def __init__(self):
super(HwModule.Config.Location, self).__init__()
self.yang_name = "location"
self.yang_parent_name = "config"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['location']
self._child_classes = OrderedDict([
("logging", ("logging", HwModule.Config.Location.Logging))
])
self._leafs = OrderedDict([
('location', (YLeaf(YType.str, 'location'), ['str'])),
])
self.location = None
self.logging = HwModule.Config.Location.Logging()
self.logging.parent = self
self._children_name_map["logging"] = "logging"
self._segment_path = lambda: "location" + "[location='" + str(
self.location) + "']"
self._absolute_path = lambda: "Cisco-IOS-XR-sysadmin-hw-module:hw-module/config/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(Ipv4arm.Addresses.Vrfs.Vrf, self).__init__()
self.yang_name = "vrf"
self.yang_parent_name = "vrfs"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['vrf_name']
self._child_classes = OrderedDict([("networks", ("networks", Ipv4arm.Addresses.Vrfs.Vrf.Networks)), ("interfaces", ("interfaces", Ipv4arm.Addresses.Vrfs.Vrf.Interfaces))])
self._leafs = OrderedDict([
('vrf_name', (YLeaf(YType.str, 'vrf-name'), ['str'])),
])
self.vrf_name = None
self.networks = Ipv4arm.Addresses.Vrfs.Vrf.Networks()
self.networks.parent = self
self._children_name_map["networks"] = "networks"
self.interfaces = Ipv4arm.Addresses.Vrfs.Vrf.Interfaces()
self.interfaces.parent = self
self._children_name_map["interfaces"] = "interfaces"
self._segment_path = lambda: "vrf" + "[vrf-name='" + str(self.vrf_name) + "']"
self._absolute_path = lambda: "Cisco-IOS-XR-ip-iarm-v4-oper:ipv4arm/addresses/vrfs/%s" % self._segment_path()
self._is_frozen = True
def __init__(self):
super(Netconf.Agent.Tty, self).__init__()
self.yang_name = "tty"
self.yang_parent_name = "agent"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = []
self._child_classes = OrderedDict([("throttle", ("throttle", Netconf.Agent.Tty.Throttle)), ("session", ("session", Netconf.Agent.Tty.Session))])
self._leafs = OrderedDict([
('enable', (YLeaf(YType.empty, 'enable'), ['Empty'])),
])
self.enable = None
self.throttle = Netconf.Agent.Tty.Throttle()
self.throttle.parent = self
self._children_name_map["throttle"] = "throttle"
self.session = Netconf.Agent.Tty.Session()
self.session.parent = self
self._children_name_map["session"] = "session"
self._segment_path = lambda: "tty"
self._absolute_path = lambda: "Cisco-IOS-XR-man-xml-ttyagent-cfg:netconf/agent/%s" % self._segment_path()
self._is_frozen = True
def __init__(self):
super(Trace.TimezoneNotify.Trace_.Location,
self).__init__()
self.yang_name = "location"
self.yang_parent_name = "trace"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = ['location_name']
self._child_classes = OrderedDict([
("all-options",
("all_options",
Trace.TimezoneNotify.Trace_.Location.AllOptions))
])
self._leafs = OrderedDict([
('location_name', (YLeaf(YType.str,
'location_name'), ['str'])),
])
self.location_name = None
self.all_options = YList(self)
self._segment_path = lambda: "location" + "[location_name='" + str(
self.location_name) + "']"
self._is_frozen = True
def __init__(self):
super(FlowSpec.Afs.Af.ServicePolicies.ServicePolicy,
self).__init__()
self.yang_name = "service-policy"
self.yang_parent_name = "service-policies"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = ['policy_name']
self._child_classes = OrderedDict([
("policy-type",
("policy_type", FlowSpec.Afs.Af.ServicePolicies.
ServicePolicy.PolicyType))
])
self._leafs = OrderedDict([
('policy_name', (YLeaf(YType.str,
'policy-name'), ['str'])),
])
self.policy_name = None
self.policy_type = YList(self)
self._segment_path = lambda: "service-policy" + "[policy-name='" + str(
self.policy_name) + "']"
self._is_frozen = True
def __init__(self):
super(PfilterMa.Nodes.Node, self).__init__()
self.yang_name = "node"
self.yang_parent_name = "nodes"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['node_name']
self._child_classes = OrderedDict([
("process", ("process", PfilterMa.Nodes.Node.Process))
])
self._leafs = OrderedDict([
('node_name', (YLeaf(YType.str, 'node-name'), ['str'])),
])
self.node_name = None
self.process = PfilterMa.Nodes.Node.Process()
self.process.parent = self
self._children_name_map["process"] = "process"
self._segment_path = lambda: "node" + "[node-name='" + str(
self.node_name) + "']"
self._absolute_path = lambda: "Cisco-IOS-XR-ip-pfilter-oper:pfilter-ma/nodes/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(NvoInstances.NvoInstance.VirtualNetwork, self).__init__()
self.yang_name = "virtual-network"
self.yang_parent_name = "nvo-instance"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = ['vni_start', 'vni_end']
self._child_container_classes = OrderedDict([
("multicast",
("multicast",
NvoInstances.NvoInstance.VirtualNetwork.Multicast))
])
self._child_list_classes = OrderedDict([
("peers", ("peers",
NvoInstances.NvoInstance.VirtualNetwork.Peers))
])
self._leafs = OrderedDict([
('vni_start', YLeaf(YType.uint32, 'vni-start')),
('vni_end', YLeaf(YType.uint32, 'vni-end')),
('suppress_arp', YLeaf(YType.empty, 'suppress-arp')),
('bgp', YLeaf(YType.empty, 'bgp')),
('end_host_discovery',
YLeaf(YType.enumeration, 'end-host-discovery')),
('routing_instance', YLeaf(YType.str, 'routing-instance')),
])
self.vni_start = None
self.vni_end = None
self.suppress_arp = None
self.bgp = None
self.end_host_discovery = None
self.routing_instance = None
self.multicast = NvoInstances.NvoInstance.VirtualNetwork.Multicast(
)
self.multicast.parent = self
self._children_name_map["multicast"] = "multicast"
self._children_yang_names.add("multicast")
self.peers = YList(self)
self._segment_path = lambda: "virtual-network" + "[vni-start='" + str(
self.vni_start) + "']" + "[vni-end='" + str(self.vni_end
) + "']"
def __init__(self):
super(
DiffservInterfacesState.DiffservInterface.
DiffservTargetEntry.
DiffservTargetClassifierStatistics.
QueuingStatistics, self).__init__()
self.yang_name = "queuing-statistics"
self.yang_parent_name = "diffserv-target-classifier-statistics"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([
("wred-stats",
("wred_stats", DiffservInterfacesState.
DiffservInterface.DiffservTargetEntry.
DiffservTargetClassifierStatistics.
QueuingStatistics.WredStats))
])
self._leafs = OrderedDict([
('output_pkts', YLeaf(YType.uint64,
'output-pkts')),
('output_bytes', YLeaf(YType.uint64,
'output-bytes')),
('queue_size_pkts',
YLeaf(YType.uint64, 'queue-size-pkts')),
('queue_size_bytes',
YLeaf(YType.uint64, 'queue-size-bytes')),
('drop_pkts', YLeaf(YType.uint64, 'drop-pkts')),
('drop_bytes', YLeaf(YType.uint64, 'drop-bytes')),
])
self.output_pkts = None
self.output_bytes = None
self.queue_size_pkts = None
self.queue_size_bytes = None
self.drop_pkts = None
self.drop_bytes = None
self.wred_stats = DiffservInterfacesState.DiffservInterface.DiffservTargetEntry.DiffservTargetClassifierStatistics.QueuingStatistics.WredStats(
)
self.wred_stats.parent = self
self._children_name_map["wred_stats"] = "wred-stats"
self._segment_path = lambda: "queuing-statistics"
def __init__(self):
super(
Pbr.Nodes.Node.PolicyMap.
Interfaces.Interface.Direction.
Input.ClassStat.HttprStats,
self).__init__()
self.yang_name = "httpr-stats"
self.yang_parent_name = "class-stat"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_container_classes = OrderedDict(
[])
self._child_list_classes = OrderedDict(
[])
self._leafs = OrderedDict([
('rqst_rcvd_packets',
YLeaf(YType.uint64,
'rqst-rcvd-packets')),
('rqst_rcvd_bytes',
YLeaf(YType.uint64,
'rqst-rcvd-bytes')),
('drop_packets',
YLeaf(YType.uint64,
'drop-packets')),
('drop_bytes',
YLeaf(YType.uint64,
'drop-bytes')),
('resp_sent_packets',
YLeaf(YType.uint64,
'resp-sent-packets')),
('resp_sent_bytes',
YLeaf(YType.uint64,
'resp-sent-bytes')),
])
self.rqst_rcvd_packets = None
self.rqst_rcvd_bytes = None
self.drop_packets = None
self.drop_bytes = None
self.resp_sent_packets = None
self.resp_sent_bytes = None
self._segment_path = lambda: "httpr-stats"
def __init__(self):
super(
INTEGRATEDSERVICESMIB.Intsrvifattribtable.
Intsrvifattribentry, self).__init__()
self.yang_name = "intSrvIfAttribEntry"
self.yang_parent_name = "intSrvIfAttribTable"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['ifindex']
self._child_container_classes = OrderedDict([])
self._child_list_classes = OrderedDict([])
self._leafs = OrderedDict([
('ifindex', YLeaf(YType.str, 'ifIndex')),
('intsrvifattriballocatedbits',
YLeaf(YType.int32, 'intSrvIfAttribAllocatedBits')),
('intsrvifattribmaxallocatedbits',
YLeaf(YType.int32, 'intSrvIfAttribMaxAllocatedBits')),
('intsrvifattriballocatedbuffer',
YLeaf(YType.int32, 'intSrvIfAttribAllocatedBuffer')),
('intsrvifattribflows',
YLeaf(YType.uint32, 'intSrvIfAttribFlows')),
('intsrvifattribpropagationdelay',
YLeaf(YType.int32, 'intSrvIfAttribPropagationDelay')),
('intsrvifattribstatus',
YLeaf(YType.enumeration, 'intSrvIfAttribStatus')),
])
self.ifindex = None
self.intsrvifattriballocatedbits = None
self.intsrvifattribmaxallocatedbits = None
self.intsrvifattriballocatedbuffer = None
self.intsrvifattribflows = None
self.intsrvifattribpropagationdelay = None
self.intsrvifattribstatus = None
self._segment_path = lambda: "intSrvIfAttribEntry" + "[ifIndex='" + str(
self.ifindex) + "']"
self._absolute_path = lambda: "INTEGRATED-SERVICES-MIB:INTEGRATED-SERVICES-MIB/intSrvIfAttribTable/%s" % self._segment_path(
)
def __init__(self):
super(
CISCOIETFATM2PVCTRAPMIBEXTN.Atmstatuschangepvclrangetable.
Atmstatuschangepvclrangeentry, self).__init__()
self.yang_name = "atmStatusChangePVclRangeEntry"
self.yang_parent_name = "atmStatusChangePVclRangeTable"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['ifindex', 'atmvclvpi', 'rangeindex']
self._child_container_classes = OrderedDict([])
self._child_list_classes = OrderedDict([])
self._leafs = OrderedDict([
('ifindex', YLeaf(YType.str, 'ifIndex')),
('atmvclvpi', YLeaf(YType.str, 'atmVclVpi')),
('rangeindex', YLeaf(YType.uint32, 'rangeIndex')),
('atmpvcllowerrangevalue',
YLeaf(YType.int32, 'atmPVclLowerRangeValue')),
('atmpvclhigherrangevalue',
YLeaf(YType.int32, 'atmPVclHigherRangeValue')),
('atmpvclrangestatuschangestart',
YLeaf(YType.uint32, 'atmPVclRangeStatusChangeStart')),
('atmpvclrangestatuschangeend',
YLeaf(YType.uint32, 'atmPVclRangeStatusChangeEnd')),
])
self.ifindex = None
self.atmvclvpi = None
self.rangeindex = None
self.atmpvcllowerrangevalue = None
self.atmpvclhigherrangevalue = None
self.atmpvclrangestatuschangestart = None
self.atmpvclrangestatuschangeend = None
self._segment_path = lambda: "atmStatusChangePVclRangeEntry" + "[ifIndex='" + str(
self.ifindex) + "']" + "[atmVclVpi='" + str(
self.atmvclvpi) + "']" + "[rangeIndex='" + str(
self.rangeindex) + "']"
self._absolute_path = lambda: "CISCO-IETF-ATM2-PVCTRAP-MIB-EXTN:CISCO-IETF-ATM2-PVCTRAP-MIB-EXTN/atmStatusChangePVclRangeTable/%s" % self._segment_path(
)
def __init__(self):
super(CISCOBULKFILEMIB.Cbfdefinefiletable.Cbfdefinefileentry,
self).__init__()
self.yang_name = "cbfDefineFileEntry"
self.yang_parent_name = "cbfDefineFileTable"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['cbfdefinefileindex']
self._child_container_classes = OrderedDict([])
self._child_list_classes = OrderedDict([])
self._leafs = OrderedDict([
('cbfdefinefileindex',
YLeaf(YType.uint32, 'cbfDefineFileIndex')),
('cbfdefinefilename', YLeaf(YType.str,
'cbfDefineFileName')),
('cbfdefinefilestorage',
YLeaf(YType.enumeration, 'cbfDefineFileStorage')),
('cbfdefinefileformat',
YLeaf(YType.enumeration, 'cbfDefineFileFormat')),
('cbfdefinefilenow',
YLeaf(YType.enumeration, 'cbfDefineFileNow')),
('cbfdefinefileentrystatus',
YLeaf(YType.enumeration, 'cbfDefineFileEntryStatus')),
('cbfdefinefilenotifyoncompletion',
YLeaf(YType.boolean, 'cbfDefineFileNotifyOnCompletion')),
])
self.cbfdefinefileindex = None
self.cbfdefinefilename = None
self.cbfdefinefilestorage = None
self.cbfdefinefileformat = None
self.cbfdefinefilenow = None
self.cbfdefinefileentrystatus = None
self.cbfdefinefilenotifyoncompletion = None
self._segment_path = lambda: "cbfDefineFileEntry" + "[cbfDefineFileIndex='" + str(
self.cbfdefinefileindex) + "']"
self._absolute_path = lambda: "CISCO-BULK-FILE-MIB:CISCO-BULK-FILE-MIB/cbfDefineFileTable/%s" % self._segment_path(
)
def __init__(self):
super(TUNNELMIB.Tunnelconfigtable.Tunnelconfigentry,
self).__init__()
self.yang_name = "tunnelConfigEntry"
self.yang_parent_name = "tunnelConfigTable"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = [
'tunnelconfiglocaladdress', 'tunnelconfigremoteaddress',
'tunnelconfigencapsmethod', 'tunnelconfigid'
]
self._child_container_classes = OrderedDict([])
self._child_list_classes = OrderedDict([])
self._leafs = OrderedDict([
('tunnelconfiglocaladdress',
YLeaf(YType.str, 'tunnelConfigLocalAddress')),
('tunnelconfigremoteaddress',
YLeaf(YType.str, 'tunnelConfigRemoteAddress')),
('tunnelconfigencapsmethod',
YLeaf(YType.enumeration, 'tunnelConfigEncapsMethod')),
('tunnelconfigid', YLeaf(YType.int32, 'tunnelConfigID')),
('tunnelconfigifindex',
YLeaf(YType.int32, 'tunnelConfigIfIndex')),
('tunnelconfigstatus',
YLeaf(YType.enumeration, 'tunnelConfigStatus')),
])
self.tunnelconfiglocaladdress = None
self.tunnelconfigremoteaddress = None
self.tunnelconfigencapsmethod = None
self.tunnelconfigid = None
self.tunnelconfigifindex = None
self.tunnelconfigstatus = None
self._segment_path = lambda: "tunnelConfigEntry" + "[tunnelConfigLocalAddress='" + str(
self.tunnelconfiglocaladdress
) + "']" + "[tunnelConfigRemoteAddress='" + str(
self.tunnelconfigremoteaddress
) + "']" + "[tunnelConfigEncapsMethod='" + str(
self.tunnelconfigencapsmethod
) + "']" + "[tunnelConfigID='" + str(self.tunnelconfigid
) + "']"
self._absolute_path = lambda: "TUNNEL-MIB:TUNNEL-MIB/tunnelConfigTable/%s" % self._segment_path(
)
def __init__(self):
super(ProcessesMemory.Nodes.Node.JobIds.JobId,
self).__init__()
self.yang_name = "job-id"
self.yang_parent_name = "job-ids"
self.job_id = YLeaf(YType.int32, "job-id")
self.data_seg_size = YLeaf(YType.uint32,
"data-seg-size")
self.jid = YLeaf(YType.uint32, "jid")
self.malloc_size = YLeaf(YType.uint32, "malloc-size")
self.name = YLeaf(YType.str, "name")
self.stack_seg_size = YLeaf(YType.uint32,
"stack-seg-size")
self.text_seg_size = YLeaf(YType.uint32,
"text-seg-size")
def __init__(self):
super(CISCOIGMPFILTERMIB.Cigmpfiltertable.Cigmpfilterentry,
self).__init__()
self.yang_name = "cIgmpFilterEntry"
self.yang_parent_name = "cIgmpFilterTable"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = [
'cigmpfilterprofileindex', 'cigmpfilterstartaddresstype',
'cigmpfilterstartaddress'
]
self._child_container_classes = OrderedDict([])
self._child_list_classes = OrderedDict([])
self._leafs = OrderedDict([
('cigmpfilterprofileindex',
YLeaf(YType.uint32, 'cIgmpFilterProfileIndex')),
('cigmpfilterstartaddresstype',
YLeaf(YType.enumeration, 'cIgmpFilterStartAddressType')),
('cigmpfilterstartaddress',
YLeaf(YType.str, 'cIgmpFilterStartAddress')),
('cigmpfilterendaddresstype',
YLeaf(YType.enumeration, 'cIgmpFilterEndAddressType')),
('cigmpfilterendaddress',
YLeaf(YType.str, 'cIgmpFilterEndAddress')),
('cigmpfilterprofileaction',
YLeaf(YType.enumeration, 'cIgmpFilterProfileAction')),
])
self.cigmpfilterprofileindex = None
self.cigmpfilterstartaddresstype = None
self.cigmpfilterstartaddress = None
self.cigmpfilterendaddresstype = None
self.cigmpfilterendaddress = None
self.cigmpfilterprofileaction = None
self._segment_path = lambda: "cIgmpFilterEntry" + "[cIgmpFilterProfileIndex='" + str(
self.cigmpfilterprofileindex
) + "']" + "[cIgmpFilterStartAddressType='" + str(
self.cigmpfilterstartaddresstype
) + "']" + "[cIgmpFilterStartAddress='" + str(
self.cigmpfilterstartaddress) + "']"
self._absolute_path = lambda: "CISCO-IGMP-FILTER-MIB:CISCO-IGMP-FILTER-MIB/cIgmpFilterTable/%s" % self._segment_path(
)
def __init__(self):
super(Components.Component.State, self).__init__()
self.yang_name = "state"
self.yang_parent_name = "component"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([
("temp", ("temp", Components.Component.State.Temp))
])
self._leafs = OrderedDict([
('type', (YLeaf(YType.enumeration, 'type'), [
('ydk.models.cisco_ios_xe.Cisco_IOS_XE_platform_oper',
'PlatformCompType', '')
])),
('id', (YLeaf(YType.str, 'id'), ['str'])),
('description', (YLeaf(YType.str,
'description'), ['str'])),
('mfg_name', (YLeaf(YType.str, 'mfg-name'), ['str'])),
('version', (YLeaf(YType.str, 'version'), ['str'])),
('serial_no', (YLeaf(YType.str, 'serial-no'), ['str'])),
('part_no', (YLeaf(YType.str, 'part-no'), ['str'])),
])
self.type = None
self.id = None
self.description = None
self.mfg_name = None
self.version = None
self.serial_no = None
self.part_no = None
self.temp = Components.Component.State.Temp()
self.temp.parent = self
self._children_name_map["temp"] = "temp"
self._segment_path = lambda: "state"
self._is_frozen = True
def __init__(self):
super(
MplsForwardingTable.LocalLabelEntry.ForwardingInfo.
ConnectionInfo, self).__init__()
self.yang_name = "connection-info"
self.yang_parent_name = "forwarding-info"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([
("tunnel-tp",
("tunnel_tp", MplsForwardingTable.LocalLabelEntry.
ForwardingInfo.ConnectionInfo.TunnelTp))
])
self._leafs = OrderedDict([
('type', YLeaf(YType.enumeration, 'type')),
('ip', YLeaf(YType.str, 'ip')),
('mask', YLeaf(YType.uint16, 'mask')),
('tunnel_id', YLeaf(YType.uint32, 'tunnel-id')),
('vrf_id', YLeaf(YType.uint32, 'vrf-id')),
('nh_id', YLeaf(YType.uint32, 'nh-id')),
('l2ckt_id', YLeaf(YType.uint32, 'l2ckt-id')),
])
self.type = None
self.ip = None
self.mask = None
self.tunnel_id = None
self.vrf_id = None
self.nh_id = None
self.l2ckt_id = None
self.tunnel_tp = MplsForwardingTable.LocalLabelEntry.ForwardingInfo.ConnectionInfo.TunnelTp(
)
self.tunnel_tp.parent = self
self._children_name_map["tunnel_tp"] = "tunnel-tp"
self._segment_path = lambda: "connection-info"
def __init__(self):
if sys.version_info > (3, ):
super().__init__()
else:
super(
Sbfd.TargetIdentifier.LocalVrfs.LocalVrf.
LocalDiscriminator, self).__init__()
self.yang_name = "local-discriminator"
self.yang_parent_name = "local-vrf"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([])
self._leafs = OrderedDict([
('local_discriminator',
(YLeaf(YType.uint32,
'local-discriminator'), ['int'])),
('vrf_name', (YLeaf(YType.str,
'vrf-name'), ['str'])),
('discr', (YLeaf(YType.uint32, 'discr'), ['int'])),
('vrf_name_xr', (YLeaf(YType.str,
'vrf-name-xr'), ['str'])),
('flags', (YLeaf(YType.str, 'flags'), ['str'])),
('status', (YLeaf(YType.str, 'status'), ['str'])),
('discr_src', (YLeaf(YType.str,
'discr-src'), ['str'])),
])
self.local_discriminator = None
self.vrf_name = None
self.discr = None
self.vrf_name_xr = None
self.flags = None
self.status = None
self.discr_src = None
self._segment_path = lambda: "local-discriminator"
self._is_frozen = True
def __init__(self):
super(
Ipv6Arm.Addresses.Vrfs.Vrf.Interfaces.
Interface.Address, self).__init__()
self.yang_name = "address"
self.yang_parent_name = "interface"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_container_classes = OrderedDict([
("address",
("address", Ipv6Arm.Addresses.Vrfs.Vrf.
Interfaces.Interface.Address.Address_))
])
self._child_list_classes = OrderedDict([])
self._leafs = OrderedDict([
('prefix_length',
YLeaf(YType.uint32, 'prefix-length')),
('route_tag',
YLeaf(YType.uint32, 'route-tag')),
('is_primary',
YLeaf(YType.boolean, 'is-primary')),
('is_tentative',
YLeaf(YType.boolean, 'is-tentative')),
('is_prefix_sid',
YLeaf(YType.boolean, 'is-prefix-sid')),
('producer', YLeaf(YType.str, 'producer')),
])
self.prefix_length = None
self.route_tag = None
self.is_primary = None
self.is_tentative = None
self.is_prefix_sid = None
self.producer = None
self.address = Ipv6Arm.Addresses.Vrfs.Vrf.Interfaces.Interface.Address.Address_(
)
self.address.parent = self
self._children_name_map["address"] = "address"
self._children_yang_names.add("address")
self._segment_path = lambda: "address"
def __init__(self):
super(StpDetails.StpGlobal, self).__init__()
self.yang_name = "stp-global"
self.yang_parent_name = "stp-details"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = []
self._child_classes = OrderedDict([
("mst-only", ("mst_only", StpDetails.StpGlobal.MstOnly))
])
self.is_presence_container = True
self._leafs = OrderedDict([
('mode', (YLeaf(YType.enumeration, 'mode'), [
('ydk.models.cisco_ios_xe.Cisco_IOS_XE_spanning_tree_oper',
'StpMode', '')
])),
('bridge_assurance', (YLeaf(YType.empty,
'bridge-assurance'), ['Empty'])),
('loop_guard', (YLeaf(YType.empty, 'loop-guard'), ['Empty'])),
('bpdu_guard', (YLeaf(YType.empty, 'bpdu-guard'), ['Empty'])),
('bpdu_filter', (YLeaf(YType.empty,
'bpdu-filter'), ['Empty'])),
('etherchannel_misconfig_guard',
(YLeaf(YType.empty,
'etherchannel-misconfig-guard'), ['Empty'])),
])
self.mode = None
self.bridge_assurance = None
self.loop_guard = None
self.bpdu_guard = None
self.bpdu_filter = None
self.etherchannel_misconfig_guard = None
self.mst_only = StpDetails.StpGlobal.MstOnly()
self.mst_only.parent = self
self._children_name_map["mst_only"] = "mst-only"
self._segment_path = lambda: "stp-global"
self._absolute_path = lambda: "Cisco-IOS-XE-spanning-tree-oper:stp-details/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(
SNMPTARGETMIB.Snmptargetparamstable.Snmptargetparamsentry,
self).__init__()
self.yang_name = "snmpTargetParamsEntry"
self.yang_parent_name = "snmpTargetParamsTable"
self.is_top_level_class = False
self.has_list_ancestor = False
self._child_container_classes = {}
self._child_list_classes = {}
self.snmptargetparamsname = YLeaf(YType.str,
"snmpTargetParamsName")
self.snmptargetparamsmpmodel = YLeaf(
YType.int32, "snmpTargetParamsMPModel")
self.snmptargetparamssecuritymodel = YLeaf(
YType.int32, "snmpTargetParamsSecurityModel")
self.snmptargetparamssecurityname = YLeaf(
YType.str, "snmpTargetParamsSecurityName")
self.snmptargetparamssecuritylevel = YLeaf(
YType.enumeration, "snmpTargetParamsSecurityLevel")
self.snmptargetparamsstoragetype = YLeaf(
YType.enumeration, "snmpTargetParamsStorageType")
self.snmptargetparamsrowstatus = YLeaf(
YType.enumeration, "snmpTargetParamsRowStatus")
self._segment_path = lambda: "snmpTargetParamsEntry" + "[snmpTargetParamsName='" + self.snmptargetparamsname.get(
) + "']"
self._absolute_path = lambda: "SNMP-TARGET-MIB:SNMP-TARGET-MIB/snmpTargetParamsTable/%s" % self._segment_path(
)
def __init__(self):
super(
MplsForwardingTable.LocalLabelEntry.ForwardingInfo.
ConnectionInfo, self).__init__()
self.yang_name = "connection-info"
self.yang_parent_name = "forwarding-info"
self.is_top_level_class = False
self.has_list_ancestor = True
self._child_container_classes = {
"tunnel-tp":
("tunnel_tp", MplsForwardingTable.LocalLabelEntry.
ForwardingInfo.ConnectionInfo.TunnelTp)
}
self._child_list_classes = {}
self.type = YLeaf(YType.enumeration, "type")
self.ip = YLeaf(YType.str, "ip")
self.mask = YLeaf(YType.uint16, "mask")
self.tunnel_id = YLeaf(YType.uint32, "tunnel-id")
self.vrf_id = YLeaf(YType.uint32, "vrf-id")
self.nh_id = YLeaf(YType.uint32, "nh-id")
self.l2ckt_id = YLeaf(YType.uint32, "l2ckt-id")
self.tunnel_tp = MplsForwardingTable.LocalLabelEntry.ForwardingInfo.ConnectionInfo.TunnelTp(
)
self.tunnel_tp.parent = self
self._children_name_map["tunnel_tp"] = "tunnel-tp"
self._children_yang_names.add("tunnel-tp")
self._segment_path = lambda: "connection-info"
def __init__(self):
super(Fpd_.Nodes.Node.Devices.Device, self).__init__()
self.yang_name = "device"
self.yang_parent_name = "devices"
self.is_top_level_class = False
self.has_list_ancestor = True
self._child_container_classes = {}
self._child_list_classes = {}
self.fpd_type = YLeaf(YType.enumeration, "fpd-type")
self.instance = YLeaf(YType.int32, "instance")
self.sub_type = YLeaf(YType.enumeration, "sub-type")
self.card_type = YLeaf(YType.str, "card-type")
self.hardware_version = YLeaf(YType.str, "hardware-version")
self.software_version = YLeaf(YType.str, "software-version")
self.is_upgrade_downgrade = YLeaf(YType.boolean, "is-upgrade-downgrade")
self._segment_path = lambda: "device"
def __init__(self):
super(Cofo.Nodes.Node.TopicIds.TopicId.DatabaseInfoStruct.ClientDbInfoStruct.CofoObjectPublishedArray, self).__init__()
self.yang_name = "cofo-object-published-array"
self.yang_parent_name = "client-db-info-struct"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([("object-add-time", ("object_add_time", Cofo.Nodes.Node.TopicIds.TopicId.DatabaseInfoStruct.ClientDbInfoStruct.CofoObjectPublishedArray.ObjectAddTime)), ("object-delete-time", ("object_delete_time", Cofo.Nodes.Node.TopicIds.TopicId.DatabaseInfoStruct.ClientDbInfoStruct.CofoObjectPublishedArray.ObjectDeleteTime)), ("object-txl-add-time", ("object_txl_add_time", Cofo.Nodes.Node.TopicIds.TopicId.DatabaseInfoStruct.ClientDbInfoStruct.CofoObjectPublishedArray.ObjectTxlAddTime)), ("object-txl-encode-time", ("object_txl_encode_time", Cofo.Nodes.Node.TopicIds.TopicId.DatabaseInfoStruct.ClientDbInfoStruct.CofoObjectPublishedArray.ObjectTxlEncodeTime))])
self._leafs = OrderedDict([
('client_id', (YLeaf(YType.uint32, 'client-id'), ['int'])),
('object_id', (YLeaf(YType.uint32, 'object-id'), ['int'])),
('insert_count', (YLeaf(YType.uint32, 'insert-count'), ['int'])),
('item_state', (YLeaf(YType.uint32, 'item-state'), ['int'])),
('cofo_infra_object_key', (YLeaf(YType.str, 'cofo-infra-object-key'), ['str'])),
('cofo_infra_object_value', (YLeaf(YType.str, 'cofo-infra-object-value'), ['str'])),
])
self.client_id = None
self.object_id = None
self.insert_count = None
self.item_state = None
self.cofo_infra_object_key = None
self.cofo_infra_object_value = None
self.object_add_time = Cofo.Nodes.Node.TopicIds.TopicId.DatabaseInfoStruct.ClientDbInfoStruct.CofoObjectPublishedArray.ObjectAddTime()
self.object_add_time.parent = self
self._children_name_map["object_add_time"] = "object-add-time"
self.object_delete_time = Cofo.Nodes.Node.TopicIds.TopicId.DatabaseInfoStruct.ClientDbInfoStruct.CofoObjectPublishedArray.ObjectDeleteTime()
self.object_delete_time.parent = self
self._children_name_map["object_delete_time"] = "object-delete-time"
self.object_txl_add_time = Cofo.Nodes.Node.TopicIds.TopicId.DatabaseInfoStruct.ClientDbInfoStruct.CofoObjectPublishedArray.ObjectTxlAddTime()
self.object_txl_add_time.parent = self
self._children_name_map["object_txl_add_time"] = "object-txl-add-time"
self.object_txl_encode_time = Cofo.Nodes.Node.TopicIds.TopicId.DatabaseInfoStruct.ClientDbInfoStruct.CofoObjectPublishedArray.ObjectTxlEncodeTime()
self.object_txl_encode_time.parent = self
self._children_name_map["object_txl_encode_time"] = "object-txl-encode-time"
self._segment_path = lambda: "cofo-object-published-array"
self._is_frozen = True
def __init__(self):
super(
Controller.Dpa.Nodes.Node.
InternalTcamResources.NpuTcam.TcamBank,
self).__init__()
self.yang_name = "tcam-bank"
self.yang_parent_name = "npu-tcam"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_container_classes = OrderedDict([])
self._child_list_classes = OrderedDict([
("bank-db",
("bank_db", Controller.Dpa.Nodes.Node.
InternalTcamResources.NpuTcam.TcamBank.
BankDb))
])
self._leafs = OrderedDict([
('bank_id', YLeaf(YType.str, 'bank-id')),
('bank_key_size',
YLeaf(YType.str, 'bank-key-size')),
('bank_free_entries',
YLeaf(YType.uint32, 'bank-free-entries')),
('bank_inuse_entries',
YLeaf(YType.uint32,
'bank-inuse-entries')),
('owner', YLeaf(YType.str, 'owner')),
('nof_dbs', YLeaf(YType.uint32,
'nof-dbs')),
])
self.bank_id = None
self.bank_key_size = None
self.bank_free_entries = None
self.bank_inuse_entries = None
self.owner = None
self.nof_dbs = None
self.bank_db = YList(self)
self._segment_path = lambda: "tcam-bank"
def __init__(self):
super(CISCOCONFIGCOPYMIB.CcCopyErrorTable.CcCopyErrorEntry,
self).__init__()
self.yang_name = "ccCopyErrorEntry"
self.yang_parent_name = "ccCopyErrorTable"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['cccopyindex', 'cccopyerrorindex']
self._child_classes = OrderedDict([])
self._leafs = OrderedDict([
('cccopyindex', (YLeaf(YType.str,
'ccCopyIndex'), ['int'])),
('cccopyerrorindex', (YLeaf(YType.uint32,
'ccCopyErrorIndex'), ['int'])),
('cccopyerrordeviceipaddresstype',
(YLeaf(YType.enumeration,
'ccCopyErrorDeviceIpAddressType'),
[('ydk.models.cisco_ios_xe.INET_ADDRESS_MIB',
'InetAddressType', '')])),
('cccopyerrordeviceipaddress',
(YLeaf(YType.str,
'ccCopyErrorDeviceIpAddress'), ['str'])),
('cccopyerrordevicewwn',
(YLeaf(YType.str, 'ccCopyErrorDeviceWWN'), ['str'])),
('cccopyerrordescription',
(YLeaf(YType.str, 'ccCopyErrorDescription'), ['str'])),
])
self.cccopyindex = None
self.cccopyerrorindex = None
self.cccopyerrordeviceipaddresstype = None
self.cccopyerrordeviceipaddress = None
self.cccopyerrordevicewwn = None
self.cccopyerrordescription = None
self._segment_path = lambda: "ccCopyErrorEntry" + "[ccCopyIndex='" + str(
self.cccopyindex) + "']" + "[ccCopyErrorIndex='" + str(
self.cccopyerrorindex) + "']"
self._absolute_path = lambda: "CISCO-CONFIG-COPY-MIB:CISCO-CONFIG-COPY-MIB/ccCopyErrorTable/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(UtdOperData.UtdEngineStatus, self).__init__()
self.yang_name = "utd-engine-status"
self.yang_parent_name = "utd-oper-data"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = []
self._child_classes = OrderedDict([
("utd-engine-instance-status",
("utd_engine_instance_status",
UtdOperData.UtdEngineStatus.UtdEngineInstanceStatus))
])
self.is_presence_container = True
self._leafs = OrderedDict([
('version', (YLeaf(YType.str, 'version'), ['str'])),
('profile', (YLeaf(YType.str, 'profile'), ['str'])),
('status', (YLeaf(YType.enumeration, 'status'),
[('ydk.models.cisco_ios_xe.Cisco_IOS_XE_utd_oper',
'UtdOperStatusVal', '')])),
('reason', (YLeaf(YType.str, 'reason'), ['str'])),
('memory_usage', (YLeaf(YType.str,
'memory-usage'), ['Decimal64'])),
('memory_status', (YLeaf(YType.enumeration, 'memory-status'), [
('ydk.models.cisco_ios_xe.Cisco_IOS_XE_utd_oper',
'UtdOperStatusVal', '')
])),
])
self.version = None
self.profile = None
self.status = None
self.reason = None
self.memory_usage = None
self.memory_status = None
self.utd_engine_instance_status = YList(self)
self._segment_path = lambda: "utd-engine-status"
self._absolute_path = lambda: "Cisco-IOS-XE-utd-oper:utd-oper-data/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(Ipv6Arm.Addresses.Vrfs.Vrf.Networks.Network,
self).__init__()
self.yang_name = "network"
self.yang_parent_name = "networks"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_container_classes = OrderedDict([
("address-xr",
("address_xr", Ipv6Arm.Addresses.Vrfs.Vrf.
Networks.Network.AddressXr))
])
self._child_list_classes = OrderedDict([])
self._leafs = OrderedDict([
('address', YLeaf(YType.str, 'address')),
('prefix_length',
YLeaf(YType.uint32, 'prefix-length')),
('handle', YLeaf(YType.str, 'handle')),
('interface_name',
YLeaf(YType.str, 'interface-name')),
('referenced_interface',
YLeaf(YType.str, 'referenced-interface')),
('vrf_name', YLeaf(YType.str, 'vrf-name')),
])
self.address = None
self.prefix_length = None
self.handle = None
self.interface_name = None
self.referenced_interface = None
self.vrf_name = None
self.address_xr = Ipv6Arm.Addresses.Vrfs.Vrf.Networks.Network.AddressXr(
)
self.address_xr.parent = self
self._children_name_map[
"address_xr"] = "address-xr"
self._children_yang_names.add("address-xr")
self._segment_path = lambda: "network"
def __init__(self):
super(
BfdState.Sessions.Session.BfdTunnelPaths.
BfdTunnelPath, self).__init__()
self.yang_name = "bfd-tunnel-path"
self.yang_parent_name = "bfd-tunnel-paths"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = ['interface', 'lsp_type']
self._child_classes = OrderedDict([])
self._leafs = OrderedDict([
('interface', (YLeaf(YType.str,
'interface'), ['str'])),
('lsp_type',
(YLeaf(YType.enumeration, 'lsp-type'),
[('ydk.models.cisco_ios_xe.Cisco_IOS_XE_bfd_oper',
'BfdLspType', '')])),
('ld', (YLeaf(YType.uint32, 'ld'), ['int'])),
('rd', (YLeaf(YType.uint32, 'rd'), ['int'])),
('remote_state',
(YLeaf(YType.enumeration, 'remote-state'),
[('ydk.models.cisco_ios_xe.Cisco_IOS_XE_bfd_oper',
'BfdRemoteStateType', '')])),
('state',
(YLeaf(YType.enumeration, 'state'),
[('ydk.models.cisco_ios_xe.Cisco_IOS_XE_bfd_oper',
'BfdStateType', '')])),
])
self.interface = None
self.lsp_type = None
self.ld = None
self.rd = None
self.remote_state = None
self.state = None
self._segment_path = lambda: "bfd-tunnel-path" + "[interface='" + str(
self.interface) + "']" + "[lsp-type='" + str(
self.lsp_type) + "']"
self._is_frozen = True
def __init__(self):
super(
Lacp.Interfaces.Interface.Members.Member.
State.Counters, self).__init__()
self.yang_name = "counters"
self.yang_parent_name = "state"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([])
self._leafs = OrderedDict([
('lacp_in_pkts',
(YLeaf(YType.uint64,
'lacp-in-pkts'), ['int'])),
('lacp_out_pkts',
(YLeaf(YType.uint64,
'lacp-out-pkts'), ['int'])),
('lacp_rx_errors',
(YLeaf(YType.uint64,
'lacp-rx-errors'), ['int'])),
('lacp_tx_errors',
(YLeaf(YType.uint64,
'lacp-tx-errors'), ['int'])),
('lacp_unknown_errors',
(YLeaf(YType.uint64,
'lacp-unknown-errors'), ['int'])),
('lacp_errors',
(YLeaf(YType.uint64,
'lacp-errors'), ['int'])),
])
self.lacp_in_pkts = None
self.lacp_out_pkts = None
self.lacp_rx_errors = None
self.lacp_tx_errors = None
self.lacp_unknown_errors = None
self.lacp_errors = None
self._segment_path = lambda: "counters"
self._is_frozen = True
