def __init__(self):
super(User, self).__init__()
self._top_entity = None
self.yang_name = "user"
self.yang_parent_name = "tailf-aaa"
self.is_top_level_class = True
self.has_list_ancestor = False
self.ylist_key_names = ['name']
self._child_classes = OrderedDict([("alias", ("alias", User.Alias)), ("session", ("session", User.Session))])
self._leafs = OrderedDict([
('name', YLeaf(YType.str, 'name')),
('description', YLeaf(YType.str, 'description')),
])
self.name = None
self.description = None
self.session = User.Session()
self.session.parent = self
self._children_name_map["session"] = "session"
self.alias = YList(self)
self._segment_path = lambda: "tailf-aaa:user" + "[name='" + str(self.name) + "']"
def __init__(self):
if sys.version_info > (3,):
super().__init__()
else:
super(AaaNacm.Users.User, self).__init__()
self.yang_name = "user"
self.yang_parent_name = "users"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['user']
self._child_classes = OrderedDict([("group-name", ("group_name", AaaNacm.Users.User.GroupName))])
self._leafs = OrderedDict([
('user', (YLeaf(YType.str, 'user'), ['str'])),
('user_name', (YLeaf(YType.str, 'user-name'), ['str'])),
])
self.user = None
self.user_name = None
self.group_name = YList(self)
self._segment_path = lambda: "user" + "[user='******']"
self._absolute_path = lambda: "Cisco-IOS-XR-aaa-nacm-oper:aaa-nacm/users/%s" % self._segment_path()
self._is_frozen = True
def __init__(self):
super(Ntp.Trace.NtpHelper.Trace_, self).__init__()
self.yang_name = "trace"
self.yang_parent_name = "ntp_helper"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['buffer']
self._child_classes = OrderedDict([
("location", ("location",
Ntp.Trace.NtpHelper.Trace_.Location))
])
self._leafs = OrderedDict([
('buffer', (YLeaf(YType.str, 'buffer'), ['str'])),
])
self.buffer = None
self.location = YList(self)
self._segment_path = lambda: "trace" + "[buffer='" + str(
self.buffer) + "']"
self._absolute_path = lambda: "ntp:ntp/trace/ntp_helper/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(KeyChains, self).__init__()
self._top_entity = None
self.yang_name = "key-chains"
self.yang_parent_name = "ietf-key-chain"
self.is_top_level_class = True
self.has_list_ancestor = False
self._child_container_classes = {
"accept-tolerance": ("accept_tolerance", KeyChains.AcceptTolerance)
}
self._child_list_classes = {"key": ("key", KeyChains.Key)}
self.name = YLeaf(YType.str, "name")
self.accept_tolerance = KeyChains.AcceptTolerance()
self.accept_tolerance.parent = self
self._children_name_map["accept_tolerance"] = "accept-tolerance"
self._children_yang_names.add("accept-tolerance")
self.key = YList(self)
self._segment_path = lambda: "ietf-key-chain:key-chains" + "[name='" + self.name.get(
) + "']"
def __init__(self):
super(Ping.Output.PingResponse, self).__init__()
self.yang_name = "ping-response"
self.yang_parent_name = "output"
self.is_top_level_class = False
self.has_list_ancestor = False
self._child_container_classes = {
"ipv6": ("ipv6", Ping.Output.PingResponse.Ipv6)
}
self._child_list_classes = {
"ipv4": ("ipv4", Ping.Output.PingResponse.Ipv4)
}
self.ipv6 = Ping.Output.PingResponse.Ipv6()
self.ipv6.parent = self
self._children_name_map["ipv6"] = "ipv6"
self._children_yang_names.add("ipv6")
self.ipv4 = YList(self)
self._segment_path = lambda: "ping-response"
self._absolute_path = lambda: "Cisco-IOS-XR-ping-act:ping/output/%s" % self._segment_path(
)
def __init__(self):
super(ShowFpd.HwModuleFpd, self).__init__()
self.yang_name = "hw-module-fpd"
self.yang_parent_name = "show-fpd"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = []
self._child_classes = OrderedDict([
("fpd-info-detaile", ("fpd_info_detaile",
ShowFpd.HwModuleFpd.FpdInfoDetaile))
])
self._leafs = OrderedDict([
('upgrade_status', (YLeaf(YType.str,
'upgrade-status'), ['str'])),
])
self.upgrade_status = None
self.fpd_info_detaile = YList(self)
self._segment_path = lambda: "hw-module-fpd"
self._absolute_path = lambda: "Cisco-IOS-XR-show-fpd-loc-ng-oper:show-fpd/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
if sys.version_info > (3, ):
super().__init__()
else:
super(SNMPUSERBASEDSMMIB.UsmUserTable, self).__init__()
self.yang_name = "usmUserTable"
self.yang_parent_name = "SNMP-USER-BASED-SM-MIB"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = []
self._child_classes = OrderedDict([
("usmUserEntry",
("usmuserentry",
SNMPUSERBASEDSMMIB.UsmUserTable.UsmUserEntry))
])
self._leafs = OrderedDict()
self.usmuserentry = YList(self)
self._segment_path = lambda: "usmUserTable"
self._absolute_path = lambda: "SNMP-USER-BASED-SM-MIB:SNMP-USER-BASED-SM-MIB/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(StartQuery.Input, self).__init__()
self.yang_name = "input"
self.yang_parent_name = "start-query"
self.is_top_level_class = False
self.has_list_ancestor = False
self._child_container_classes = {}
self._child_list_classes = {"select" : ("select", StartQuery.Input.Select)}
self.foreach = YLeaf(YType.str, "foreach")
self.sort_by = YLeafList(YType.str, "sort-by")
self.limit = YLeaf(YType.uint32, "limit")
self.offset = YLeaf(YType.uint32, "offset")
self.timeout = YLeaf(YType.uint32, "timeout")
self.select = YList(self)
self._segment_path = lambda: "input"
self._absolute_path = lambda: "tailf-netconf-query:start-query/%s" % self._segment_path()
def __init__(self):
super(RebootHistory.Node, self).__init__()
self.yang_name = "node"
self.yang_parent_name = "reboot-history"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['node_name']
self._child_classes = OrderedDict([
("reboot-history", ("reboot_history",
RebootHistory.Node.RebootHistory_))
])
self._leafs = OrderedDict([
('node_name', (YLeaf(YType.str, 'node-name'), ['str'])),
])
self.node_name = None
self.reboot_history = YList(self)
self._segment_path = lambda: "node" + "[node-name='" + str(
self.node_name) + "']"
self._absolute_path = lambda: "Cisco-IOS-XR-reboot-history-oper:reboot-history/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(AaaData.AaaUsers, self).__init__()
self.yang_name = "aaa-users"
self.yang_parent_name = "aaa-data"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['username']
self._child_classes = OrderedDict([
("aaa-sessions", ("aaa_sessions",
AaaData.AaaUsers.AaaSessions))
])
self._leafs = OrderedDict([
('username', (YLeaf(YType.str, 'username'), ['str'])),
])
self.username = None
self.aaa_sessions = YList(self)
self._segment_path = lambda: "aaa-users" + "[username='******']"
self._absolute_path = lambda: "Cisco-IOS-XE-aaa-oper:aaa-data/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(Classifiers.ClassifierEntry.FilterEntry, self).__init__()
self.yang_name = "filter-entry"
self.yang_parent_name = "classifier-entry"
self.is_top_level_class = False
self.has_list_ancestor = True
self._child_container_classes = {}
self._child_list_classes = {
"dscp-cfg":
("dscp_cfg",
Classifiers.ClassifierEntry.FilterEntry.DscpCfg),
"source-ip-address-cfg":
("source_ip_address_cfg",
Classifiers.ClassifierEntry.FilterEntry.SourceIpAddressCfg
),
"destination-ip-address-cfg":
("destination_ip_address_cfg", Classifiers.ClassifierEntry.
FilterEntry.DestinationIpAddressCfg),
"source-port-cfg":
("source_port_cfg",
Classifiers.ClassifierEntry.FilterEntry.SourcePortCfg),
"destination-port-cfg":
("destination_port_cfg",
Classifiers.ClassifierEntry.FilterEntry.DestinationPortCfg
),
"protocol-cfg":
("protocol_cfg",
Classifiers.ClassifierEntry.FilterEntry.ProtocolCfg)
}
self.filter_type = YLeaf(YType.identityref, "filter-type")
self.filter_logical_not = YLeaf(YType.boolean,
"filter-logical-not")
self.dscp_cfg = YList(self)
self.source_ip_address_cfg = YList(self)
self.destination_ip_address_cfg = YList(self)
self.source_port_cfg = YList(self)
self.destination_port_cfg = YList(self)
self.protocol_cfg = YList(self)
self._segment_path = lambda: "filter-entry" + "[filter-type='" + self.filter_type.get(
) + "']" + "[filter-logical-not='" + self.filter_logical_not.get(
) + "']"
def __init__(self):
super(HwModule.SliceAll.SliceInfo.ClientPort,
self).__init__()
self.yang_name = "client-port"
self.yang_parent_name = "slice-info"
self.is_top_level_class = False
self.has_list_ancestor = False
self._child_container_classes = {}
self._child_list_classes = {
"trunk-port":
("trunk_port",
HwModule.SliceAll.SliceInfo.ClientPort.TrunkPort)
}
self.client_name = YLeaf(YType.str, "client-name")
self.if_index = YLeaf(YType.uint32, "if-index")
self.trunk_port = YList(self)
self._segment_path = lambda: "client-port"
self._absolute_path = lambda: "Cisco-IOS-XR-ncs1k-mxp-oper:hw-module/slice-all/slice-info/%s" % self._segment_path(
)
def __init__(self):
super(Vlans.Vlan, self).__init__()
self.yang_name = "vlan"
self.yang_parent_name = "vlans"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['id']
self._child_classes = OrderedDict([("ports", ("ports",
Vlans.Vlan.Ports))])
self._leafs = OrderedDict([
('id', YLeaf(YType.uint16, 'id')),
('name', YLeaf(YType.str, 'name')),
('status', YLeaf(YType.enumeration, 'status')),
])
self.id = None
self.name = None
self.status = None
self.ports = YList(self)
self._segment_path = lambda: "vlan" + "[id='" + str(self.id) + "']"
self._absolute_path = lambda: "Cisco-IOS-XE-vlan-oper:vlans/%s" % self._segment_path(
)
def __init__(self):
super(NetconfYang.CiscoIa.SnmpTrapControl, self).__init__()
self.yang_name = "snmp-trap-control"
self.yang_parent_name = "cisco-ia"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = []
self._child_classes = OrderedDict([
("trap-list",
("trap_list",
NetconfYang.CiscoIa.SnmpTrapControl.TrapList))
])
self._leafs = OrderedDict([
('global_forwarding',
YLeaf(YType.boolean, 'global-forwarding')),
])
self.global_forwarding = None
self.trap_list = YList(self)
self._segment_path = lambda: "snmp-trap-control"
self._absolute_path = lambda: "cisco-self-mgmt:netconf-yang/cisco-ia:cisco-ia/%s" % self._segment_path(
)
def __init__(self):
super(Trace.TimezoneNotify.Trace_, self).__init__()
self.yang_name = "trace"
self.yang_parent_name = "timezone_notify"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['buffer']
self._child_classes = OrderedDict([
("location", ("location",
Trace.TimezoneNotify.Trace_.Location))
])
self._leafs = OrderedDict([
('buffer', (YLeaf(YType.str, 'buffer'), ['str'])),
])
self.buffer = None
self.location = YList(self)
self._segment_path = lambda: "trace" + "[buffer='" + str(
self.buffer) + "']"
self._absolute_path = lambda: "Cisco-IOS-XR-sysadmin-time-of-day-timezone:trace/timezone_notify/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(PppData.Pppoe.PppoeSessionList, self).__init__()
self.yang_name = "pppoe-session-list"
self.yang_parent_name = "pppoe"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = ['ifname']
self._child_classes = OrderedDict([
("session", ("session",
PppData.Pppoe.PppoeSessionList.Session))
])
self._leafs = OrderedDict([
('ifname', (YLeaf(YType.str, 'ifname'), ['str'])),
])
self.ifname = None
self.session = YList(self)
self._segment_path = lambda: "pppoe-session-list" + "[ifname='" + str(
self.ifname) + "']"
self._absolute_path = lambda: "Cisco-IOS-XE-ppp-oper:ppp-data/pppoe/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(Vmm.VmManager.Trace.Location.AllOptions,
self).__init__()
self.yang_name = "all-options"
self.yang_parent_name = "location"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = ['option']
self._child_classes = OrderedDict([
("trace-blocks",
("trace_blocks", Vmm.VmManager.Trace.Location.
AllOptions.TraceBlocks))
])
self._leafs = OrderedDict([
('option', (YLeaf(YType.str, 'option'), ['str'])),
])
self.option = None
self.trace_blocks = YList(self)
self._segment_path = lambda: "all-options" + "[option='" + str(
self.option) + "']"
self._is_frozen = True
def __init__(self):
super(Vmm.VmManager.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",
Vmm.VmManager.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(
PfilterMa.Nodes.Node.Process.Ipv4.
AclInfoTable.InterfaceInfos,
self).__init__()
self.yang_name = "interface-infos"
self.yang_parent_name = "acl-info-table"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([
("interface-info",
("interface_info",
PfilterMa.Nodes.Node.Process.Ipv4.
AclInfoTable.InterfaceInfos.InterfaceInfo
))
])
self._leafs = OrderedDict()
self.interface_info = YList(self)
self._segment_path = lambda: "interface-infos"
self._is_frozen = True
def __init__(self):
super(Cm, self).__init__()
self._top_entity = None
self.yang_name = "cm"
self.yang_parent_name = "Cisco-IOS-XR-sysadmin-show-trace-cm"
self.is_top_level_class = True
self.has_list_ancestor = False
self.ylist_key_names = []
self._child_container_classes = OrderedDict([
("Cisco-IOS-XR-sysadmin-cm:lsp", ("lsp", Cm.Lsp))
])
self._child_list_classes = OrderedDict([("trace", ("trace", Cm.Trace))
])
self._leafs = OrderedDict()
self.lsp = Cm.Lsp()
self.lsp.parent = self
self._children_name_map["lsp"] = "Cisco-IOS-XR-sysadmin-cm:lsp"
self._children_yang_names.add("Cisco-IOS-XR-sysadmin-cm:lsp")
self.trace = YList(self)
self._segment_path = lambda: "Cisco-IOS-XR-sysadmin-show-trace-cm:cm"
def __init__(self):
if sys.version_info > (3, ):
super().__init__()
else:
super(L3vpn.Vrfs.Vrf.Af, self).__init__()
self.yang_name = "af"
self.yang_parent_name = "vrf"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([
("route-target", ("route_target",
L3vpn.Vrfs.Vrf.Af.RouteTarget))
])
self._leafs = OrderedDict([
('af_name',
(YLeaf(YType.enumeration, 'af-name'),
[('ydk.models.cisco_ios_xr.Cisco_IOS_XR_mpls_vpn_oper',
'MplsVpnAfi', '')])),
('saf_name',
(YLeaf(YType.enumeration, 'saf-name'),
[('ydk.models.cisco_ios_xr.Cisco_IOS_XR_mpls_vpn_oper',
'MplsVpnSafi', '')])),
('import_route_policy',
(YLeaf(YType.str, 'import-route-policy'), ['str'])),
('export_route_policy',
(YLeaf(YType.str, 'export-route-policy'), ['str'])),
])
self.af_name = None
self.saf_name = None
self.import_route_policy = None
self.export_route_policy = None
self.route_target = YList(self)
self._segment_path = lambda: "af"
self._is_frozen = True
def __init__(self):
super(FibOperData.FibNiEntry.FibEntries, self).__init__()
self.yang_name = "fib-entries"
self.yang_parent_name = "fib-ni-entry"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = ['ip_addr']
self._child_classes = OrderedDict([
("fib-nexthop-entries",
("fib_nexthop_entries",
FibOperData.FibNiEntry.FibEntries.FibNexthopEntries))
])
self._leafs = OrderedDict([
('ip_addr', (YLeaf(YType.str, 'ip-addr'), ['str', 'str'])),
('instance_name', (YLeaf(YType.str,
'instance-name'), ['str'])),
('af', (YLeaf(YType.enumeration, 'af'),
[('ydk.models.cisco_ios_xe.Cisco_IOS_XE_fib_oper',
'FibAddressFamily', '')])),
('num_paths', (YLeaf(YType.uint8, 'num-paths'), ['int'])),
('packets_forwarded',
(YLeaf(YType.uint64, 'packets-forwarded'), ['int'])),
('octets_forwarded', (YLeaf(YType.uint64,
'octets-forwarded'), ['int'])),
])
self.ip_addr = None
self.instance_name = None
self.af = None
self.num_paths = None
self.packets_forwarded = None
self.octets_forwarded = None
self.fib_nexthop_entries = YList(self)
self._segment_path = lambda: "fib-entries" + "[ip-addr='" + str(
self.ip_addr) + "']"
self._is_frozen = True
def __init__(self):
super(
Macsec.Secy.Interfaces.Interface.Stats.
TxScStats, self).__init__()
self.yang_name = "tx-sc-stats"
self.yang_parent_name = "stats"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([
("txsa-stat",
("txsa_stat", Macsec.Secy.Interfaces.
Interface.Stats.TxScStats.TxsaStat))
])
self._leafs = OrderedDict([
('tx_sci', YLeaf(YType.uint64, 'tx-sci')),
('out_pkts_protected',
YLeaf(YType.uint64, 'out-pkts-protected')),
('out_pkts_encrypted',
YLeaf(YType.uint64, 'out-pkts-encrypted')),
('out_octets_protected',
YLeaf(YType.uint64, 'out-octets-protected')),
('out_octets_encrypted',
YLeaf(YType.uint64, 'out-octets-encrypted')),
('out_pkts_too_long',
YLeaf(YType.uint64, 'out-pkts-too-long')),
])
self.tx_sci = None
self.out_pkts_protected = None
self.out_pkts_encrypted = None
self.out_octets_protected = None
self.out_octets_encrypted = None
self.out_pkts_too_long = None
self.txsa_stat = YList(self)
self._segment_path = lambda: "tx-sc-stats"
def __init__(self):
super(Macsec.Secy.Interfaces.Interface.Stats,
self).__init__()
self.yang_name = "stats"
self.yang_parent_name = "interface"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([
("intf-stats",
("intf_stats",
Macsec.Secy.Interfaces.Interface.Stats.IntfStats)
),
("tx-sc-stats",
("tx_sc_stats",
Macsec.Secy.Interfaces.Interface.Stats.TxScStats)
),
("rx-sc-stats",
("rx_sc_stats",
Macsec.Secy.Interfaces.Interface.Stats.RxScStats)
)
])
self._leafs = OrderedDict()
self.intf_stats = Macsec.Secy.Interfaces.Interface.Stats.IntfStats(
)
self.intf_stats.parent = self
self._children_name_map["intf_stats"] = "intf-stats"
self.tx_sc_stats = Macsec.Secy.Interfaces.Interface.Stats.TxScStats(
)
self.tx_sc_stats.parent = self
self._children_name_map["tx_sc_stats"] = "tx-sc-stats"
self.rx_sc_stats = YList(self)
self._segment_path = lambda: "stats"
def __init__(self):
super(
Pbr.Nodes.Node.PolicyMap.Interfaces.
Interface.Direction.Input,
self).__init__()
self.yang_name = "input"
self.yang_parent_name = "direction"
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([
("class-stat",
("class_stat",
Pbr.Nodes.Node.PolicyMap.Interfaces.
Interface.Direction.Input.ClassStat))
])
self._leafs = OrderedDict([
('node_name',
YLeaf(YType.str, 'node-name')),
('policy_name',
YLeaf(YType.str, 'policy-name')),
('state',
YLeaf(YType.enumeration, 'state')),
('state_description',
YLeaf(YType.str,
'state-description')),
])
self.node_name = None
self.policy_name = None
self.state = None
self.state_description = None
self.class_stat = YList(self)
self._segment_path = lambda: "input"
def __init__(self):
super(IpDomain.Vrfs.Vrf.Hosts.Host, self).__init__()
self.yang_name = "host"
self.yang_parent_name = "hosts"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = ['host_name']
self._child_container_classes = OrderedDict([
("host-alias-list",
("host_alias_list",
IpDomain.Vrfs.Vrf.Hosts.Host.HostAliasList))
])
self._child_list_classes = OrderedDict([
("host-address",
("host_address",
IpDomain.Vrfs.Vrf.Hosts.Host.HostAddress))
])
self._leafs = OrderedDict([
('host_name', YLeaf(YType.str, 'host-name')),
('af_name', YLeaf(YType.identityref, 'af-name')),
('age', YLeaf(YType.uint16, 'age')),
])
self.host_name = None
self.af_name = None
self.age = None
self.host_alias_list = IpDomain.Vrfs.Vrf.Hosts.Host.HostAliasList(
)
self.host_alias_list.parent = self
self._children_name_map[
"host_alias_list"] = "host-alias-list"
self._children_yang_names.add("host-alias-list")
self.host_address = YList(self)
self._segment_path = lambda: "host" + "[host-name='" + str(
self.host_name) + "']"
def __init__(self):
super(Watchdog.Nodes.Node.OverloadState, self).__init__()
self.yang_name = "overload-state"
self.yang_parent_name = "node"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = []
self._child_classes = OrderedDict([
("current-throttle",
("current_throttle",
Watchdog.Nodes.Node.OverloadState.CurrentThrottle)),
("last-throttle",
("last_throttle",
Watchdog.Nodes.Node.OverloadState.LastThrottle))
])
self._leafs = OrderedDict([
('overload_control_notification',
YLeaf(YType.enumeration,
'overload-control-notification')),
('default_wdsysmon_throttle',
YLeaf(YType.uint32, 'default-wdsysmon-throttle')),
('configured_wdsysmon_throttle',
YLeaf(YType.uint32, 'configured-wdsysmon-throttle')),
])
self.overload_control_notification = None
self.default_wdsysmon_throttle = None
self.configured_wdsysmon_throttle = None
self.current_throttle = Watchdog.Nodes.Node.OverloadState.CurrentThrottle(
)
self.current_throttle.parent = self
self._children_name_map[
"current_throttle"] = "current-throttle"
self.last_throttle = YList(self)
self._segment_path = lambda: "overload-state"
def __init__(self):
super(HwModule.SliceIds.SliceId.SliceInfo, self).__init__()
self.yang_name = "slice-info"
self.yang_parent_name = "slice-id"
self.is_top_level_class = False
self.has_list_ancestor = True
self._child_container_classes = {}
self._child_list_classes = {
"client-port":
("client_port",
HwModule.SliceIds.SliceId.SliceInfo.ClientPort)
}
self.slice_id = YLeaf(YType.uint32, "slice-id")
self.client_rate = YLeaf(YType.enumeration, "client-rate")
self.trunk_rate = YLeaf(YType.enumeration, "trunk-rate")
self.hardware_status = YLeaf(YType.enumeration,
"hardware-status")
self.dp_fpga_fw_type = YLeaf(YType.str, "dp-fpga-fw-type")
self.dp_fpga_fw_ver = YLeaf(YType.str, "dp-fpga-fw-ver")
self.need_upg = YLeaf(YType.uint32, "need-upg")
self.encryption_supported = YLeaf(YType.boolean,
"encryption-supported")
self.lldp_drop_status = YLeaf(YType.boolean,
"lldp-drop-status")
self.client_port = YList(self)
self._segment_path = lambda: "slice-info"
def __init__(self):
if sys.version_info > (3, ):
super().__init__()
else:
super(ManagementPlaneProtection.Inband.Interfaces,
self).__init__()
self.yang_name = "interfaces"
self.yang_parent_name = "inband"
self.is_top_level_class = False
self.has_list_ancestor = False
self.ylist_key_names = []
self._child_classes = OrderedDict([
("interface",
("interface",
ManagementPlaneProtection.Inband.Interfaces.Interface))
])
self._leafs = OrderedDict()
self.interface = YList(self)
self._segment_path = lambda: "interfaces"
self._absolute_path = lambda: "Cisco-IOS-XR-lib-mpp-oper:management-plane-protection/inband/%s" % self._segment_path(
)
self._is_frozen = True
def __init__(self):
super(LptsIfib.Nodes.Node.SliceIds.SliceId,
self).__init__()
self.yang_name = "slice-id"
self.yang_parent_name = "slice-ids"
self.is_top_level_class = False
self.has_list_ancestor = True
self.ylist_key_names = ['slice_name']
self._child_classes = OrderedDict([
("entry",
("entry",
LptsIfib.Nodes.Node.SliceIds.SliceId.Entry))
])
self._leafs = OrderedDict([
('slice_name', (YLeaf(YType.str,
'slice-name'), ['str'])),
])
self.slice_name = None
self.entry = YList(self)
self._segment_path = lambda: "slice-id" + "[slice-name='" + str(
self.slice_name) + "']"
self._is_frozen = True
