max_stars_repo_path
stringlengths 4
245
| max_stars_repo_name
stringlengths 7
115
| max_stars_count
int64 101
368k
| id
stringlengths 2
8
| content
stringlengths 6
1.03M
|
|---|---|---|---|---|
pynubank/__init__.py
|
danizord/pynubank
| 744 |
53678
|
from .exception import NuRequestException, NuException
from .nubank import Nubank
from .utils.mock_http import MockHttpClient
from .utils.http import HttpClient
from .utils.discovery import DISCOVERY_URL
def is_alive(client: HttpClient = None) -> bool:
if client is None:
client = HttpClient()
response = client.raw_get(DISCOVERY_URL)
return response.status_code in [200, 201]
|
docs/tutorials/masking_audio_signals.py
|
ZhaoJY1/nussl
| 259 |
53721
|
# ---
# jupyter:
# jupytext:
# formats: ipynb,py:light
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.5.1
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# Separation via Time-Frequency Masking
# =====================================
#
# One of the most effective ways to separate sounds from a mixture is by
# *masking*. Consider the following mixture, which we will download via
# one of the dataset hooks in *nussl*.
# +
import nussl
import matplotlib.pyplot as plt
import numpy as np
import copy
import time
start_time = time.time()
musdb = nussl.datasets.MUSDB18(download=True)
item = musdb[40]
mix = item['mix']
sources = item['sources']
# -
# Let's listen to the mixture. Note that it contains 4 sources: drums, bass,
# vocals, and all other sounds (considered as one source: other).
mix.embed_audio()
print(mix)
# Let's now consider the time-frequency representation of this mixture:
plt.figure(figsize=(10, 3))
plt.title('Mixture spectrogram')
nussl.utils.visualize_spectrogram(mix, y_axis='mel')
plt.tight_layout()
plt.show()
# Masking means to assign each of these time-frequency bins to one of the four
# sources in part or in whole. The first method involves creating a *soft* mask
# on the time-frequency representation, while the second is a *binary* mask. How
# do we assign each time-frequency bin to each source? This is a very hard problem,
# in general. For now, let's consider that we *know* the actual assignment of each
# time-frequency bin. If we know that, how do we separate the sounds?
#
# First let's look at one of the sources, say the drums:
plt.figure(figsize=(10, 3))
plt.title('Drums')
nussl.utils.visualize_spectrogram(sources['drums'], y_axis='mel')
plt.tight_layout()
plt.show()
# Looking at this versus the mixture spectrogram, one can see which time-frequency
# bins belong to the drum. Now, let's build a *mask* on the mixture spectrogram
# using a soft mask. We construct the soft mask using the drum STFT data and the
# mixture STFT data, like so:
mask_data = np.abs(sources['drums'].stft()) / np.abs(mix.stft())
# Hmm, this may not be a safe way to do this. What if there's a `0` in both the source
# and the mix? Then we would get `0/0`, which would result in NaN in the mask. Or
# what if the source STFT is louder than the mix at some time-frequency bin due to
# cancellation between sources when mixed? Let's do things a bit more safely by
# using the maximum and some checking...
mask_data = (
np.abs(sources['drums'].stft()) /
np.maximum(
np.abs(mix.stft()),
np.abs(sources['drums'].stft())
) + nussl.constants.EPSILON
)
# Great, some peace of mind. Now let's apply the soft mask to the mixture to
# separate the drums. We can do this by element-wise multiplying the STFT and
# adding the mixture phase.
# +
magnitude, phase = np.abs(mix.stft_data), np.angle(mix.stft_data)
masked_abs = magnitude * mask_data
masked_stft = masked_abs * np.exp(1j * phase)
drum_est = mix.make_copy_with_stft_data(masked_stft)
drum_est.istft()
drum_est.embed_audio()
plt.figure(figsize=(10, 3))
plt.title('Separated drums')
nussl.utils.visualize_spectrogram(drum_est, y_axis='mel')
plt.tight_layout()
plt.show()
# -
# Cool! Sounds pretty good! But it'd be a drag if we had to type all of
# that every time we wanted to separate something. Lucky for you, we
# built this stuff into the core functionality of *nussl*!
#
# `SoftMask` and `BinaryMask`
# ---------------------------
#
# At the core of *nussl*'s separation functionality are the classes
# `SoftMask` and `BinaryMask`. These are classes that contain some logic
# for masking and can be used with AudioSignal objects. We have a soft mask
# already, so let's build a `SoftMask` object.
soft_mask = nussl.core.masks.SoftMask(mask_data)
# `soft_mask` contains our mask here:
soft_mask.mask.shape
# We can apply the soft mask to our mix and return the separated drums easily,
# using the `apply_mask` method:
# +
drum_est = mix.apply_mask(soft_mask)
drum_est.istft()
drum_est.embed_audio()
plt.figure(figsize=(10, 3))
plt.title('Separated drums')
nussl.utils.visualize_spectrogram(drum_est, y_axis='mel')
plt.tight_layout()
plt.show()
# -
# Sometimes masks are *binary* instead of *soft*. To apply a binary mask, we can do this:
# +
binary_mask = nussl.core.masks.BinaryMask(mask_data > .5)
drum_est = mix.apply_mask(binary_mask)
drum_est.istft()
drum_est.embed_audio()
plt.figure(figsize=(10, 3))
plt.title('Separated drums')
nussl.utils.visualize_spectrogram(drum_est, y_axis='mel')
plt.tight_layout()
plt.show()
# -
# Playing around with the threshold will result in more or less leakage of other sources:
# +
binary_mask = nussl.core.masks.BinaryMask(mask_data > .05)
drum_est = mix.apply_mask(binary_mask)
drum_est.istft()
drum_est.embed_audio()
plt.figure(figsize=(10, 3))
plt.title('Separated drums')
nussl.utils.visualize_spectrogram(drum_est, y_axis='mel')
plt.tight_layout()
plt.show()
# -
# You can hear the vocals slightly in the background as well as the
# other sources.
#
# Finally, given a list of separated sources, we can use some handy nussl
# functionality to easily visualize the masks and listen to the original
# sources that make up the mixture.
# +
plt.figure(figsize=(10, 7))
plt.subplot(211)
nussl.utils.visualize_sources_as_masks(
sources, db_cutoff=-60, y_axis='mel')
plt.subplot(212)
nussl.utils.visualize_sources_as_waveform(
sources, show_legend=False)
plt.tight_layout()
plt.show()
nussl.play_utils.multitrack(sources, ext='.wav')
# -
end_time = time.time()
time_taken = end_time - start_time
print(f'Time taken: {time_taken:.4f} seconds')
|
content/test/gpu/gpu_tests/info_collection_test.py
|
zipated/src
| 2,151 |
53726
|
<reponame>zipated/src
# Copyright 2016 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from gpu_tests import gpu_integration_test
from gpu_tests.gpu_test_expectations import GpuTestExpectations
import sys
# There are no expectations for info_collection
class InfoCollectionExpectations(GpuTestExpectations):
def SetExpectations(self):
pass
class InfoCollectionTest(gpu_integration_test.GpuIntegrationTest):
@classmethod
def Name(cls):
return 'info_collection'
@classmethod
def AddCommandlineArgs(cls, parser):
parser.add_option('--expected-device-id',
help='The expected device id')
parser.add_option('--expected-vendor-id',
help='The expected vendor id')
@classmethod
def GenerateGpuTests(cls, options):
yield ('_', '_', (options.expected_vendor_id, options.expected_device_id))
@classmethod
def SetUpProcess(cls):
super(cls, InfoCollectionTest).SetUpProcess()
cls.CustomizeBrowserArgs([])
cls.StartBrowser()
def RunActualGpuTest(self, test_path, *args):
# Make sure the GPU process is started
self.tab.action_runner.Navigate('chrome:gpu')
# Gather the IDs detected by the GPU process
if not self.browser.supports_system_info:
self.fail("Browser doesn't support GetSystemInfo")
gpu = self.browser.GetSystemInfo().gpu.devices[0]
if not gpu:
self.fail("System Info doesn't have a gpu")
detected_vendor_id = gpu.vendor_id
detected_device_id = gpu.device_id
# Gather the expected IDs passed on the command line
if args[0] == None or args[1] == None:
self.fail("Missing --expected-[vendor|device]-id command line args")
expected_vendor_id = int(args[0], 16)
expected_device_id = int(args[1], 16)
# Check expected and detected matches
if detected_vendor_id != expected_vendor_id:
self.fail('Vendor ID mismatch, expected %s but got %s.' %
(expected_vendor_id, detected_vendor_id))
if detected_device_id != expected_device_id:
self.fail('device ID mismatch, expected %s but got %s.' %
(expected_device_id, detected_device_id))
@classmethod
def _CreateExpectations(cls):
return InfoCollectionExpectations()
def load_tests(loader, tests, pattern):
del loader, tests, pattern # Unused.
return gpu_integration_test.LoadAllTestsInModule(sys.modules[__name__])
|
docs/circuit.py
|
smishraIOV/ri-aggregation
| 1,274 |
53754
|
<reponame>smishraIOV/ri-aggregation
# Citcuit pseudocode
# Data structures
struct op:
# operation data
tx_type: # type of transaction, see the list: https://docs.google.com/spreadsheets/d/1ejK1MJfVehcwjgjVDFD3E2k1EZ7auqbG_y0DKidS9nA/edit#gid=0
chunk: # op chunk number (0..3)
pubdata_chunk: # current chunk of the pubdata (always 8 bytes)
args: # arguments for the operation
# Merkle branches
lhs: # left Merkle branch data
rhs: # right Merkle branch data
clear_account: # bool: instruction to clear the account in the current branch
clear_subaccount: # bool: instruction to clear the subaccount in the current branch
# precomputed witness:
a: # depends on the optype, used for range checks
b: # depends on the optype, used for range checks
new_root: # new state root after the operation is applied
account_path: # Merkle path witness for the account in the current branch
subtree_path: # Merkle path witness for the subtree in the current branch
struct cur: # current Merkle branch data
struct computed:
last_chunk: # bool: whether the current chunk is the last one in sequence
pubdata: # pubdata accumulated over all chunks
range_checked: # bool: ensures that a >= b
new_pubkey_hash: # hash of the new pubkey, truncated to 20 bytes (used only for deposits)
# Circuit functions
def circuit:
running_hash := initial_hash
current_root := last_state_root
prev.lhs := { 0, ... }
prev.rhs := { 0, ... }
prev.chunk := 0
prev.new_root := 0
for op in operations:
# enfore correct bitlentgh for every input in witness
# TODO: create a macro gadget to recursively iterate over struct member annotations (ZKS-119).
for x in op:
verify_bitlength(x)
# check and prepare data
verify_correct_chunking(op, computed)
accumulate_sha256(op.pubdata_chunk)
accumulate_pubdata(op, computed)
# prepare Merkle branch
cur := select_branch(op, computed)
cur.cosigner_pubkey_hash := hash(cur.cosigner_pubkey)
# check initial Merkle paths, before applying the operation
op.clear_account := False
op.clear_subaccount := False
state_root := check_account_data(op, cur, computed, check_intersection = False)
enforce state_root == current_root
# check validity and perform state updates for the current branch by modifying `cur` struct
execute_op(op, cur, computed)
# check final Merkle paths after applying the operation
new_root := check_account_data(op, cur, computed, check_intersection = True)
# NOTE: this is checked separately for each branch side, and we already enforced
# that `op.new_root` remains unchanged for both by enforcing that it is shared by all chunks
enforce new_root == op.new_root
# update global state root on the last op chunk
if computed.last_chunk:
current_root = new_root
# update `prev` references
# TODO: need a gadget to copy struct members one by one (ZKS-119).
prev.rhs = op.rhs
prev.lhs = op.lhs
prev.args = op.args
prev.new_root = op.new_root
prev.chunk = op.chunk
# final checks after the loop end
enforce current_root == new_state_root
enforce running_hash == pubdata_hash
enforce last_chunk # any operation should close with the last chunk
# make sure that operation chunks are passed correctly
def verify_correct_chunking(op, computed):
# enforce chunk sequence correctness
enforce (op.chunk == 0) or (op.chunk == prev.chunk + 1) # ensure that chunks come in sequence
max_chunks := switch op.tx_type
deposit => 4,
transfer_to_new=> 1,
transfer => 2,
# ...and so on
enforce op.chunk < max_chunks # 4 constraints
computed.last_chunk = op.chunk == max_chunks-1 # flag to mark the last op chunk
# enforce that all chunks share the same witness:
# - `op.args` for the common arguments of the operation
# - `op.lhs` and `op.rhs` for left and right Merkle branches
# - `new_root` of the state after the operation is applied
correct_inputs :=
op.chunk == 0 # skip check for the first chunk
or (
prev.args == op.args and
prev.lhs == op.lhs and
prev.rhs == op.rhs and
prev.new_root == op.new_root
) # TODO: need a gadget for logical equality which works with structs (ZKS-119).
enforce correct_inputs
# accumulate pubdata from multiple chunks
def accumulate_pubdata(op, computed):
computed.pubdata =
if op.chunk == 0:
op.pubdata_chunk # initialize from the first chunk
else:
computed.pubdata << 8 + op.pubdata_chunk
# determine the Merkle branch side (0 for LHS, 1 for RHS) and set `cur` for the current Merkle branch
def select_branch(op, computed):
op.current_side := LHS if op.tx_type == 'deposit' else op.chunk
# TODO: need a gadget for conditional swap applied to each struct member (ZKS-119).
cur := op.lhs if current_side == LHS else op.rhs
return cur
def check_account_data(op, cur, computed, check_intersection):
# leaf data for account and balance leaves
subaccount_data := (
cur.subaccount_balance,
cur.subaccount_nonce,
cur.creation_nonce,
cur.cosigner_pubkey_hash,
cur.cosigner_balance,
cur.subaccount_token)
balance_data := cur.balance
# subaccount emptiness check and clearing
cur.subaccount_is_empty := subaccount_data == EMPTY_SUBACCOUNT
subaccount_data = EMPTY_SUBACCOUNT if clear_subaccount else subaccount_data
# subtree Merkle checks
balances_root := merkle_root(token, op.balances_path, balance_data)
subaccounts_root := merkle_root(token, op.balances_path, subaccount_data)
subtree_root := hash(balances_root, subaccounts_root)
# account data
account_data := hash(cur.owner_pub_key, cur.subtree_root, cur.account_nonce)
# account emptiness check and clearing
cur.account_is_empty := account_data == EMPTY_ACCOUNT
account_data = EMPTY_ACCOUNT if clear_account else account_data
# final state Merkle root verification with conditional intersection check
intersection_path := intersection(op.account_path, cur.account, lhs.account, rhs.account,
lhs.intersection_hash, rhs.intersection_hash)
path_witness := intersection_path if check_intersection else op.account_path
state_root := merkle_root(cur.account, path_witness, account_data)
return state_root
# verify operation and execute state updates
def execute_op(op, cur, computed):
# universal range check
computed.range_checked := op.a >= op.b
# unpack floating point values and hashes
op.args.amount := unpack(op.args.amount_packed)
op.args.fee := unpack(op.args.fee_packed)
# some operations require tighter amount packing (with less precision)
computed.compact_amount_correct := op.args.amount == op.args.compact_amount * 256
# new pubkey hash for deposits
computed.new_pubkey_hash := hash(cur.new_pubkey)
# signature check
# NOTE: signature check must always be valid, but msg and signer can be phony
enforce check_sig(cur.sig_msg, cur.signer_pubkey)
# execute operations
op_valid := False
op_valid = op_valid or op.tx_type == 'noop'
op_valid = op_valid or transfer_to_new(op, cur, computed)
op_valid = op_valid or deposit(op, cur, computed)
op_valid = op_valid or close_account(op, cur, computed)
op_valid = op_valid or withdraw(op, cur, computed)
op_valid = op_valid or escalation(op, cur, computed)
op_valid = op_valid or create_subaccount(op, cur, computed)
op_valid = op_valid or close_subaccount(op, cur, computed)
op_valid = op_valid or fill_orders(op, cur, computed)
# `op` MUST be one of the operations and MUST be valid
enforce op_valid
def transfer_to_new(op, cur, computed):
# transfer_to_new validation is split into lhs and rhs; pubdata is combined from both branches
lhs_valid :=
op.tx_type == 'transfer_to_new'
# here we process the first chunk
and op.chunk == 0
# sender authorized spending and recepient
and lhs.sig_msg == hash('transfer_to_new', lhs.account, lhs.token, lhs.account_nonce, op.args.amount_packed,
op.args.fee_packed, cur.new_pubkey)
# sender is account owner
and lhs.signer_pubkey == cur.owner_pub_key
# sender has enough balance: we checked above that `op.a >= op.b`
# NOTE: no need to check overflow for `amount + fee` because their bitlengths are enforced]
and computed.range_checked and (op.a == cur.balance) and (op.b == (op.args.amount + op.args.fee) )
# NOTE: updating the state is done by modifying data in the `cur` branch
if lhs_valid:
cur.leaf_balance = cur.leaf_balance - (op.args.amount + op.args.fee)
cur.account_nonce = cur.account_nonce + 1
rhs_valid :=
op.tx_type == 'transfer_to_new'
# here we process the second (last) chunk
and op.chunk == 1
# compact amount is passed to pubdata for this operation
and computed.compact_amount_correct
# pubdata contains correct data from both branches, so we verify it agains `lhs` and `rhs`
and pubdata == (op.tx_type, lhs.account, lhs.token, lhs.compact_amount, cur.new_pubkey_hash, rhs.account, rhs.fee)
# new account branch is empty
and cur.account_is_empty
# sender signed the same recepient pubkey of which the hash was passed to public data
and lhs.new_pubkey == rhs.new_pubkey
if rhs_valid:
cur.leaf_balance = op.args.amount
return lhs_valid or rhs_valid
def deposit(op, cur, computed):
ignore_pubdata := not last_chunk
tx_valid :=
op.tx_type == 'deposit'
and (ignore_pubdata or pubdata == (cur.account, cur.token, args.compact_amount, cur.new_pubkey_hash, args.fee))
and cur.is_account_empty
and computed.compact_amount_correct
and computed.range_checked and (op.a == op.args.amount) and (op.b == op.args.fee)
if tx_valid:
cur.leaf_balance = op.args.amount - op.args.fee
return tx_valid
def close_account(op, cur, computed):
tx_valid :=
op.tx_type == 'close_account'
and pubdata == (cur.account, cur.subtree_root)
and cur.sig_msg == ('close_account', cur.account, cur.leaf_index, cur.account_nonce, cur.amount, cur.fee)
and cur.signer_pubkey == cur.owner_pub_key
if tx_valid:
op.clear_account = True
return tx_valid
def no_nonce_overflow(nonce):
nonce_overflow := cur.leaf_nonce == 0x10000-1 # nonce is 2 bytes long
return not nonce_overflow
def withdraw(op, cur, computed):
tx_valid :=
op.tx_type == 'withdraw'
and computed.compact_amount_correct
and pubdata == (op.tx_type, cur.account, cur.token, op.args.amount, op.args.fee)
and computed.range_checked and (op.a == cur.balance) and (op.b == (op.args.amount + op.args.fee) )
and cur.sig_msg == ('withdraw', cur.account, cur.token, cur.account_nonce, cur.amount, cur.fee)
and cur.signer_pubkey == cur.owner_pub_key
and no_nonce_overflow(cur.leaf_nonce)
if tx_valid:
cur.balance = cur.balance - (op.args.amount + op.args.fee)
cur.account_nonce = cur.leaf_nonce + 1
return tx_valid
def escalation(op, cur, computed):
tx_valid :=
op.tx_type == 'escalation'
and pubdata == (op.tx_type, cur.account, cur.subaccount, cur.creation_nonce, cur.leaf_nonce)
and cur.sig_msg == ('escalation', cur.account, cur.subaccount, cur.creation_nonce)
(cur.signer_pubkey == cur.owner_pub_key or cur.signer_pubkey == cosigner_pubkey)
if tx_valid:
cur.clear_subaccount = True
return tx_valid
def transfer(op, cur, computed):
lhs_valid :=
op.tx_type == 'transfer'
and op.chunk == 0
and lhs.sig_msg == ('transfer', lhs.account, lhs.token, lhs.account_nonce, op.args.amount_packed,
op.args.fee_packed, rhs.account_pubkey)
and lhs.signer_pubkey == cur.owner_pub_key
and computed.range_checked and (op.a == cur.balance) and (op.b == (op.args.amount + op.args.fee) )
and no_nonce_overflow(cur.account_nonce)
if lhs_valid:
cur.balance = cur.balance - (op.args.amount + op.args.fee)
cur.account_nonce = cur.account_nonce + 1
rhs_valid :=
op.tx_type == 'transfer'
and op.chunk == 1
and not cur.account_is_empty
and pubdata == (op.tx_type, lhs.account, lhs.token, op.args.amount, rhs.account, op.args.fee)
and computed.range_checked and (op.a == (cur.balance + op.args.amount) ) and (op.b == cur.balance )
if rhs_valid:
cur.balance = cur.balance + op.args.amount
return lhs_valid or rhs_valid
# Subaccount operations
def create_subaccount(op, cur, computed):
# On the LHS we have cosigner, we only use it for a overflow check
lhs_valid: =
op.tx_type == 'create_subaccount'
and op.chunk == 0
and computed.range_checked and (op.a == rhs.balance) and (op.b == (op.args.amount + op.args.fee) )
# We process everything else on the RHS
rhs_valid :=
op.tx_type == 'create_subaccount'
and op.chunk == 1
and cur.sig_msg == (
'create_subaccount',
cur.account, # cur = rhs
lhs.account, # co-signer account on the lhs
cur.token,
cur.account_nonce,
op.args.amount_packed,
op.args.fee_packed )
and cur.signer_pubkey == cur.owner_pub_key
and cur.subaccount_is_empty
and pubdata == (op.tx_type, lhs.account, lhs.leaf_index, op.args.amount, rhs.account, op.args.fee)
and computed.range_checked and (op.a == (cur.subaccount_balance + op.args.amount) ) and (op.b == cur.subaccount_balance)
and no_nonce_overflow(cur.account_nonce)
if rhs_valid:
# initialize subaccount
cur.subaccount_balance = cur.subaccount_balance + op.args.amount
cur.creation_nonce = cur.account_nonce
cur.cosigner_pubkey = lhs.account_pubkey
cur.subaccount_token = cur.token
# update main account
cur.balance = cur.balance - (op.args.amount + op.args.fee)
cur.account_nonce = cur.account_nonce + 1
return lhs_valid or rhs_valid
def close_subaccount(op, cur, computed):
# tbd: similar to create_subaccount()
def fill_orders(op, cur, computed):
# tbd
|
ProofOfConcepts/Vision/OpenMvStereoVision/src/target_code/get_calibration_images_remote_side.py
|
WoodData/EndpointAI
| 190 |
53845
|
import image, network, rpc, sensor, struct
import time
import micropython
from pyb import Pin
from pyb import LED
red_led = LED(1)
green_led = LED(2)
blue_led = LED(3)
ir_led = LED(4)
def led_control(x):
if (x&1)==0: red_led.off()
elif (x&1)==1: red_led.on()
if (x&2)==0: green_led.off()
elif (x&2)==2: green_led.on()
if (x&4)==0: blue_led.off()
elif (x&4)==4: blue_led.on()
if (x&8)==0: ir_led.off()
elif (x&8)==8: ir_led.on()
processing = True
# pin used to sync the 2 cams
pin4 = Pin('P4', Pin.IN, Pin.PULL_UP)
# setting the SPI communication as a slave
interface = rpc.rpc_spi_slave(cs_pin="P3", clk_polarity=1, clk_phase=0)
# here we always choose the QVGA format (320x240) inside a VGA image
img_width = 320
img_height = 240
sensor.reset()
sensor_format = sensor.GRAYSCALE
sensor_size = sensor.VGA
sensor.set_pixformat(sensor_format)
sensor.set_framesize(sensor_size)
if img_width != sensor.width() or img_height != sensor.height():
sensor.set_windowing((int((sensor.width()-img_width)/2),int((sensor.height()-img_height)/2),img_width,img_height))
sensor.skip_frames(time = 2000)
sensor.snapshot()
################################################################
# Call Backs
################################################################
def sensor_config(data):
global processing
gain_db, exposure_us, r_gain_db, g_gain_db, b_gain_db = struct.unpack("<fIfff", data)
sensor.set_auto_gain(False, gain_db)
sensor.set_auto_exposure(False, exposure_us)
sensor.set_auto_whitebal(False, (r_gain_db, g_gain_db, b_gain_db))
processing = False
return struct.pack("<fIfff",gain_db, exposure_us, r_gain_db, g_gain_db, b_gain_db)
def raw_image_read_cb():
global processing
interface.put_bytes(sensor.get_fb().bytearray(), 5000) # timeout
processing = False
def raw_image_read(data):
interface.schedule_callback(raw_image_read_cb)
return bytes()
def loop_callback():
global processing
if not processing:
raise Exception
# Register call backs.
interface.register_callback(raw_image_read)
interface.register_callback(sensor_config)
interface.setup_loop_callback(loop_callback)
# a simple visual way to know the slave cam has started properly and is ready
led_control(4)
time.sleep(500)
led_control(0)
time.sleep(500)
led_control(4)
time.sleep(500)
led_control(0)
# configuration step: getting the same image settings as the controller cam
try:
processing = True
interface.loop()
except:
pass
# serve for ever
while True:
try:
processing = True
# GPIO sync
while not pin4.value():
pass
# Get a snapshot that will be sent back to the controller cam
sensor.snapshot()
interface.loop()
except:
pass
|
textclf/tester/__init__.py
|
lswjkllc/textclf
| 146 |
53851
|
<gh_stars>100-1000
from .ml_tester import MLTester
from .dl_tester import DLTester
|
testapps/PY/test_partial.py
|
naver/pinpoint-c-agent
| 178 |
53853
|
<gh_stars>100-1000
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
from pinpointPy.CommonPlugin import PinpointCommonPlugin
@PinpointCommonPlugin( __name__+".func1")
def func1(a, b="Wool"):
return a + b
|
util/logging.py
|
PJunhyuk/exercise-pose-guide
| 161 |
53870
|
<reponame>PJunhyuk/exercise-pose-guide
import logging
def setup_logging():
FORMAT = '%(asctime)-15s %(message)s'
logging.basicConfig(filename='log.txt', filemode='w',
datefmt='%Y-%m-%d %H:%M:%S',
level=logging.INFO, format=FORMAT)
console = logging.StreamHandler()
console.setLevel(logging.INFO)
logging.getLogger('').addHandler(console)
|
python/ql/test/3/library-tests/PointsTo/regressions/subprocess-assert/mwe_failure.py
|
vadi2/codeql
| 4,036 |
53890
|
<reponame>vadi2/codeql<filename>python/ql/test/3/library-tests/PointsTo/regressions/subprocess-assert/mwe_failure.py
import subprocess
assert subprocess.call(['run-backup']) == 0
class TestCase:
pass
class MyTest(TestCase):
pass
# found by /home/rasmus/code/ql/python/ql/test/query-tests/Statements/asserts/AssertLiteralConstant.qlref
|
orchestra/tests/management_commands/test_migrate_certifications.py
|
code-review-doctor/orchestra
| 444 |
53914
|
from unittest.mock import patch
from django.core.management import call_command
from django.core.management.base import CommandError
from orchestra.tests.helpers import OrchestraTestCase
class MigrateCertificationsTestCase(OrchestraTestCase):
patch_path = ('orchestra.management.commands.'
'migrate_certifications.migrate_certifications')
@patch(patch_path)
def test_options(self, mock_migrate):
# Test no options
with self.assertRaises(CommandError):
call_command('migrate_certifications')
mock_migrate.assert_not_called()
# Test
call_command('migrate_certifications',
'test_source_workflow_slug',
'ntest_destination_workflow_slug',
certifications=['test_cert_1', 'test_cert_2'])
mock_migrate.called_once_with(
'test_source_workflow_slug',
'test_destination_workflow_slug',
['test_cert_1', 'test_cert_2']
)
|
src/hg/utils/otto/nextstrainNcov/newick.py
|
andypohl/kent
| 171 |
53934
|
# Parse Newick-formatted file into tree of { 'kids': [], 'label': '', 'length': '' }
import logging
from utils import die
def skipSpaces(treeString, offset):
while (offset != len(treeString) and treeString[offset].isspace()):
offset += 1
return offset
def parseQuoted(treeString, offset):
"""Read in a quoted, possibly \-escaped string in treeString at offset"""
label = ''
quoteChar = treeString[offset]
offset += 1
labelStart = offset
while (offset != len(treeString) and treeString[offset] != quoteChar):
if (treeString[offset] == '\\'):
offset += 1
offset += 1
if (treeString[offset] != quoteChar):
die("Missing end-" + quoteChar + " after '" + treeString + "'")
else:
label = treeString[labelStart:offset]
offset = skipSpaces(treeString, offset + 1)
return (label, offset)
def terminatesLabel(treeString, offset):
"""Return True if treeString+offset is empty or starts w/char that would terminate a label"""
return (offset == len(treeString) or treeString[offset] == ',' or treeString[offset] == ')' or
treeString[offset] == ';' or treeString[offset] == ':')
def parseLabel(treeString, offset):
"""Read in a possibly quoted, possibly \-escaped node label terminated by [,):;]"""
if (offset == len(treeString)):
label = ''
elif (treeString[offset] == "'" or treeString[offset] == '"'):
(label, offset) = parseQuoted(treeString, offset)
else:
labelStart = offset
while (not terminatesLabel(treeString, offset)):
if (treeString[offset] == '\\'):
offset += 1
offset += 1
label = treeString[labelStart:offset]
offset = skipSpaces(treeString, offset)
return(label, offset)
def parseLength(treeString, offset):
"""If treeString[offset] is ':', then parse the number that follows; otherwise return 0.0."""
if (offset != len(treeString) and treeString[offset] == ':'):
# Branch length
offset = skipSpaces(treeString, offset + 1)
if (not treeString[offset].isdigit()):
die("Expected number to follow ':' but instead got '" +
treeString[offset:offset+100] + "'")
lengthStart = offset
while (offset != len(treeString) and
(treeString[offset].isdigit() or treeString[offset] == '.' or
treeString[offset] == 'E' or treeString[offset] == 'e' or
treeString[offset] == '-')):
offset += 1
lengthStr = treeString[lengthStart:offset]
offset = skipSpaces(treeString, offset)
return (lengthStr, offset)
else:
return ('', offset)
def parseBranch(treeString, offset, internalNode):
"""Recursively parse Newick branch (x, y, z)[label][:length] from treeString at offset"""
if (treeString[offset] != '('):
die("parseBranch called on treeString that doesn't begin with '(': '" +
treeString + "'")
branchStart = offset
internalNode += 1
branch = { 'kids': [], 'label': '', 'length': '', 'inode': internalNode }
offset = skipSpaces(treeString, offset + 1)
while (offset != len(treeString) and treeString[offset] != ')' and treeString[offset] != ';'):
(child, offset, internalNode) = parseString(treeString, offset, internalNode)
branch['kids'].append(child)
if (treeString[offset] == ','):
offset = skipSpaces(treeString, offset + 1)
if (offset == len(treeString)):
die("Input ended before ')' for '" + treeString[branchStart:branchStart+100] + "'")
if (treeString[offset] == ')'):
offset = skipSpaces(treeString, offset + 1)
else:
die("Can't find ')' matching '" + treeString[branchStart:branchStart+100] + "', " +
"instead got '" + treeString[offset:offset+100] + "'")
(branch['label'], offset) = parseLabel(treeString, offset)
(branch['length'], offset) = parseLength(treeString, offset)
return (branch, offset, internalNode)
def parseString(treeString, offset=0, internalNode=0):
"""Recursively parse Newick tree from treeString"""
offset = skipSpaces(treeString, offset)
if (treeString[offset] == '('):
return parseBranch(treeString, offset, internalNode)
else:
(label, offset) = parseLabel(treeString, offset)
(length, offset) = parseLength(treeString, offset)
leaf = { 'kids': None, 'label': label, 'length': length }
return (leaf, offset, internalNode)
def parseFile(treeFile):
"""Read Newick file, return tree object"""
with open(treeFile, 'r') as treeF:
line1 = treeF.readline().strip()
if (line1 == ''):
return None
(tree, offset, internalNode) = parseString(line1)
if (offset != len(line1) and line1[offset] != ';'):
die("Tree terminated without ';' before '" + line1[offset:offset+100] + "'")
treeF.close()
return tree
def treeToString(node, pretty=False, indent=0):
"""Return a Newick string encoding node and its descendants, optionally pretty-printing with
newlines and indentation. String is not ';'-terminated, caller must do that."""
if not node:
return ''
labelLen = ''
if (node['label']):
labelLen += node['label']
if (node['length']):
labelLen += ':' + node['length']
if (node['kids']):
string = '('
kidIndent = indent + 1
kidStrings = [ treeToString(kid, pretty, kidIndent) for kid in node['kids'] ]
sep = ','
if (pretty):
sep = ',\n' + ' ' * kidIndent
string += sep.join(kidStrings)
string += ')'
string += labelLen
else:
string = labelLen
return string;
def printTree(tree, pretty=False, indent=0):
"""Print out Newick text encoding tree, optionally pretty-printing with
newlines and indentation."""
print(treeToString(tree, pretty, indent) + ';')
def leafNames(node):
"""Return a list of labels of all leaf descendants of node"""
if (node['kids']):
return [ leaf for kid in node['kids'] for leaf in leafNames(kid) ]
else:
return [ node['label'] ]
def treeIntersectIds(node, idLookup, sampleSet, lookupFunc=None):
"""For each leaf in node, attempt to look up its label in idLookup; replace if found.
Prune nodes with no matching leaves. Store new leaf labels in sampleSet.
If lookupFunc is given, it is passed two arguments (label, idLookup) and returns a
possible empty list of matches."""
if (node['kids']):
# Internal node: prune
prunedKids = []
for kid in (node['kids']):
kidIntersected = treeIntersectIds(kid, idLookup, sampleSet, lookupFunc)
if (kidIntersected):
prunedKids.append(kidIntersected)
if (len(prunedKids) > 1):
node['kids'] = prunedKids
elif (len(prunedKids) == 1):
node = prunedKids[0]
else:
node = None
else:
# Leaf: lookup, prune if not found
label = node['label']
if (lookupFunc):
matchList = lookupFunc(node['label'], idLookup)
elif label in idLookup:
matchList = idLookup[label]
else:
matchList = []
if (not matchList):
logging.info("No match for leaf '" + label + "'")
node = None
else:
if (len(matchList) != 1):
logging.warn("Non-unique match for leaf '" + label + "': ['" +
"', '".join(matchList) + "']")
else:
logging.debug(label + ' --> ' + matchList[0]);
node['label'] = matchList[0]
sampleSet.add(matchList[0])
return node
|
zeus/vcs/asserts.py
|
conrad-kronos/zeus
| 221 |
53951
|
def assert_revision(revision, author=None, message=None):
"""Asserts values of the given fields in the provided revision.
:param revision: The revision to validate
:param author: that must be present in the ``revision``
:param message: message substring that must be present in ``revision``
"""
if author:
assert author == revision.author
if message:
assert message in revision.message
|
test/test_gradcam_guided_backprop.py
|
giladcohen/darkon
| 254 |
54003
|
# Copyright 2017 Neosapience, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT 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 unittest
import darkon
import tensorflow as tf
import numpy as np
_classes = 2
def nn_graph(activation):
# create graph
x = tf.placeholder(tf.float32, (1, 2, 2, 3), 'x_placeholder')
y = tf.placeholder(tf.int32, name='y_placeholder', shape=[1, 2])
with tf.name_scope('conv1'):
conv_1 = tf.layers.conv2d(
inputs=x,
filters=10,
kernel_size=[2, 2],
padding="same",
activation=activation)
with tf.name_scope('fc2'):
flatten = tf.layers.flatten(conv_1)
top = tf.layers.dense(flatten, _classes)
logits = tf.nn.softmax(top)
return x
class GradcamGuidedBackprop(unittest.TestCase):
def setUp(self):
tf.reset_default_graph()
def tearDown(self):
x = nn_graph(activation=self.activation_fn)
image = np.random.uniform(size=(2, 2, 3))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
gradcam_ops = darkon.Gradcam.candidate_featuremap_op_names(sess)
if self.enable_guided_backprop:
_ = darkon.Gradcam(x, _classes, gradcam_ops[-1])
g = tf.get_default_graph()
from_ts = g.get_operation_by_name(gradcam_ops[-1]).outputs
to_ts = g.get_operation_by_name(gradcam_ops[-2]).outputs
max_output = tf.reduce_max(from_ts, axis=3)
y = tf.reduce_sum(-max_output * 1e2)
grad = tf.gradients(y, to_ts)[0]
grad_val = sess.run(grad, feed_dict={x: np.expand_dims(image, 0)})
if self.enable_guided_backprop:
self.assertTrue(not np.any(grad_val))
else:
self.assertTrue(np.any(grad_val))
def test_relu(self):
self.activation_fn = tf.nn.relu
self.enable_guided_backprop = False
def test_relu_guided(self):
self.activation_fn = tf.nn.relu
self.enable_guided_backprop = True
def test_tanh(self):
self.activation_fn = tf.nn.tanh
self.enable_guided_backprop = False
def test_tanh_guided(self):
self.activation_fn = tf.nn.tanh
self.enable_guided_backprop = True
def test_sigmoid(self):
self.activation_fn = tf.nn.sigmoid
self.enable_guided_backprop = False
def test_sigmoid_guided(self):
self.activation_fn = tf.nn.sigmoid
self.enable_guided_backprop = True
def test_relu6(self):
self.activation_fn = tf.nn.relu6
self.enable_guided_backprop = False
def test_relu6_guided(self):
self.activation_fn = tf.nn.relu6
self.enable_guided_backprop = True
def test_elu(self):
self.activation_fn = tf.nn.elu
self.enable_guided_backprop = False
def test_elu_guided(self):
self.activation_fn = tf.nn.elu
self.enable_guided_backprop = True
def test_selu(self):
self.activation_fn = tf.nn.selu
self.enable_guided_backprop = False
def test_selu_guided(self):
self.activation_fn = tf.nn.selu
self.enable_guided_backprop = True
def test_softplus(self):
self.activation_fn = tf.nn.softplus
self.enable_guided_backprop = False
def test_test_softplus_guided(self):
self.activation_fn = tf.nn.softplus
self.enable_guided_backprop = True
def test_softsign(self):
self.activation_fn = tf.nn.softsign
self.enable_guided_backprop = False
def test_softsign_guided(self):
self.activation_fn = tf.nn.softsign
self.enable_guided_backprop = True
|
03_SweynTooth/libs/scapy/contrib/automotive/gm/gmlanutils.py
|
Charmve/BLE-Security-Att-Def
| 149 |
54053
|
#! /usr/bin/env python
# This file is part of Scapy
# See http://www.secdev.org/projects/scapy for more information
# Copyright (C) <NAME> <<EMAIL>>
# Copyright (C) <NAME> <<EMAIL>>
# This program is published under a GPLv2 license
# scapy.contrib.description = GMLAN Utilities
# scapy.contrib.status = loads
import time
from scapy.contrib.automotive.gm.gmlan import GMLAN, GMLAN_SA, GMLAN_RD, \
GMLAN_TD, GMLAN_PM, GMLAN_RMBA
from scapy.config import conf
from scapy.contrib.isotp import ISOTPSocket
from scapy.error import warning, log_loading
from scapy.utils import PeriodicSenderThread
__all__ = ["GMLAN_TesterPresentSender", "GMLAN_InitDiagnostics",
"GMLAN_GetSecurityAccess", "GMLAN_RequestDownload",
"GMLAN_TransferData", "GMLAN_TransferPayload",
"GMLAN_ReadMemoryByAddress", "GMLAN_BroadcastSocket"]
log_loading.info("\"conf.contribs['GMLAN']"
"['treat-response-pending-as-answer']\" set to True). This "
"is required by the GMLAN-Utils module to operate "
"correctly.")
try:
conf.contribs['GMLAN']['treat-response-pending-as-answer'] = False
except KeyError:
conf.contribs['GMLAN'] = {'treat-response-pending-as-answer': False}
class GMLAN_TesterPresentSender(PeriodicSenderThread):
def __init__(self, sock, pkt=GMLAN(service="TesterPresent"), interval=2):
""" Thread to send TesterPresent messages packets periodically
Args:
sock: socket where packet is sent periodically
pkt: packet to send
interval: interval between two packets
"""
PeriodicSenderThread.__init__(self, sock, pkt, interval)
def _check_response(resp, verbose):
if resp is None:
if verbose:
print("Timeout.")
return False
if verbose:
resp.show()
return resp.sprintf("%GMLAN.service%") != "NegativeResponse"
def _send_and_check_response(sock, req, timeout, verbose):
if verbose:
print("Sending %s" % repr(req))
resp = sock.sr1(req, timeout=timeout, verbose=0)
return _check_response(resp, verbose)
def GMLAN_InitDiagnostics(sock, broadcastsocket=None, timeout=None,
verbose=None, retry=0):
"""Send messages to put an ECU into an diagnostic/programming state.
Args:
sock: socket to send the message on.
broadcast: socket for broadcasting. If provided some message will be
sent as broadcast. Recommended when used on a network with
several ECUs.
timeout: timeout for sending, receiving or sniffing packages.
verbose: set verbosity level
retry: number of retries in case of failure.
Returns true on success.
"""
if verbose is None:
verbose = conf.verb
retry = abs(retry)
while retry >= 0:
retry -= 1
# DisableNormalCommunication
p = GMLAN(service="DisableNormalCommunication")
if broadcastsocket is None:
if not _send_and_check_response(sock, p, timeout, verbose):
continue
else:
if verbose:
print("Sending %s as broadcast" % repr(p))
broadcastsocket.send(p)
time.sleep(0.05)
# ReportProgrammedState
p = GMLAN(service="ReportProgrammingState")
if not _send_and_check_response(sock, p, timeout, verbose):
continue
# ProgrammingMode requestProgramming
p = GMLAN() / GMLAN_PM(subfunction="requestProgrammingMode")
if not _send_and_check_response(sock, p, timeout, verbose):
continue
time.sleep(0.05)
# InitiateProgramming enableProgramming
# No response expected
p = GMLAN() / GMLAN_PM(subfunction="enableProgrammingMode")
if verbose:
print("Sending %s" % repr(p))
sock.send(p)
time.sleep(0.05)
return True
return False
def GMLAN_GetSecurityAccess(sock, keyFunction, level=1, timeout=None,
verbose=None, retry=0):
"""Authenticate on ECU. Implements Seey-Key procedure.
Args:
sock: socket to send the message on.
keyFunction: function implementing the key algorithm.
level: level of access
timeout: timeout for sending, receiving or sniffing packages.
verbose: set verbosity level
retry: number of retries in case of failure.
Returns true on success.
"""
if verbose is None:
verbose = conf.verb
retry = abs(retry)
if level % 2 == 0:
warning("Parameter Error: Level must be an odd number.")
return False
while retry >= 0:
retry -= 1
request = GMLAN() / GMLAN_SA(subfunction=level)
if verbose:
print("Requesting seed..")
resp = sock.sr1(request, timeout=timeout, verbose=0)
if not _check_response(resp, verbose):
if verbose:
print("Negative Response.")
continue
seed = resp.securitySeed
if seed == 0:
if verbose:
print("ECU security already unlocked. (seed is 0x0000)")
return True
keypkt = GMLAN() / GMLAN_SA(subfunction=level + 1,
securityKey=keyFunction(seed))
if verbose:
print("Responding with key..")
resp = sock.sr1(keypkt, timeout=timeout, verbose=0)
if resp is None:
if verbose:
print("Timeout.")
continue
if verbose:
resp.show()
if resp.sprintf("%GMLAN.service%") == "SecurityAccessPositiveResponse": # noqa: E501
if verbose:
print("SecurityAccess granted.")
return True
# Invalid Key
elif resp.sprintf("%GMLAN.service%") == "NegativeResponse" and \
resp.sprintf("%GMLAN.returnCode%") == "InvalidKey":
if verbose:
print("Key invalid")
continue
return False
def GMLAN_RequestDownload(sock, length, timeout=None, verbose=None, retry=0):
"""Send RequestDownload message.
Usually used before calling TransferData.
Args:
sock: socket to send the message on.
length: value for the message's parameter 'unCompressedMemorySize'.
timeout: timeout for sending, receiving or sniffing packages.
verbose: set verbosity level.
retry: number of retries in case of failure.
Returns true on success.
"""
if verbose is None:
verbose = conf.verb
retry = abs(retry)
while retry >= 0:
# RequestDownload
pkt = GMLAN() / GMLAN_RD(memorySize=length)
resp = sock.sr1(pkt, timeout=timeout, verbose=0)
if _check_response(resp, verbose):
return True
retry -= 1
if retry >= 0 and verbose:
print("Retrying..")
return False
def GMLAN_TransferData(sock, addr, payload, maxmsglen=None, timeout=None,
verbose=None, retry=0):
"""Send TransferData message.
Usually used after calling RequestDownload.
Args:
sock: socket to send the message on.
addr: destination memory address on the ECU.
payload: data to be sent.
maxmsglen: maximum length of a single iso-tp message. (default:
maximum length)
timeout: timeout for sending, receiving or sniffing packages.
verbose: set verbosity level.
retry: number of retries in case of failure.
Returns true on success.
"""
if verbose is None:
verbose = conf.verb
retry = abs(retry)
startretry = retry
scheme = conf.contribs['GMLAN']['GMLAN_ECU_AddressingScheme']
if addr < 0 or addr >= 2**(8 * scheme):
warning("Error: Invalid address " + hex(addr) + " for scheme " +
str(scheme))
return False
# max size of dataRecord according to gmlan protocol
if maxmsglen is None or maxmsglen <= 0 or maxmsglen > (4093 - scheme):
maxmsglen = (4093 - scheme)
for i in range(0, len(payload), maxmsglen):
retry = startretry
while True:
if len(payload[i:]) > maxmsglen:
transdata = payload[i:i + maxmsglen]
else:
transdata = payload[i:]
pkt = GMLAN() / GMLAN_TD(startingAddress=addr + i,
dataRecord=transdata)
resp = sock.sr1(pkt, timeout=timeout, verbose=0)
if _check_response(resp, verbose):
break
retry -= 1
if retry >= 0:
if verbose:
print("Retrying..")
else:
return False
return True
def GMLAN_TransferPayload(sock, addr, payload, maxmsglen=None, timeout=None,
verbose=None, retry=0):
"""Send data by using GMLAN services.
Args:
sock: socket to send the data on.
addr: destination memory address on the ECU.
payload: data to be sent.
maxmsglen: maximum length of a single iso-tp message. (default:
maximum length)
timeout: timeout for sending, receiving or sniffing packages.
verbose: set verbosity level.
retry: number of retries in case of failure.
Returns true on success.
"""
if not GMLAN_RequestDownload(sock, len(payload), timeout=timeout,
verbose=verbose, retry=retry):
return False
if not GMLAN_TransferData(sock, addr, payload, maxmsglen=maxmsglen,
timeout=timeout, verbose=verbose, retry=retry):
return False
return True
def GMLAN_ReadMemoryByAddress(sock, addr, length, timeout=None,
verbose=None, retry=0):
"""Read data from ECU memory.
Args:
sock: socket to send the data on.
addr: source memory address on the ECU.
length: bytes to read
timeout: timeout for sending, receiving or sniffing packages.
verbose: set verbosity level.
retry: number of retries in case of failure.
Returns the bytes read.
"""
if verbose is None:
verbose = conf.verb
retry = abs(retry)
scheme = conf.contribs['GMLAN']['GMLAN_ECU_AddressingScheme']
if addr < 0 or addr >= 2**(8 * scheme):
warning("Error: Invalid address " + hex(addr) + " for scheme " +
str(scheme))
return None
# max size of dataRecord according to gmlan protocol
if length <= 0 or length > (4094 - scheme):
warning("Error: Invalid length " + hex(length) + " for scheme " +
str(scheme) + ". Choose between 0x1 and " + hex(4094 - scheme))
return None
while retry >= 0:
# RequestDownload
pkt = GMLAN() / GMLAN_RMBA(memoryAddress=addr, memorySize=length)
resp = sock.sr1(pkt, timeout=timeout, verbose=0)
if _check_response(resp, verbose):
return resp.dataRecord
retry -= 1
if retry >= 0 and verbose:
print("Retrying..")
return None
def GMLAN_BroadcastSocket(interface):
"""Returns a GMLAN broadcast socket using interface."""
return ISOTPSocket(interface, sid=0x101, did=0x0, basecls=GMLAN,
extended_addr=0xfe)
|
adet/modeling/blendmask/__init__.py
|
manusheoran/AdelaiDet_DA
| 2,597 |
54091
|
<reponame>manusheoran/AdelaiDet_DA
from .basis_module import build_basis_module
from .blendmask import BlendMask
|
Chapter 14/code/ocr.py
|
shivampotdar/Artificial-Intelligence-with-Python
| 387 |
54092
|
<gh_stars>100-1000
import numpy as np
import neurolab as nl
# Define the input file
input_file = 'letter.data'
# Define the number of datapoints to
# be loaded from the input file
num_datapoints = 50
# String containing all the distinct characters
orig_labels = 'omandig'
# Compute the number of distinct characters
num_orig_labels = len(orig_labels)
# Define the training and testing parameters
num_train = int(0.9 * num_datapoints)
num_test = num_datapoints - num_train
# Define the dataset extraction parameters
start = 6
end = -1
# Creating the dataset
data = []
labels = []
with open(input_file, 'r') as f:
for line in f.readlines():
# Split the current line tabwise
list_vals = line.split('\t')
# Check if the label is in our ground truth
# labels. If not, we should skip it.
if list_vals[1] not in orig_labels:
continue
# Extract the current label and append it
# to the main list
label = np.zeros((num_orig_labels, 1))
label[orig_labels.index(list_vals[1])] = 1
labels.append(label)
# Extract the character vector and append it to the main list
cur_char = np.array([float(x) for x in list_vals[start:end]])
data.append(cur_char)
# Exit the loop once the required dataset has been created
if len(data) >= num_datapoints:
break
# Convert the data and labels to numpy arrays
data = np.asfarray(data)
labels = np.array(labels).reshape(num_datapoints, num_orig_labels)
# Extract the number of dimensions
num_dims = len(data[0])
# Create a feedforward neural network
nn = nl.net.newff([[0, 1] for _ in range(len(data[0]))],
[128, 16, num_orig_labels])
# Set the training algorithm to gradient descent
nn.trainf = nl.train.train_gd
# Train the network
error_progress = nn.train(data[:num_train,:], labels[:num_train,:],
epochs=10000, show=100, goal=0.01)
# Predict the output for test inputs
print('\nTesting on unknown data:')
predicted_test = nn.sim(data[num_train:, :])
for i in range(num_test):
print('\nOriginal:', orig_labels[np.argmax(labels[i])])
print('Predicted:', orig_labels[np.argmax(predicted_test[i])])
|
clover/examples/gps.py
|
lvsoft/clover
| 146 |
54139
|
# Information: https://clover.coex.tech/en/simple_offboard.html#navigateglobal
import rospy
from clover import srv
from std_srvs.srv import Trigger
import math
rospy.init_node('flight')
get_telemetry = rospy.ServiceProxy('get_telemetry', srv.GetTelemetry)
navigate = rospy.ServiceProxy('navigate', srv.Navigate)
navigate_global = rospy.ServiceProxy('navigate_global', srv.NavigateGlobal)
set_position = rospy.ServiceProxy('set_position', srv.SetPosition)
set_velocity = rospy.ServiceProxy('set_velocity', srv.SetVelocity)
set_attitude = rospy.ServiceProxy('set_attitude', srv.SetAttitude)
set_rates = rospy.ServiceProxy('set_rates', srv.SetRates)
land = rospy.ServiceProxy('land', Trigger)
# https://clover.coex.tech/en/snippets.html#wait_arrival
def wait_arrival(tolerance=0.2):
while not rospy.is_shutdown():
telem = get_telemetry(frame_id='navigate_target')
if math.sqrt(telem.x ** 2 + telem.y ** 2 + telem.z ** 2) < tolerance:
break
rospy.sleep(0.2)
start = get_telemetry()
if math.isnan(start.lat):
raise Exception('No global position, install and configure GPS sensor: https://clover.coex.tech/gps')
print('Start point global position: lat={}, lon={}'.format(start.lat, start.lon))
print('Take off 3 meters')
navigate(x=0, y=0, z=3, frame_id='body', auto_arm=True)
wait_arrival()
print('Fly 1 arcsecond to the North (approx. 30 meters)')
navigate_global(lat=start.lat+1.0/60/60, lon=start.lon, z=start.z+3, yaw=math.inf, speed=5)
wait_arrival()
print('Fly to home position')
navigate_global(lat=start.lat, lon=start.lon, z=start.z+3, yaw=math.inf, speed=5)
wait_arrival()
print('Land')
land()
|
grr/client/grr_response_client/client_actions/windows/pipes_test.py
|
khanhgithead/grr
| 4,238 |
54203
|
#!/usr/bin/env python
import contextlib
import os
import platform
from typing import Iterator
from typing import Optional
import uuid
from absl.testing import absltest
from grr_response_client.client_actions.windows import pipes
if platform.system() == "Windows":
# pylint: disable=g-import-not-at-top
# pytype: disable=import-error
import win32pipe
# pytype: enable=import-error
# pylint: enable=g-import-not-at-top
@absltest.skipUnless(
platform.system() == "Windows",
reason="Windows-only action.",
)
class ListNamedPipesTest(absltest.TestCase):
def testSinglePipe(self) -> None:
pipe_name = str(uuid.uuid4())
pipe_spec = NamedPipeSpec(pipe_name)
with pipe_spec.Create():
results = list(pipes.ListNamedPipes())
names = set(result.name for result in results)
self.assertIn(pipe_name, names)
def testMultiplePipes(self) -> None:
pipe_name_1 = str(uuid.uuid4())
pipe_name_2 = str(uuid.uuid4())
pipe_spec_1 = NamedPipeSpec(pipe_name_1)
pipe_spec_2 = NamedPipeSpec(pipe_name_2)
with pipe_spec_1.Create():
with pipe_spec_2.Create():
results = list(pipes.ListNamedPipes())
names = set(result.name for result in results)
self.assertIn(pipe_name_1, names)
self.assertIn(pipe_name_2, names)
def testPipeTypeByte(self) -> None:
self._testPipeType(win32pipe.PIPE_TYPE_BYTE)
def testPipeTypeMessage(self) -> None:
self._testPipeType(win32pipe.PIPE_TYPE_MESSAGE)
def _testPipeType(self, pipe_type: int) -> None: # pylint: disable=invalid-name
pipe_name = str(uuid.uuid4())
pipe_spec = NamedPipeSpec(pipe_name)
pipe_spec.pipe_mode = pipe_type
with pipe_spec.Create():
results = list(pipes.ListNamedPipes())
results_by_name = {result.name: result for result in results}
result = results_by_name[pipe_name]
self.assertEqual(result.flags & pipe_type, pipe_type)
def testMaxInstanceCountLimited(self) -> None:
self._testMaxInstanceCount(42)
def testMaxInstanceCountUnlimited(self) -> None:
self._testMaxInstanceCount(win32pipe.PIPE_UNLIMITED_INSTANCES)
def _testMaxInstanceCount(self, count: int) -> None: # pylint: disable=invalid-name
pipe_name = str(uuid.uuid4())
pipe_spec = NamedPipeSpec(pipe_name)
pipe_spec.max_instance_count = count
with pipe_spec.Create():
results = list(pipes.ListNamedPipes())
results_by_name = {result.name: result for result in results}
result = results_by_name[pipe_name]
self.assertEqual(result.max_instance_count, count)
def testCurInstanceCount(self) -> None:
pipe_name = str(uuid.uuid4())
pipe_spec = NamedPipeSpec(pipe_name)
with pipe_spec.Create():
with pipe_spec.Create():
with pipe_spec.Create():
results = list(pipes.ListNamedPipes())
results_by_name = {result.name: result for result in results}
result = results_by_name[pipe_name]
self.assertEqual(result.cur_instance_count, 3)
def testBufferSize(self) -> None:
pipe_name = str(uuid.uuid4())
pipe_spec = NamedPipeSpec(pipe_name)
pipe_spec.in_buffer_size = 42
pipe_spec.out_buffer_size = 108
with pipe_spec.Create():
results = list(pipes.ListNamedPipes())
results_by_name = {result.name: result for result in results}
result = results_by_name[pipe_name]
self.assertEqual(result.in_buffer_size, 42)
self.assertEqual(result.out_buffer_size, 108)
def testPid(self) -> None:
pipe_name = str(uuid.uuid4())
pipe_spec = NamedPipeSpec(pipe_name)
with pipe_spec.Create():
results = list(pipes.ListNamedPipes())
results_by_name = {result.name: result for result in results}
result = results_by_name[pipe_name]
self.assertEqual(result.server_pid, os.getpid())
self.assertEqual(result.client_pid, os.getpid())
class NamedPipeSpec:
"""A class with named pipe specification."""
name: str
open_mode: Optional[int] = None
pipe_mode: Optional[int] = None
max_instance_count: Optional[int] = None
in_buffer_size: int = 0
out_buffer_size: int = 0
default_timeout_millis: int = 0
def __init__(self, name: str) -> None:
self.name = name
@contextlib.contextmanager
def Create(self) -> Iterator[None]:
"""Creates a named pipe context conforming to the specification."""
if self.max_instance_count is not None:
max_instance_count = self.max_instance_count
else:
max_instance_count = win32pipe.PIPE_UNLIMITED_INSTANCES
if self.open_mode is not None:
open_mode = self.open_mode
else:
open_mode = win32pipe.PIPE_ACCESS_DUPLEX
if self.pipe_mode is not None:
pipe_mode = self.pipe_mode
else:
pipe_mode = 0
handle = win32pipe.CreateNamedPipe(
f"\\\\.\\pipe\\{self.name}",
open_mode,
pipe_mode,
max_instance_count,
self.in_buffer_size,
self.out_buffer_size,
self.default_timeout_millis,
None,
)
with contextlib.closing(handle):
yield
if __name__ == "__main__":
absltest.main()
|
slack_sdk/web/__init__.py
|
priya1puresoftware/python-slack-sdk
| 2,486 |
54253
|
<gh_stars>1000+
"""The Slack Web API allows you to build applications that interact with Slack
in more complex ways than the integrations we provide out of the box."""
from .client import WebClient # noqa
from .slack_response import SlackResponse # noqa
|
hata/discord/http/headers.py
|
Multiface24111/hata
| 173 |
54286
|
__all__ = ()
from ...backend.utils import istr
AUDIT_LOG_REASON = istr('X-Audit-Log-Reason')
RATE_LIMIT_REMAINING = istr('X-RateLimit-Remaining')
RATE_LIMIT_RESET = istr('X-RateLimit-Reset')
RATE_LIMIT_RESET_AFTER = istr('X-RateLimit-Reset-After')
RATE_LIMIT_LIMIT = istr('X-RateLimit-Limit')
# to send
RATE_LIMIT_PRECISION = istr('X-RateLimit-Precision')
DEBUG_OPTIONS = istr('X-Debug-Options')
|
proxyclient/tools/reboot.py
|
EricRabil/m1n1
| 1,604 |
54289
|
<filename>proxyclient/tools/reboot.py<gh_stars>1000+
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
import sys, pathlib
sys.path.append(str(pathlib.Path(__file__).resolve().parents[1]))
from m1n1.setup import *
p.reboot()
|
py/manipulation/props/object_collection.py
|
wx-b/dm_robotics
| 128 |
54320
|
# Copyright 2020 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Manage collections of props."""
import collections
from typing import Any, Callable, Union
class Singleton(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
return cls._instances[cls]
VersionedSequence = collections.namedtuple('VersionedSequence',
['version', 'ids'])
class PropSetDict(dict):
"""A dictionary that supports a function evaluation on every key access.
Extends the standard dictionary to provide dynamic behaviour for object sets.
"""
def __getitem__(self, key: Any) -> VersionedSequence:
# The method is called during [] access.
# Provides a collection of prop names.
return self._evaluate(dict.__getitem__(self, key))
def __repr__(self) -> str:
return f'{type(self).__name__}({super().__repr__()})'
def get(self, key) -> VersionedSequence:
return self.__getitem__(key)
def values(self):
values = super().values()
return [self._evaluate(x) for x in values]
def items(self):
new_dict = {k: self._evaluate(v) for k, v in super().items()}
return new_dict.items()
def _evaluate(
self, sequence_or_function: Union[VersionedSequence,
Callable[[], VersionedSequence]]
) -> VersionedSequence:
"""Based on the type of an argument, execute different actions.
Supports static sequence containers or functions that create such. When the
argument is a contrainer, the function returns the argument "as is". In case
a callable is provided as an argument, it will be evaluated to create a
container.
Args:
sequence_or_function: A sequence or a function that creates a sequence.
Returns:
A versioned set of names.
"""
if isinstance(sequence_or_function, VersionedSequence):
return sequence_or_function
new_sequence = sequence_or_function()
return new_sequence
|
maketrainingimages.py
|
leidix/images-to-osm
| 487 |
54356
|
<filename>maketrainingimages.py
import imagestoosm.config as cfg
import os
import QuadKey.quadkey as quadkey
import numpy as np
import shapely.geometry as geometry
from skimage import draw
from skimage import io
import csv
minFeatureClip = 0.3
# make the training data images
# construct index of osm data, each point
# for each tile
# check for tiles east and south, and south/east to make 512x512 tile, if no skip
# bounding box for image
# write out image as png
# see what features overlap with image
# if more than >20%
# lit of augmentations (N +45,-45 degree), N offsets
# emit mask for feature for current image.
# training will do flips, intensity, and color shifts if needed
os.system("rm -R " + cfg.trainDir)
os.mkdir(cfg.trainDir)
# load up the OSM features into hash of arrays of polygons, in pixels
features = {}
for classDir in os.listdir(cfg.rootOsmDir) :
classDirFull = os.path.join( cfg.rootOsmDir,classDir)
for fileName in os.listdir(classDirFull) :
fullPath = os.path.join( cfg.rootOsmDir,classDir,fileName)
with open(fullPath, "rt") as csvfile:
csveader = csv.reader(csvfile, delimiter='\t')
pts = []
for row in csveader:
latLot = (float(row[0]),float(row[1]))
pixel = quadkey.TileSystem.geo_to_pixel(latLot,cfg.tileZoom)
pts.append(pixel)
poly = geometry.Polygon(pts)
areaMeters = poly.area * 0.596 *0.596
# don't learn against baseball fields that are outlines just on the
# diamond. They are tagged wrong, don't want to teach the NN that this
# is correct. There are > 1000 of them in the OSM DB, we can't avoid
# them.
if ( classDir != "baseball" or areaMeters > 2500) :
feature = {
"geometry" : poly,
"filename" : fullPath
}
if ( (classDir in features) == False) :
features[classDir] = []
features[classDir].append( feature )
imageWriteCounter = 0
for root, subFolders, files in os.walk(cfg.rootTileDir):
for file in files:
quadKeyStr = os.path.splitext(file)[0]
qkRoot = quadkey.from_str(quadKeyStr)
tilePixel = quadkey.TileSystem.geo_to_pixel(qkRoot.to_geo(), qkRoot.level)
tileRootDir = os.path.split( root)[0]
# stick the adjacent tiles together to make larger images up to max
# image size.
maxImageSize = 256*3
maxTileCount = maxImageSize // 256
count = 0
image = np.zeros([maxImageSize,maxImageSize,3],dtype=np.uint8)
for x in range(maxTileCount) :
for y in range(maxTileCount) :
pixel = ( tilePixel[0] + 256*x, tilePixel[1]+256*y)
geo = quadkey.TileSystem.pixel_to_geo(pixel, qkRoot.level)
qk = quadkey.from_geo(geo, qkRoot.level)
qkStr = str(qk)
tileCacheDir = os.path.join(tileRootDir,qkStr[-3:])
tileFileName = "%s/%s.jpg" % (tileCacheDir, qkStr)
if ( os.path.exists(tileFileName) ) :
try:
image[ y*256 : (y+1)*256, x*256 : (x+1)*256,0:3 ] = io.imread(tileFileName )
count += 1
except:
# try to get the tile again next time.
os.remove( tileFileName)
pts = []
pts.append( ( tilePixel[0]+0,tilePixel[1]+0 ) )
pts.append( ( tilePixel[0]+0,tilePixel[1]+maxImageSize ) )
pts.append( ( tilePixel[0]+maxImageSize,tilePixel[1]+maxImageSize ) )
pts.append( ( tilePixel[0]+maxImageSize,tilePixel[1]+0 ) )
imageBoundingBoxPoly = geometry.Polygon(pts)
featureMask = np.zeros((maxImageSize, maxImageSize), dtype=np.uint8)
featureCountTotal = 0
usedFileNames = []
for featureType in features :
featureCount = 0
for feature in features[featureType] :
if ( imageBoundingBoxPoly.intersects( feature['geometry']) ) :
area = feature['geometry'].area
xs, ys = feature['geometry'].exterior.coords.xy
xs = [ x-tilePixel[0] for x in xs]
ys = [ y-tilePixel[1] for y in ys]
xsClipped = [ min( max( x,0),maxImageSize) for x in xs]
ysClipped = [ min( max( y,0),maxImageSize) for y in ys]
pts2 = []
for i in range(len(xs)) :
pts2.append( (xsClipped[i],ysClipped[i] ) )
clippedPoly = geometry.Polygon(pts2)
newArea = clippedPoly.area
if ( area > 0 and newArea/area > minFeatureClip) :
if (os.path.exists( "%s/%06d" % (cfg.trainDir,imageWriteCounter) ) == False) :
os.mkdir( "%s/%06d" % (cfg.trainDir,imageWriteCounter) )
featureMask.fill(0)
rr, cc = draw.polygon(xs,ys,(maxImageSize,maxImageSize))
featureMask[cc,rr] = 255
io.imsave("%s/%06d/%06d-%s-%d.png" % (cfg.trainDir,imageWriteCounter,imageWriteCounter,featureType,featureCount),featureMask)
usedFileNames.append( feature['filename'] )
featureCount += 1
featureCountTotal += 1
if ( featureCountTotal > 0) :
io.imsave("%s/%06d/%06d.jpg" % (cfg.trainDir,imageWriteCounter,imageWriteCounter),image,quality=100)
with open("%s/%06d/%06d.txt" % (cfg.trainDir,imageWriteCounter,imageWriteCounter), "wt") as text_file:
text_file.write( "%s\n" % (str(qkRoot)))
text_file.write( "%0.8f,%0.8f\n" % qkRoot.to_geo())
for f in usedFileNames :
text_file.write( "%s\n" % (f))
imageWriteCounter += 1
print("%s - %s - tiles %d - features %d" % (os.path.join(root, file), quadKeyStr,count, featureCountTotal))
|
changes/api/task_details.py
|
vault-the/changes
| 443 |
54413
|
<gh_stars>100-1000
from __future__ import absolute_import
from changes.api.base import APIView
from changes.models.task import Task
class TaskDetailsAPIView(APIView):
def _collect_children(self, task):
children = Task.query.filter(
Task.parent_id == task.task_id,
)
results = []
for child in children:
child_data = self.serialize(child)
child_data['children'] = self._collect_children(child)
results.append(child_data)
return results
def get(self, task_id):
task = Task.query.get(task_id)
if task is None:
return '', 404
context = self.serialize(task)
context['children'] = self._collect_children(task)
return self.respond(context)
|
tasks/__init__.py
|
brmson/sts-data
| 690 |
54434
|
<gh_stars>100-1000
from __future__ import print_function
from __future__ import division
import importlib
from keras.layers.core import Activation
from keras.models import Graph
import numpy as np
import random
import traceback
import pysts.loader as loader
from pysts.kerasts import graph_input_slice, graph_input_prune
import pysts.kerasts.blocks as B
def default_config(model_config, task_config):
# TODO: Move this to AbstractTask()?
c = dict()
c['embdim'] = 300
c['embprune'] = 100
c['embicase'] = False
c['inp_e_dropout'] = 1/2
c['inp_w_dropout'] = 0
c['e_add_flags'] = True
c['ptscorer'] = B.mlp_ptscorer
c['mlpsum'] = 'sum'
c['Ddim'] = 2
c['Dinit'] = 'glorot_uniform'
c['f_add_kw'] = False
c['loss'] = 'mse' # you really want to override this in each task's config()
c['balance_class'] = False
c['opt'] = 'adam'
c['fix_layers'] = [] # mainly useful for transfer learning, or 'emb' to fix embeddings
c['batch_size'] = 160
c['nb_epoch'] = 16
c['nb_runs'] = 1
c['epoch_fract'] = 1
c['prescoring'] = None
c['prescoring_prune'] = None
c['prescoring_input'] = None
task_config(c)
if c.get('task>model', False): # task config has higher priority than model
model_config(c)
task_config(c)
else:
model_config(c)
return c
class AbstractTask(object):
def set_conf(self, c):
self.c = c
if 's0pad' in self.c:
self.s0pad = self.c['s0pad']
self.s1pad = self.c['s1pad']
elif 'spad' in self.c:
self.spad = self.c['spad']
self.s0pad = self.c['spad']
self.s1pad = self.c['spad']
def load_vocab(self, vocabf):
_, _, self.vocab = self.load_set(vocabf)
return self.vocab
def load_data(self, trainf, valf, testf=None):
self.trainf = trainf
self.valf = valf
self.testf = testf
self.gr, self.y, self.vocab = self.load_set(trainf)
self.grv, self.yv, _ = self.load_set(valf)
if testf is not None:
self.grt, self.yt, _ = self.load_set(testf)
else:
self.grt, self.yt = (None, None)
if self.c.get('adapt_ubuntu', False):
self.vocab.add_word('__eou__')
self.vocab.add_word('__eot__')
self.gr = loader.graph_adapt_ubuntu(self.gr, self.vocab)
self.grv = loader.graph_adapt_ubuntu(self.grv, self.vocab)
if self.grt is not None:
self.grt = loader.graph_adapt_ubuntu(self.grt, self.vocab)
def sample_pairs(self, gr, batch_size, shuffle=True, once=False):
""" A generator that produces random pairs from the dataset """
try:
id_N = int((len(gr['si0']) + batch_size-1) / batch_size)
ids = list(range(id_N))
while True:
if shuffle:
# XXX: We never swap samples between batches, does it matter?
random.shuffle(ids)
for i in ids:
sl = slice(i * batch_size, (i+1) * batch_size)
ogr = graph_input_slice(gr, sl)
ogr['se0'] = self.emb.map_jset(ogr['sj0'])
ogr['se1'] = self.emb.map_jset(ogr['sj1'])
# print(sl)
# print('<<0>>', ogr['sj0'], ogr['se0'])
# print('<<1>>', ogr['sj1'], ogr['se1'])
yield ogr
if once:
break
except Exception:
traceback.print_exc()
def prescoring_apply(self, gr, skip_oneclass=False):
""" Given a gr, prescore the pairs and do either pruning (for each s0,
keep only top N s1 based on the prescoring) or add the prescore as
an input. """
def prescoring_model(prescoring_task, model, conf, weightsf):
""" Setup and return a pre-scoring model """
# We just make a task instance with the prescoring model
# specific config, build the model and apply it;
# we sometimes don't want the *real* task to do prescoring, e.g. in
# case of hypev which evaluates whole clusters of same-s0 pairs but
# prescoring should be done on the individual tasks
prescore_task = prescoring_task()
# We also set up the config appropriately to the model + task.
prescoring_module = importlib.import_module('.'+model, 'models')
c = default_config(prescoring_module.config, prescore_task.config)
for k, v in conf.items():
c[k] = v
prescore_task.set_conf(c)
print('[Prescoring] Model')
model = prescore_task.build_model(prescoring_module.prep_model)
print('[Prescoring] ' + weightsf)
model.load_weights(weightsf)
return model
if 'prescoring' not in self.c or (self.c['prescoring_prune'] is None and self.c['prescoring_input'] is None):
return gr # nothing to do
if 'prescoring_model_inst' not in self.c:
# cache the prescoring model instance
self.c['prescoring_model_inst'] = prescoring_model(self.prescoring_task, self.c['prescoring'],
self.c.get('prescoring_conf', {}), self.c['prescoring_weightsf'])
print('[Prescoring] Predict')
ypred = self.c['prescoring_model_inst'].predict(gr)['score'][:,0]
if self.c['prescoring_input'] is not None:
inp = self.c['prescoring_input']
gr[inp] = np.reshape(ypred, (len(ypred), 1)) # 1D to 2D
if self.c['prescoring_prune'] is not None:
N = self.c['prescoring_prune']
print('[Prescoring] Prune')
gr = graph_input_prune(gr, ypred, N, skip_oneclass=skip_oneclass)
return gr
def prep_model(self, module_prep_model, oact='sigmoid'):
# Input embedding and encoding
model = Graph()
N = B.embedding(model, self.emb, self.vocab, self.s0pad, self.s1pad,
self.c['inp_e_dropout'], self.c['inp_w_dropout'], add_flags=self.c['e_add_flags'])
# Sentence-aggregate embeddings
final_outputs = module_prep_model(model, N, self.s0pad, self.s1pad, self.c)
# Measurement
if self.c['ptscorer'] == '1':
# special scoring mode just based on the answer
# (assuming that the question match is carried over to the answer
# via attention or another mechanism)
ptscorer = B.cat_ptscorer
final_outputs = [final_outputs[1]]
else:
ptscorer = self.c['ptscorer']
kwargs = dict()
if ptscorer == B.mlp_ptscorer:
kwargs['sum_mode'] = self.c['mlpsum']
kwargs['Dinit'] = self.c['Dinit']
if 'f_add' in self.c:
for inp in self.c['f_add']:
model.add_input(inp, input_shape=(1,)) # assumed scalar
kwargs['extra_inp'] = self.c['f_add']
model.add_node(name='scoreS', input=ptscorer(model, final_outputs, self.c['Ddim'], N, self.c['l2reg'], **kwargs),
layer=Activation(oact))
model.add_output(name='score', input='scoreS')
return model
def fit_model(self, model, **kwargs):
if self.c['ptscorer'] is None:
return model.fit(self.gr, **kwargs)
batch_size = kwargs.pop('batch_size')
kwargs['callbacks'] = self.fit_callbacks(kwargs.pop('weightsf'))
return model.fit_generator(self.sample_pairs(self.gr, batch_size), **kwargs)
def predict(self, model, gr):
if self.c['ptscorer'] is None:
return model.predict(gr)
batch_size = 16384 # XXX: hardcoded
ypred = []
for ogr in self.sample_pairs(gr, batch_size, shuffle=False, once=True):
ypred += list(model.predict(ogr)['score'][:,0])
return np.array(ypred)
|
src/sort/0791.custom-sort-string/custom-sort-string.py
|
lyphui/Just-Code
| 782 |
54445
|
<gh_stars>100-1000
class Solution:
def customSortString(self, S: str, T: str) -> str:
return ''.join(sorted(list(T), key=lambda x:S.find(x)))
|
tools/bin/pythonSrc/pychecker-0.8.18/pychecker2/utest/data.py
|
YangHao666666/hawq
| 450 |
54453
|
<gh_stars>100-1000
import exceptions
class Data:
class DataError(exceptions.ValueError): pass
def __init__(self, value):
self.value = value
def get_value(self):
return self.value
|
OnlineStudy/utils/middlewares.py
|
NanRenTeam-9/MongoMicroCourse
| 132 |
54493
|
from django.utils.deprecation import MiddlewareMixin
class MyCors(MiddlewareMixin):
def process_response(self, requesst, response):
response['Access-Control-Allow-Origin'] = '*'
if requesst.method == 'OPTIONS':
response["Access-Control-Allow-Headers"] = "*"
response['Access-Control-Allow-Methods'] = '*'
return response
|
vectorbt/base/__init__.py
|
haxdds/vectorbt
| 1,787 |
54494
|
# Copyright (c) 2021 <NAME>. All rights reserved.
# This code is licensed under Apache 2.0 with Commons Clause license (see LICENSE.md for details)
"""Modules with base classes and utilities for pandas objects, such as broadcasting."""
from vectorbt.base.array_wrapper import ArrayWrapper
__all__ = [
'ArrayWrapper'
]
__pdoc__ = {k: False for k in __all__}
|
music21/sorting.py
|
cuthbertLab/music21
| 1,449 |
54499
|
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Name: sorting.py
# Purpose: Music21 class for sorting
#
# Authors: <NAME>
#
# Copyright: Copyright © 2014-2015 <NAME> and the music21
# Project
# License: BSD, see license.txt
# -----------------------------------------------------------------------------
'''
This module defines a single class, SortTuple, which is a named tuple that can
sort against bare offsets and other SortTuples.
This is a performance-critical object.
It also defines three singleton instance of the SortTupleLow class as ZeroSortTupleDefault,
ZeroSortTupleLow and
ZeroSortTupleHigh which are sortTuple at
offset 0.0, priority [0, -inf, inf] respectively:
>>> sorting.ZeroSortTupleDefault
SortTuple(atEnd=0, offset=0.0, priority=0, classSortOrder=0, isNotGrace=1, insertIndex=0)
>>> sorting.ZeroSortTupleLow
SortTuple(atEnd=0, offset=0.0, priority=-inf, classSortOrder=0, isNotGrace=1, insertIndex=0)
>>> sorting.ZeroSortTupleHigh
SortTuple(atEnd=0, offset=0.0, priority=inf, classSortOrder=0, isNotGrace=1, insertIndex=0)
'''
from collections import namedtuple
from math import inf as INFINITY
from music21 import exceptions21
_attrList = ['atEnd', 'offset', 'priority', 'classSortOrder', 'isNotGrace', 'insertIndex']
class SortingException(exceptions21.Music21Exception):
pass
class SortTuple(namedtuple('SortTuple', _attrList)):
'''
Derived class of namedTuple which allows for comparisons with pure ints/fractions.
>>> n = note.Note()
>>> s = stream.Stream()
>>> s.insert(4, n)
>>> st = n.sortTuple()
>>> st
SortTuple(atEnd=0, offset=4.0, priority=0, classSortOrder=20, isNotGrace=1, insertIndex=...)
>>> st.shortRepr()
'4.0 <0.20...>'
>>> st.atEnd
0
>>> st.offset
4.0
>>> st < 5.0
True
>>> 5.0 > st
True
>>> st > 3.0
True
>>> 3.0 < st
True
>>> st == 4.0
True
>>> ts = bar.Barline('double')
>>> t = stream.Stream()
>>> t.storeAtEnd(ts)
>>> ts_st = ts.sortTuple()
>>> ts_st
SortTuple(atEnd=1, offset=0.0, priority=0, classSortOrder=-5, isNotGrace=1, insertIndex=...)
>>> st < ts_st
True
>>> ts_st > 999999
True
>>> import math
>>> ts_st == math.inf
True
Construct one w/ keywords:
>>> st = sorting.SortTuple(atEnd=0, offset=1.0, priority=0, classSortOrder=20,
... isNotGrace=1, insertIndex=323)
>>> st.shortRepr()
'1.0 <0.20.323>'
or as tuple:
>>> st = sorting.SortTuple(0, 1.0, 0, 20, 1, 323)
>>> st.shortRepr()
'1.0 <0.20.323>'
'''
def __new__(cls, *tupEls, **kw):
# noinspection PyTypeChecker
return super(SortTuple, cls).__new__(cls, *tupEls, **kw)
def __eq__(self, other):
if isinstance(other, tuple):
return super().__eq__(other)
try:
if self.atEnd == 1 and other != INFINITY:
return False
elif self.atEnd == 1:
return True
else:
return self.offset == other
except ValueError:
return NotImplemented
def __lt__(self, other):
if isinstance(other, tuple):
return super().__lt__(other)
try:
if self.atEnd == 1:
return False
else:
return self.offset < other
except ValueError:
return NotImplemented
def __gt__(self, other):
if isinstance(other, tuple):
return super().__gt__(other)
try:
if self.atEnd == 1 and other != INFINITY:
return True
elif self.atEnd == 1:
return False
else:
return self.offset > other
except ValueError:
return NotImplemented
def __ne__(self, other):
return not self.__eq__(other)
def __le__(self, other):
return self.__lt__(other) or self.__eq__(other)
def __ge__(self, other):
return self.__gt__(other) or self.__eq__(other)
def shortRepr(self):
'''
Returns a nice representation of a SortTuple
>>> st = sorting.SortTuple(atEnd=0, offset=1.0, priority=0, classSortOrder=20,
... isNotGrace=1, insertIndex=323)
>>> st.shortRepr()
'1.0 <0.20.323>'
>>> st = sorting.SortTuple(atEnd=1, offset=1.0, priority=4, classSortOrder=7,
... isNotGrace=0, insertIndex=200)
>>> st.shortRepr()
'End <4.7.[Grace].200>'
'''
reprParts = []
if self.atEnd:
reprParts.append('End')
else:
reprParts.append(str(self.offset))
reprParts.append(' <')
reprParts.append(str(self.priority))
reprParts.append('.')
reprParts.append(str(self.classSortOrder))
if self.isNotGrace == 0:
reprParts.append('.[Grace]')
reprParts.append('.')
reprParts.append(str(self.insertIndex))
reprParts.append('>')
return ''.join(reprParts)
def modify(self, **kw):
'''
return a new SortTuple identical to the previous, except with
the given keyword modified. Works only with keywords.
>>> st = sorting.SortTuple(atEnd=0, offset=1.0, priority=0, classSortOrder=20,
... isNotGrace=1, insertIndex=32)
>>> st2 = st.modify(offset=2.0)
>>> st2.shortRepr()
'2.0 <0.20.32>'
>>> st2
SortTuple(atEnd=0, offset=2.0, priority=0, classSortOrder=20, isNotGrace=1, insertIndex=32)
>>> st3 = st2.modify(atEnd=1, isNotGrace=0)
>>> st3.shortRepr()
'End <0.20.[Grace].32>'
The original tuple is never modified (hence tuple):
>>> st.offset
1.0
Changing offset, but nothing else, helps in creating .flatten() positions.
'''
outList = [kw.get(attr, getattr(self, attr)) for attr in _attrList]
return self.__class__(*outList)
def add(self, other):
'''
Add all attributes from one sortTuple to another,
returning a new one.
>>> n = note.Note()
>>> n.offset = 10
>>> s = stream.Stream()
>>> s.offset = 10
>>> n.sortTuple()
SortTuple(atEnd=0, offset=10.0, priority=0, classSortOrder=20, isNotGrace=1, insertIndex=0)
>>> s.sortTuple()
SortTuple(atEnd=0, offset=10.0, priority=0, classSortOrder=-20, isNotGrace=1, insertIndex=0)
>>> s.sortTuple().add(n.sortTuple())
SortTuple(atEnd=0, offset=20.0, priority=0, classSortOrder=0, isNotGrace=1, insertIndex=0)
Note that atEnd and isNotGrace are equal to other's value. are upper bounded at 1 and
take the maxValue of either.
'''
if not isinstance(other, self.__class__):
raise SortingException('Cannot add attributes from a different class')
outList = [max(getattr(self, attr), getattr(other, attr))
if attr in ('atEnd', 'isNotGrace')
else (getattr(self, attr) + getattr(other, attr))
for attr in _attrList]
return self.__class__(*outList)
def sub(self, other):
'''
Subtract all attributes from to another. atEnd and isNotGrace take the min value of either.
>>> n = note.Note()
>>> n.offset = 10
>>> s = stream.Stream()
>>> s.offset = 10
>>> n.sortTuple()
SortTuple(atEnd=0, offset=10.0, priority=0, classSortOrder=20, isNotGrace=1, insertIndex=0)
>>> s.sortTuple()
SortTuple(atEnd=0, offset=10.0, priority=0, classSortOrder=-20, isNotGrace=1, insertIndex=0)
>>> s.sortTuple().sub(n.sortTuple())
SortTuple(atEnd=0, offset=0.0, priority=0, classSortOrder=-40, isNotGrace=1, insertIndex=0)
Note that atEnd and isNotGrace are lower bounded at 0.
'''
if not isinstance(other, self.__class__):
raise SortingException('Cannot add attributes from a different class')
outList = [min(getattr(self, attr), getattr(other, attr))
if attr in ('atEnd', 'isNotGrace')
else (getattr(self, attr) - getattr(other, attr))
for attr in _attrList]
return self.__class__(*outList)
ZeroSortTupleDefault = SortTuple(atEnd=0, offset=0.0, priority=0, classSortOrder=0,
isNotGrace=1, insertIndex=0)
ZeroSortTupleLow = SortTuple(atEnd=0, offset=0.0, priority=-INFINITY, classSortOrder=0,
isNotGrace=1, insertIndex=0)
ZeroSortTupleHigh = SortTuple(atEnd=0, offset=0.0, priority=INFINITY, classSortOrder=0,
isNotGrace=1, insertIndex=0)
# -----------------------------------------------------------------------------
if __name__ == '__main__':
import music21
music21.mainTest()
|
pinball/master/blessed_version.py
|
DotModus/pinball
| 1,143 |
54504
|
# Copyright 2015, Pinterest, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Definition of a token used to generate unique version values.
Blessed version is stored in the master as any other token. Each time a new
version number is needed, it is generated off the value stored in that token.
The value stored in blessed version is a monotonically increasing counter
so it is guaranteed that no single value is issued more than once.
"""
import sys
import time
from pinball.config.utils import timestamp_to_str
from pinball.master.thrift_lib.ttypes import Token
__author__ = '<NAME>'
__copyright__ = 'Copyright 2015, Pinterest, Inc.'
__credits__ = [__author__]
__license__ = 'Apache'
__version__ = '2.0'
class BlessedVersion(Token):
"""A singleton token keeping track of token versions.
Versions of tokens stored in a given master are required to be unique.
"""
def __init__(self, name=None, owner=None):
"""Create blessed version with a given name and owner.
Name and owner have to either both be set or none should be set.
Blessed version in use should always have name and owner set. The
version of init with name and owner set to None relies on external
initialization of those fields.
Args:
name: The name of the blessed version token.
owner: The owner of the blessed version token.
"""
assert (name and owner) or (not name and not owner)
if name and owner:
now = BlessedVersion._get_timestamp_millis()
data_str = ('blessed version created at %s' %
timestamp_to_str(now / 1000))
Token.__init__(self, now, name, owner, sys.maxint, 0, data_str)
else:
Token.__init__(self)
@staticmethod
def from_token(token):
blessed_version = BlessedVersion()
for key, value in token.__dict__.items():
blessed_version.__dict__[key] = value
return blessed_version
@staticmethod
def _get_timestamp_millis():
"""Return time in milliseconds since the epoch."""
return int(time.time() * 1000)
def advance_version(self):
"""Increase the internal version counter.
The counter value is based on the current time. Since those values
are used as token modification ids, basing them on time has an
advantage for debugging - looking at the version we can tell when a
token was modified.
A BIG WARNING: as an application developer do not assume anything about
the semantics of version values other than their uniqueness. The
implementation details are subject to change.
"""
self.version = max(self.version + 1,
BlessedVersion._get_timestamp_millis())
return self.version
|
mac/pyobjc-framework-Quartz/Examples/Programming with Quartz/BasicDrawing/ColorAndGState.py
|
albertz/music-player
| 132 |
54514
|
import sys
from Quartz import *
import Utilities
import array
def doColorSpaceFillAndStroke(context):
theColorSpace = Utilities.getTheCalibratedRGBColorSpace()
opaqueRed = ( 0.663, 0.0, 0.031, 1.0 ) # red,green,blue,alpha
aBlue = ( 0.482, 0.62, 0.871, 1.0 ) # red,green,blue,alpha
# Set the fill color space to be the generic calibrated RGB color space.
CGContextSetFillColorSpace(context, theColorSpace)
# Set the fill color to opaque red. The number of elements in the
# array passed to this function must be the number of color
# components in the current fill color space plus 1 for alpha.
CGContextSetFillColor(context, opaqueRed)
# Set the stroke color space to be the generic calibrated RGB color space.
CGContextSetStrokeColorSpace(context, theColorSpace)
# Set the stroke color to opaque blue. The number of elements
# in the array passed to this function must be the number of color
# components in the current stroke color space plus 1 for alpha.
CGContextSetStrokeColor(context, aBlue)
CGContextSetLineWidth(context, 8.0)
# Rectangle 1.
CGContextBeginPath(context)
CGContextAddRect(context, CGRectMake(20.0, 20.0, 100.0, 100.0))
CGContextDrawPath(context, kCGPathFillStroke)
# Continue to use the stroke colorspace already set
# but change the stroke alpha value to a semitransparent blue.
aBlue = list(aBlue)
aBlue[3] = 0.5
CGContextSetStrokeColor(context, aBlue)
# Rectangle 2.
CGContextBeginPath(context)
CGContextAddRect(context, CGRectMake(140.0, 20.0, 100.0, 100.0))
CGContextDrawPath(context, kCGPathFillStroke)
# Don't release the color space since this routine
# didn't create it.
_opaqueRedColor = None
_opaqueBlueColor = None
_transparentBlueColor = None
def drawWithColorRefs(context):
global _opaqueRedColor
global _opaqueBlueColor
global _transparentBlueColor
# Initialize the CGColorRefs if necessary
if _opaqueRedColor is None:
# Initialize the color array to an opaque red
# in the generic calibrated RGB color space.
color = (0.663, 0.0, 0.031, 1.0)
theColorSpace = Utilities.getTheCalibratedRGBColorSpace()
# Create a CGColorRef for opaque red.
_opaqueRedColor = CGColorCreate(theColorSpace, color)
# Make the color array correspond to an opaque blue color.
color = (0.482, 0.62, 0.87, 1.0)
# Create another CGColorRef for opaque blue.
_opaqueBlueColor = CGColorCreate(theColorSpace, color)
# Create a new CGColorRef from the opaqueBlue CGColorRef
# but with a different alpha value.
_transparentBlueColor = CGColorCreateCopyWithAlpha(
_opaqueBlueColor, 0.5)
if _opaqueRedColor is None or _opaqueBlueColor is None or _transparentBlueColor is None:
print >>sys.stderr, "Couldn't create one of the CGColorRefs!!!"
return
# Set the fill color to the opaque red CGColor object.
CGContextSetFillColorWithColor(context, _opaqueRedColor)
# Set the stroke color to the opaque blue CGColor object.
CGContextSetStrokeColorWithColor(context, _opaqueBlueColor)
CGContextSetLineWidth(context, 8.0)
# Draw the first rectangle.
CGContextBeginPath(context)
CGContextAddRect(context, CGRectMake(20.0, 20.0, 100.0, 100.0))
CGContextDrawPath(context, kCGPathFillStroke)
# Set the stroke color to be that of the transparent blue
# CGColor object.
CGContextSetStrokeColorWithColor(context, _transparentBlueColor)
# Draw a second rectangle to the right of the first one.
CGContextBeginPath(context)
CGContextAddRect(context, CGRectMake(140.0, 20.0, 100.0, 100.0))
CGContextDrawPath(context, kCGPathFillStroke)
def doIndexedColorDrawGraphics(context):
theBaseRGBSpace = Utilities.getTheCalibratedRGBColorSpace()
lookupTable = array.array('B', (0,)*6)
opaqueRed = (0, 1) # index, alpha
aBlue = (1, 1) # index, alpha
# Set the first 3 values in the lookup table to a red of
# 169/255 = 0.663, no green, and blue = 8/255 = 0.031. This makes
# the first entry in the lookup table a shade of red.
lookupTable[0] = 169; lookupTable[1] = 0; lookupTable[2] = 8
# Set the second 3 values in the lookup table to a red value
# of 123/255 = 0.482, a green value of 158/255 = 0.62, and
# a blue value of 222/255 = 0.871. This makes the second entry
# in the lookup table a shade of blue.
lookupTable[3] = 123; lookupTable[4] = 158; lookupTable[5] = 222
# Create the indexed color space with this color lookup table,
# using the RGB color space as the base color space and a 2 element
# color lookup table to characterize the indexed color space.
theIndexedSpace = CGColorSpaceCreateIndexed(theBaseRGBSpace, 1, lookupTable)
if theIndexedSpace is not None:
CGContextSetStrokeColorSpace(context, theIndexedSpace)
CGContextSetFillColorSpace(context, theIndexedSpace)
# Set the stroke color to an opaque blue.
CGContextSetStrokeColor(context, aBlue)
# Set the fill color to an opaque red.
CGContextSetFillColor(context, opaqueRed)
CGContextSetLineWidth(context, 8.0)
# Draw the first rectangle.
CGContextBeginPath(context)
CGContextAddRect(context, CGRectMake(20.0, 20.0, 100.0, 100.0))
CGContextDrawPath(context, kCGPathFillStroke)
# Continue to use the stroke colorspace already set
# but change the stroke alpha value to a semitransparent value
# while leaving the index value unchanged.
aBlue = list(aBlue)
aBlue[1] = 0.5
CGContextSetStrokeColor(context, aBlue)
# Draw another rectangle to the right of the first one.
CGContextBeginPath(context)
CGContextAddRect(context, CGRectMake(140.0, 20.0, 100.0, 100.0))
CGContextDrawPath(context, kCGPathFillStroke)
else:
print >>sys.stderr, "Couldn't make the indexed color space!"
def drawWithGlobalAlpha(context):
rect = CGRectMake(40.0, 210.0, 100.0, 100.0)
color = [1.0, 0.0, 0.0, 1.0] # opaque red
# Set the fill color space to that returned by getTheCalibratedRGBColorSpace.
CGContextSetFillColorSpace(context, Utilities.getTheCalibratedRGBColorSpace())
CGContextSetFillColor(context, color)
for i in range(2):
CGContextSaveGState(context)
# Paint the leftmost rect on this row with 100% opaque red.
CGContextFillRect(context, rect)
CGContextTranslateCTM(context, rect.size.width + 70.0, 0.0)
# Set the alpha value of this rgba color to 0.5.
color[3] = 0.5
# Use the new color as the fill color in the graphics state.
CGContextSetFillColor(context, color)
# Paint the center rect on this row with 50% opaque red.
CGContextFillRect(context, rect)
CGContextTranslateCTM(context, rect.size.width + 70.0, 0.0)
# Set the alpha value of this rgba color to 0.25.
color[3] = 0.25
# Use the new color as the fill color in the graphics state.
CGContextSetFillColor(context, color)
# Paint the rightmost rect on this row with 25% opaque red.
CGContextFillRect(context, rect)
CGContextRestoreGState(context)
# After restoring the graphics state, the fill color is set to
# that prior to calling CGContextSaveGState, that is, opaque
# red. The coordinate system is also restored.
# Now set the context global alpha value to 50% opaque.
CGContextSetAlpha(context, 0.5)
# Translate down for a second row of rectangles.
CGContextTranslateCTM(context, 0.0, -(rect.size.height + 70.0))
# Reset the alpha value of the color array to fully opaque.
color[3] = 1.0
def drawWithColorBlendMode(context, url):
# A pleasant green color.
green = [0.584, 0.871, 0.318, 1.0]
# Create a CGPDFDocument object from the URL.
pdfDoc = CGPDFDocumentCreateWithURL(url)
if pdfDoc is None:
print >>sys.stderr, "Couldn't create CGPDFDocument from URL!"
return
# Obtain the media box for page 1 of the PDF document.
pdfRect = CGPDFDocumentGetMediaBox(pdfDoc, 1)
# Set the origin of the rectangle to (0,0).
pdfRect.origin.x = pdfRect.origin.y = 0
# Graphic 1, the left portion of the figure.
CGContextTranslateCTM(context, 20, 10 + CGRectGetHeight(pdfRect)/2)
# Draw the PDF document.
CGContextDrawPDFDocument(context, pdfRect, pdfDoc, 1)
# Set the fill color space to that returned by getTheCalibratedRGBColorSpace.
CGContextSetFillColorSpace(context, Utilities.getTheCalibratedRGBColorSpace())
# Set the fill color to green.
CGContextSetFillColor(context, green)
# Graphic 2, the top-right portion of the figure.
CGContextTranslateCTM(context, CGRectGetWidth(pdfRect) + 10,
CGRectGetHeight(pdfRect)/2 + 10)
# Draw the PDF document again.
CGContextDrawPDFDocument(context, pdfRect, pdfDoc, 1)
# Make a fill rectangle that is the same size as the PDF document
# but inset each side by 80 units in x and 20 units in y.
insetRect = CGRectInset(pdfRect, 80, 20)
# Fill the rectangle with green. Because the fill color is opaque and
# the blend mode is Normal, this obscures the drawing underneath.
CGContextFillRect(context, insetRect)
# Graphic 3, the bottom-right portion of the figure.
CGContextTranslateCTM(context, 0, -(10 + CGRectGetHeight(pdfRect)))
# Draw the PDF document again.
CGContextDrawPDFDocument(context, pdfRect, pdfDoc, 1)
# Set the blend mode to kCGBlendModeColor which will
# colorize the destination with subsequent drawing.
CGContextSetBlendMode(context, kCGBlendModeColor)
# Draw the rectangle on top of the PDF document. The portion of the
# background that is covered by the rectangle is colorized
# with the fill color.
CGContextFillRect(context, insetRect)
def createEllipsePath(context, center, ellipseSize):
CGContextSaveGState(context)
# Translate the coordinate origin to the center point.
CGContextTranslateCTM(context, center.x, center.y)
# Scale the coordinate system to half the width and height
# of the ellipse.
CGContextScaleCTM(context, ellipseSize.width/2, ellipseSize.height/2)
CGContextBeginPath(context)
# Add a circular arc to the path, centered at the origin and
# with a radius of 1.0. This radius, together with the
# scaling above for the width and height, produces an ellipse
# of the correct size.
CGContextAddArc(context, 0.0, 0.0, 1.0, 0.0, Utilities.DEGREES_TO_RADIANS(360.0), 0.0)
# Close the path so that this path is suitable for stroking,
# should that be desired.
CGContextClosePath(context)
CGContextRestoreGState(context)
_opaqueBrownColor = None
_opaqueOrangeColor = None
def doClippedEllipse(context):
global _opaqueBrownColor, _opaqueOrangeColor
theCenterPoint = CGPoint(120.0, 120.0)
theEllipseSize = CGSize(100.0, 200.0)
dash = [ 2.0 ]
# Initialize the CGColorRefs if necessary.
if _opaqueBrownColor is None:
# The initial value of the color array is an
# opaque brown in an RGB color space.
color = [0.325, 0.208, 0.157, 1.0]
theColorSpace = Utilities.getTheCalibratedRGBColorSpace()
# Create a CGColorRef for opaque brown.
_opaqueBrownColor = CGColorCreate(theColorSpace, color)
# Make the color array correspond to an opaque orange.
color = [0.965, 0.584, 0.059, 1.0 ]
# Create another CGColorRef for opaque orange.
_opaqueOrangeColor = CGColorCreate(theColorSpace, color)
# Draw two ellipses centered about the same point, one
# rotated 45 degrees from the other.
CGContextSaveGState(context)
# Ellipse 1
createEllipsePath(context, theCenterPoint, theEllipseSize)
CGContextSetFillColorWithColor(context, _opaqueBrownColor)
CGContextFillPath(context)
# Translate and rotate about the center point of the ellipse.
CGContextTranslateCTM(context, theCenterPoint.x, theCenterPoint.y)
# Rotate by 45 degrees.
CGContextRotateCTM(context, Utilities.DEGREES_TO_RADIANS(45))
# Ellipse 2
# CGPointZero is a pre-defined Quartz point corresponding to
# the coordinate (0,0).
createEllipsePath(context, CGPointZero, theEllipseSize)
CGContextSetFillColorWithColor(context, _opaqueOrangeColor)
CGContextFillPath(context)
CGContextRestoreGState(context)
CGContextTranslateCTM(context, 170.0, 0.0)
# Now use the first ellipse as a clipping area prior to
# painting the second ellipse.
CGContextSaveGState(context)
# Ellipse 3
createEllipsePath(context, theCenterPoint, theEllipseSize)
CGContextSetStrokeColorWithColor(context, _opaqueBrownColor)
CGContextSetLineDash(context, 0, dash, 1)
# Stroke the path with a dash.
CGContextStrokePath(context)
# Ellipse 4
createEllipsePath(context, theCenterPoint, theEllipseSize)
# Clip to the elliptical path.
CGContextClip(context)
CGContextTranslateCTM(context, theCenterPoint.x, theCenterPoint.y)
# Rotate by 45 degrees.
CGContextRotateCTM(context, Utilities.DEGREES_TO_RADIANS(45))
# Ellipse 5
createEllipsePath(context, CGPointZero, theEllipseSize)
CGContextSetFillColorWithColor(context, _opaqueOrangeColor)
CGContextFillPath(context)
CGContextRestoreGState(context)
|
tinynumpy/benchmark.py
|
Kramer84/tinynumpy
| 168 |
54556
|
<reponame>Kramer84/tinynumpy<filename>tinynumpy/benchmark.py
# -*- coding: utf-8 -*-
# Copyright (c) 2014, <NAME> and <NAME>
# tinynumpy is distributed under the terms of the MIT License.
""" Benchmarks for tinynumpy
Findings:
* A list of floats costs about 33 bytes per float
* A list if ints costs anout 41 bytes per int
* A huge list of ints 0-255, costs about 1 byter per int
* Python list takes about 5-6 times as much memory than array for 64bit
data types. Up to 40 times as much for uint8, unless Python can reuse
values.
* __slots__ help reduce the size of custom classes
* tinynumpy is about 100 times slower than numpy
* using _toflatlist instead of flat taks 50-60% of time (but more memory)
"""
from __future__ import division
import os
import sys
import time
import subprocess
import numpy as np
import tinynumpy as tnp
def _prettymem(n):
if n > 2**20:
return '%1.2f MiB' % (n / 2**20)
elif n > 2**10:
return '%1.2f KiB' % (n / 2**10)
else:
return '%1.0f B' % n
def _prettysec(n):
if n < 0.0001:
return '%1.2f us' % (n * 1000000)
elif n < 0.1:
return '%1.2f ms' % (n * 1000)
else:
return '%1.2f s' % n
code_template = """
import psutil
import os
import random
import numpy as np
import tinynumpy as tnp
N = 100 * 1000
M = 1000 * 1000
class A(object):
def __init__(self):
self.foo = 8
self.bar = 3.3
class B(object):
__slots__ = ['foo', 'bar']
def __init__(self):
self.foo = 8
self.bar = 3.3
def getmem():
process = psutil.Process(os.getpid())
return process.get_memory_info()[0]
M0 = getmem()
%s
M1 = getmem()
print(M1-M0)
"""
def measure_mem(what, code, divide=1):
cmd = [sys.executable, '-c', code_template % code]
res = subprocess.check_output(cmd, cwd=os.getcwd()).decode('utf-8')
m = int(res) / divide
print('Memory for %s:%s%s' %
(what, ' '*(22-len(what)), _prettymem(m)))
def measure_speed(what, func, *args, **kwargs):
N = 1
t0 = time.perf_counter()
func(*args, **kwargs)
t1 = time.perf_counter()
while (t1 - t0) < 0.2:
N *= 10
t0 = time.perf_counter()
for i in range(N):
func(*args, **kwargs)
t1 = time.perf_counter()
te = t1 - t0
print('Time for %s:%s%s (%i iters)' %
(what, ' '*(22-len(what)), _prettysec(te/N), N))
if __name__ == '__main__':
N = 100 * 1000
M = 1000 * 1000
print('=== MEMORY ====')
measure_mem('floats 0-M', 'L = [i*1.0 for i in range(N)]', N)
measure_mem('ints 0-M', 'L = [i for i in range(N)]', N)
measure_mem('ints 0-255', 'L = [int(random.uniform(0, 255)) for i in range(N)]', N)
measure_mem('regular object', 'L = [A() for i in range(N)]', N)
measure_mem('object with slots', 'L = [B() for i in range(N)]', N)
measure_mem(' Numpy arr size 1', 'L = [np.ones((1,)) for i in range(N)]', N)
measure_mem('Tinynumpy arr size 1', 'L = [tnp.ones((1,)) for i in range(N)]', N)
measure_mem(' Numpy arr size M', 'a = np.ones((M,))')
measure_mem('Tinynumpy arr size M', 'a = tnp.ones((M,))')
print('=== SPEED ====')
a1 = np.ones((100, 100))
a2 = tnp.ones((100, 100))
measure_speed(' numpy sum 10k', a1.sum)
measure_speed('tinynumpy sum 10k', a2.sum)
measure_speed(' numpy max 10k', a1.max)
measure_speed('tinynumpy max 10k', a2.max)
a1 = np.ones((1000, 1000))
a2 = tnp.ones((1000, 1000))
measure_speed(' numpy sum 1M', a1.sum)
measure_speed('tinynumpy sum 1M', a2.sum)
measure_speed(' numpy max 1M', a1.max)
measure_speed('tinynumpy max 1M', a2.max)
|
tests/test_config.py
|
Hellowlol/bw_plex
| 371 |
54575
|
<reponame>Hellowlol/bw_plex
import os
from conftest import TEST_DATA
from bw_plex.config import read_or_make
def test_config():
conf = read_or_make(os.path.join(TEST_DATA, 'test_config.ini'))
assert 'level' not in conf['general']
assert conf['general']['loglevel'] == 'info'
|
cami/scripts/windows.py
|
hugmyndakassi/hvmi
| 677 |
54601
|
#
# Copyright (c) 2020 Bitdefender
# SPDX-License-Identifier: Apache-2.0
#
import yaml
import struct
import os
import crc32
from options import get_options_for_os_version
from objects import CamiYAMLObject, CamiObject, CamiAtom, CamiDataTable, FilePointerException, get_all_objects
from common import IntrocoreVersion
from intro_defines import section_hints, defines, detour_args, version_any
class WinSupportedOs(CamiYAMLObject, CamiAtom):
min_intro_ver = IntrocoreVersion.min_version()
max_intro_ver = IntrocoreVersion.max_version()
yaml_tag = "!intro_update_win_supported_os"
"""
struct _CAMI_WIN_DESCRIPTOR
{
DWORD BuildNumber; // Buildnumber for this Windows OS
BOOLEAN Kpti; // If this OS has Kpti support.
BOOLEAN Is64; // If this OS is 64 bits.
WORD _Reserved1; // Alignment mostly, but may become useful.
QWORD MinIntroVersion; // Minimum introcore version which supports this OS
QWORD MaxIntroVersion; // Maximum introcore version which supports this OS
DWORD KmStructuresCount; // KM opaque fields count
DWORD KmStructuresTable; // KM opaque fields file pointer. (pointer to a CAMI_OPAQUE_STRUCTURE[] array
DWORD UmStructuresCount; // UM opaque fields count
DWORD UmStructuresTable; // UM opaque fields file pointer (pointer to a CAMI_OPAQUE_STRUCTURE[] array
DWORD FunctionCount; // Functions count
DWORD FunctionTable; // Functions file pointer. (pointer to a CAMI_WIN_FUNCTION[] array.
DWORD CustomProtectionOffset; // Protection flags for this os. (pointer to a CAMI_CUSTOM_PROTECTION struct)
DWORD VersionStringOffset;
DWORD _Reserved3;
DWORD _Reserved4;
}
"""
descriptor_layout = "<IBBHQQIIIIIIIIII"
def post_create(self, state):
if hasattr(self, "functions"):
self.functions = WinOsFunctionsTable(state["functions"])
def set_um_fields(self, um_fields_list):
""" Set the UM fields for this OS
We have to do this by hand because a set of um fields apply to a lot of supported OS versions.
This method will iterate the um_fields_list and find the suitable one for this OS.
Args:
um_fields_list: A list of WinOsUmFields.
Raises:
Exception: If multiple or none um_fields match this OS version.
"""
if hasattr(self, "um_fields"):
return
found = None
for um in um_fields_list:
if self.is_64 == um.is64 and self.build_number >= um.min_ver and self.build_number <= um.max_ver:
if found is not None:
raise Exception(
"Found duplicated UM fields for build_number %d, is_64: %r" % (self.build_number, self.is_64)
)
found = um.fields
if found is None:
raise Exception("Could not find um for build_number %d, is_64: %d" % (self.build_number, self.is_64))
self.um_fields = found
def set_functions(self, functions):
""" Set the functions for this OS
Given the list of functions, this method will filter it and will keep only the function with patterns and
arguments needed for this OS and will create the final form of the functions attribute a.k.a. a CamiDataTable instead
of a python list.
Args:
functions: A list of WinFunction
"""
if hasattr(self, "functions"):
return
funcs = WinOsFunctionsTable()
print("Functions for Windows OS {} (is 64: {})".format(self.build_number, self.is_64))
for function in functions:
new_func = function.get_function_for_os(self)
if new_func is not None:
funcs.add_entry(new_func)
print(
"\t- {} with {} patterns and arguments: {}".format(
new_func.name.ljust(30),
str(new_func.patterns.get_entry_count()).rjust(2),
new_func.arguments.args,
).expandtabs()
)
self.functions = funcs
def get_descriptor(self):
""" Generate the CamiDataTable entry for this OS version
Returns:
bytes: the CamiDataTable entry (a _CAMI_WIN_DESCRIPTOR structure)
Raises:
FilePointerException: If this method is called before generating its body with serialize()
"""
print(
"Windows OS {} (kpti: {}, 64: {})".format(
str(self.build_number).ljust(5), str(self.kpti_installed).ljust(5), str(self.is_64).ljust(5),
)
)
print("\t- Options: ", self.intro_options)
print("\t- Min intro version: ", self.min_intro_ver)
print("\t- Max intro version: ", self.max_intro_ver)
return struct.pack(
self.descriptor_layout,
self.build_number,
self.kpti_installed,
self.is_64,
0,
self.min_intro_ver.get_raw(),
self.max_intro_ver.get_raw(),
self.km_fields.get_entry_count(),
self.km_fields.get_file_pointer(),
self.um_fields.get_entry_count(),
self.um_fields.get_file_pointer(),
self.functions.get_entry_count(),
self.functions.get_file_pointer(),
self.intro_options.get_file_pointer(),
self.version_string.get_file_pointer(),
0,
0,
) # reserved
def serialize(self, start):
""" Generate the body of this OS in it's binary form.
Here we are also setting the functions and usermode fields if they are empty.
Args:
start: The offset in the file where this os body will be placed
Returns:
bytes: The body of this OS: um and km fields + functions
"""
self.intro_options = get_options_for_os_version((self.build_number, self.kpti_installed, self.is_64))
self.set_functions(get_all_objects(WinFunction))
self.set_um_fields(get_all_objects(WinOsUmFields))
data = self.km_fields.serialize(start)
data += self.um_fields.serialize(start + len(data))
data += self.functions.serialize(start + len(data))
data += self.intro_options.serialize(start + len(data))
data += self.version_string.serialize(start + len(data))
return data
class WinVersionString(CamiYAMLObject, CamiObject):
yaml_tag = "!intro_update_win_version_string"
descriptor_layout = "<Q{}sQ{}s".format(defines["MAX_VERSION_STRING_SIZE"], defines["MAX_VERSION_STRING_SIZE"])
def serialize(self, start):
self.set_file_pointer(start)
size = len(self.version_string) + 1
if size > (defines["MAX_VERSION_STRING_SIZE"] - 1):
raise Exception("String is too big!")
size_server = len(self.server_version_string) + 1
if size_server > (defines["MAX_VERSION_STRING_SIZE"] - 1):
raise Exception("String for server is too big!")
return struct.pack(
self.descriptor_layout,
size,
bytes(self.version_string, "utf-8"),
size_server,
bytes(self.server_version_string, "utf-8"),
)
class WinOsUmFields(CamiYAMLObject):
yaml_tag = "!intro_update_win_um_fields"
class WinFunction(CamiYAMLObject, CamiAtom):
yaml_tag = "!intro_update_win_function"
"""
struct _CAMI_WIN_FUNCTION
{
DWORD NameHash;
DWORD PatternsCount;
DWORD PatternsTable;
DWORD ArgumentsCount;
DWORD ArgumentsTable;
QWORD _Reserved1;
DWORD _Reserved2;
DWORD _Reserved3;
}
"""
g_patterns_list = []
descriptor_layout = "<IIIIIQII"
def __init__(self, other):
""" This is basically a copy constructor.
We don't use deepcopy because we don't want to duplicate the patterns or arguments
Args:
other: Another WinFunction object
Attributes:
name: The function name
patterns: A table* with the patterns for this function.
arguments: A WinFunctionArgument with the arguments for this function.
Notes:
* Depending on how the object was created, table could mean:
- A python list, if the object was created by the YAML loader. This is an intermediate form and should
be transformed in a CamiDataTable.
- A CamiDataTable, if the object was created by get_function_for_os()
"""
if type(self) != type(other):
raise Exception("Invalid object type sent to {} copy constructor: {}".format(type(self), type(other)))
self.__dict__.update(other.__dict__)
def post_create(self, state):
""" This is the YAML constructor
Args:
state: The YAML file in a dictionary form
"""
# We are doing this because some functions don't have custom arguments
if not hasattr(self, "arguments"):
self.arguments = []
def __eq__(self, other):
if type(self) != type(other):
raise Exception("Invalid comparison between %s and %s" % (type(self), type(other)))
# this is a rudimentary comparison but it's enough for our needs
return self.__dict__ == other.__dict__
def get_function_for_os(self, os):
""" Create another instance of this object which only contains patterns and arguments suitable for the given OS
This method will filter the attributes of this function and will create another object which
will contain only the patterns & arguments which are suitable for the given OS. This method should
be called for object which are in the intermediate form described above.
Args:
os: A SupportedOsWin object
Returns:
- Another instance of this object containing only the patterns and arguments needed by the given OS.
- None, if the functions has no patterns for the given OS or the function is for 64bits OSs and the OS is
a 32bits one (or vice versa).
Raises:
Exception: If there are multiple arguments for this OS. (Maybe we can shall our own exception class ?? )
"""
if self.guest64 != os.is_64:
return None
new_patterns = []
new_arguments = None
for pattern in self.patterns:
if os.build_number >= pattern.min_ver and os.build_number <= pattern.max_ver:
new_patterns.append(pattern)
for arguments in self.arguments:
if os.build_number >= arguments.min_ver and os.build_number <= arguments.max_ver:
if new_arguments is None:
new_arguments = arguments
else:
raise Exception("Found more arguments for function {}, 64: {}".format(self.name, self.guest64))
if len(new_patterns) == 0:
return None
new_patterns = sorted(new_patterns, key=lambda x: x.max_ver - x.min_ver)
new_function = WinFunction(self)
if new_arguments is None:
new_function.arguments = WinFunctionArgument()
else:
new_function.arguments = new_arguments
new_function.patterns = WinFunctionsPatternsTable()
new_function.patterns.set_entries(new_patterns)
try:
idx = self.g_patterns_list.index(new_function.patterns)
new_function.patterns = self.g_patterns_list[idx]
except ValueError:
self.g_patterns_list.append(new_function.patterns)
return new_function
def get_descriptor(self):
""" Generate the CamiDataTable entry for this function
Returns:
bytes: the CamiDataTable entry (a _CAMI_WIN_FUNCTION structure)
Raises:
FilePointerException: If this method is called before generating the binary form of its
code (with serialize)
"""
return struct.pack(
self.descriptor_layout,
crc32.crc32(self.name),
self.patterns.get_entry_count(),
self.patterns.get_file_pointer(),
self.arguments.get_count(),
self.arguments.get_file_pointer(),
0,
0,
0,
)
def serialize(self, start):
""" Generate the body of this function in it's binary form.
Get the binary form of this function's body by packing it's arguments and patterns.
Args:
start: The offset in the file where this function will be placed
Returns:
bytes: The body of this function containing the arguments and patterns
"""
data = self.arguments.serialize(start)
return data + self.patterns.serialize(start + len(data))
class WinFunctionPattern(CamiYAMLObject, CamiAtom):
yaml_tag = "!intro_update_win_pattern"
"""
struct _CAMI_WIN_PATTERN
{
CHAR SectionHint[8];
DWORD HashLength;
DWORD HashOffset;
DWORD _Reserved1;
DWORD _Reserved2;
}
"""
descriptor_layout = "<8sIIII"
def post_create(self, state):
""" The YAML constructor for this object
Args:
state: The YAML file in a dictionary form
"""
if self.min_ver in version_any.keys():
self.min_ver = version_any[self.min_ver]
if self.max_ver in version_any.keys():
self.max_ver = version_any[self.max_ver]
if self.section_hint is None:
self.section_hint = ""
def __eq__(self, other):
if type(self) != type(other):
raise Exception("Invalid comparison between %s and %s" % (type(self), type(other)))
# this is a rudimentary comparison but it's enough for our needs
return self.__dict__ == other.__dict__
def get_descriptor(self):
""" Generate the CamiDataTable entry for this pattern
Returns:
bytes: the CamiDataTable entry (a _CAMI_WIN_PATTERN structure)
Raises:
FilePointerException: If this method is called before generating the binary form
of the pattern code. (with serialize)
"""
return struct.pack(
self.descriptor_layout,
bytes(self.section_hint, "utf-8"),
self.pattern.get_count(),
self.pattern.get_file_pointer(),
0,
0,
)
def serialize(self, start):
""" Genereate the body of this pattern in it's binary form
Get the binary form of this pattern's body by packing it's code.
Args:
start: The offset in the file where this pattern will be placed
Returns:
bytes: The body of this pattern (the code)
"""
return self.pattern.serialize(start)
class WinFunctionArgument(CamiYAMLObject, CamiObject):
yaml_tag = "!intro_update_win_args"
def post_create(self, state):
if self.min_ver in version_any.keys():
self.min_ver = version_any[self.min_ver]
if self.max_ver in version_any.keys():
self.max_ver = version_any[self.max_ver]
def __init__(self):
""" Constructor for this object.
We need this for functions without custom arguments in order to simplify the code
Attributes:
min_ver: Minimum build_number required for this list of arguments
max_ver: Maximum build_number supported by this list of arguments
"""
self.args = []
def get_count(self):
""" Returns the length of the arguments list """
return len(self.args)
def get_binary(self):
""" Pack the arguments in a bytes object
We are doing this here (not in serialize) in order to simplify the code
Returns:
bytes: The arguments in a binary form (can be empty)
May raise KeyError if there are unknown arguments in the YAML file.
"""
c_struct = bytes()
# make sure we don't put more arguments than introcore could use
assert len(self.args) <= detour_args["DET_ARGS_MAX"]
for arg in self.args:
c_struct += struct.pack("<I", detour_args[arg])
return c_struct
def serialize(self, start):
""" Returns the bytes object of the arguments list
The return value can be an empty bytes() object if this list of arguments is already in the file
"""
try:
self.set_file_pointer(start)
except FilePointerException:
return bytes()
return self.get_binary()
class WinSupportedOsTable(CamiDataTable):
section_hint = section_hints["supported_os"] | section_hints["windows"]
entry_type = WinSupportedOs
def process_list(self):
self._entries.sort(key=lambda os: os.build_number)
class WinOsFunctionsTable(CamiDataTable):
# no section hint needed
entry_type = WinFunction
class WinFunctionsPatternsTable(CamiDataTable):
# no section hint needed
entry_type = WinFunctionPattern
|
Chapter08/src/config.py
|
jvstinian/Python-Reinforcement-Learning-Projects
| 114 |
54607
|
child_network_params = {
"learning_rate": 3e-5,
"max_epochs": 100,
"beta": 1e-3,
"batch_size": 20
}
controller_params = {
"max_layers": 3,
"components_per_layer": 4,
'beta': 1e-4,
'max_episodes': 2000,
"num_children_per_episode": 10
}
|
Project 14 -- Deep Cardiac Segmentation/rvseg/models/__init__.py
|
Vauke/Deep-Neural-Networks-HealthCare
| 274 |
54629
|
<reponame>Vauke/Deep-Neural-Networks-HealthCare
from .convunet import unet
from .dilatedunet import dilated_unet
from .dilateddensenet import dilated_densenet, dilated_densenet2, dilated_densenet3
|
hdlConvertor/__init__.py
|
the-moog/hdlConvertor
| 184 |
54649
|
from ._hdlConvertor import HdlConvertorPy as HdlConvertor, ParseException
|
optimus/engines/cudf/cudf.py
|
Pcosmin/Optimus
| 1,045 |
54651
|
class CUDF:
def __init__(self):
self._cudf = None
|
docs/source/platformdirective.py
|
mgrundy/sikuli
| 1,292 |
54656
|
<gh_stars>1000+
from sphinx import addnodes
from sphinx.util.compat import Directive
from sphinx.util.compat import make_admonition
from docutils import nodes
class platform_node(nodes.Admonition, nodes.Element): pass
class PlatformDirective(Directive):
has_content = True
required_arguments = 1
optional_arguments = 0
final_argument_whitespace = True
option_spec = {}
def run(self):
ret = make_admonition(
platform_node, self.name, [self.arguments[0]], self.options,
self.content, self.lineno, self.content_offset, self.block_text,
self.state, self.state_machine)
return ret
def MakePlatformDirective(platform):
class CustomPlatformDirective(Directive):
has_content = True
required_arguments = 0
optional_arguments = 0
final_argument_whitespace = True
option_spec = {}
def run(self):
ret = make_admonition(
platform_node, self.name, [platform], self.options,
self.content, self.lineno, self.content_offset, self.block_text,
self.state, self.state_machine)
return ret
return CustomPlatformDirective
def visit_platform_node(self, node):
self.visit_admonition(node)
def depart_platform_node(self, node):
self.depart_admonition(node)
def setup(app):
app.add_node(platform_node,
html=(visit_platform_node, depart_platform_node),
latex=(visit_platform_node, depart_platform_node),
text=(visit_platform_node, depart_platform_node),
man=(visit_platform_node, depart_platform_node))
app.add_directive('platform', PlatformDirective)
app.add_directive('windows', MakePlatformDirective('Windows'))
app.add_directive('mac', MakePlatformDirective('Mac OS X'))
app.add_directive('linux', MakePlatformDirective('Linux'))
|
plugins/example_collector/test/test_config.py
|
someengineering/resoto
| 126 |
54664
|
from resotolib.config import Config
from resoto_plugin_example_collector import ExampleCollectorPlugin
def test_config():
config = Config("dummy", "dummy")
ExampleCollectorPlugin.add_config(config)
Config.init_default_config()
# assert Config.example.region is None
|
WebMirror/OutputFilters/SeriesPageCommon.py
|
fake-name/ReadableWebProxy
| 193 |
54691
|
<gh_stars>100-1000
import json
import os.path
import cachetools
MIN_RATING_STARS = 2.5
# * 2 to convert from stars to 0-10 range actually used
MIN_RATING_FLOAT = MIN_RATING_STARS * 2
MIN_RATE_CNT = 3
MIN_CHAPTERS = 4
@cachetools.cached(cachetools.TTLCache(100, 60*5))
def _load_lut_internal():
outf = os.path.join(os.path.split(__file__)[0], 'series_overrides.json')
with open(outf) as fp:
cont = fp.read()
lut = json.loads(cont)
return lut
def get_rrl_lut():
lut = _load_lut_internal()
lut = lut['royalroadl']
assert 'force_sequential_numbering' in lut
return lut
def get_sh_lut():
lut = _load_lut_internal()
lut = lut['scribblehub']
assert 'force_sequential_numbering' in lut
return lut
def fix_tag(tagtxt):
# This is literally only tolerable since load_lut is memoized
conf = _load_lut_internal()
if tagtxt in conf['tag_rename']:
tagtxt = conf['tag_rename'][tagtxt]
return tagtxt
def fix_genre(genretxt):
# This is literally only tolerable since load_lut is memoized
conf = _load_lut_internal()
if genretxt in conf['genre_rename']:
genretxt = conf['genre_rename'][genretxt]
return genretxt
def clean_tag(in_txt):
assert isinstance(in_txt, str), "Passed item is not a string! Type: '%s' -> '%s'" % (type(in_txt), in_txt, )
assert not "," in in_txt, "It looks like a tag list got submitted as a tag! String: '%s'" % (in_txt, )
in_txt = in_txt.strip().lower().replace(" ", "-")
return in_txt
def check_fix_numbering(log, releases, series_id, rrl=False, sh=False):
assert rrl or sh
assert sum([rrl, sh]) == 1
if not isinstance(series_id, str):
log.warning("Series id is not a string: %s -> %s", series_id, type(series_id))
assert isinstance(series_id, (str, int))
series_id = str(series_id)
if rrl:
conf = get_rrl_lut()
elif sh:
conf = get_sh_lut()
must_renumber = series_id in conf['force_sequential_numbering']
missing_chap = 0
distinct = set()
for item in releases:
if not (item['vol'] or item['chp']):
missing_chap += 1
distinct.add((item['vol'], item['chp'], item['frag']))
if not releases:
return []
# If less then half the release items have unique vol-chap-frag tuples,
# Apply a forced numbering scheme.
if len(distinct) < (len(releases) / 2.0):
must_renumber = True
unnumbered = (missing_chap/len(releases)) * 100
if (len(releases) >= 5 and unnumbered > 80) or must_renumber:
if must_renumber:
log.warning("Item numbering force-overridden! Adding simple sequential chapter numbers.")
else:
log.warning("Item seems to not have numbered chapters. Adding simple sequential chapter numbers.")
chap = 1
for item in releases:
item['vol'] = None
item['chp'] = chap
chap += 1
return releases
def test():
get_rrl_lut()
if __name__ == "__main__":
test()
|
script_training.py
|
vartikagpt10/memae-anomaly-detection
| 297 |
54734
|
import os
import utils
import torch
import torch.nn as nn
from torchvision import transforms
from torch.utils.data import DataLoader
import numpy as np
import data
import scipy.io as sio
from options.training_options import TrainOptions
import utils
import time
from models import AutoEncoderCov3D, AutoEncoderCov3DMem
from models import EntropyLossEncap
###
opt_parser = TrainOptions()
opt = opt_parser.parse(is_print=True)
use_cuda = opt.UseCUDA
device = torch.device("cuda" if use_cuda else "cpu")
###
utils.seed(opt.Seed)
if(opt.IsDeter):
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
######
model_setting = utils.get_model_setting(opt)
print('Setting: %s' % (model_setting))
############
batch_size_in = opt.BatchSize
learning_rate = opt.LR
max_epoch_num = opt.EpochNum
chnum_in_ = opt.ImgChnNum # channel number of the input images
framenum_in_ = opt.FrameNum # num of frames in a video clip
mem_dim_in = opt.MemDim
entropy_loss_weight = opt.EntropyLossWeight
sparse_shrink_thres = opt.ShrinkThres
img_crop_size = 0
print('bs=%d, lr=%f, entrloss=%f, shr=%f, memdim=%d' % (batch_size_in, learning_rate, entropy_loss_weight, sparse_shrink_thres, mem_dim_in))
############
## data path
data_root = opt.DataRoot + opt.Dataset + '/'
tr_data_frame_dir = data_root + 'Train/'
tr_data_idx_dir = data_root + 'Train_idx/'
############ model saving dir path
saving_root = opt.ModelRoot
saving_model_path = os.path.join(saving_root, 'model_' + model_setting + '/')
utils.mkdir(saving_model_path)
### tblog
if(opt.IsTbLog):
log_path = os.path.join(saving_root, 'log_'+model_setting + '/')
utils.mkdir(log_path)
tb_logger = utils.Logger(log_path)
##
if(chnum_in_==1):
norm_mean = [0.5]
norm_std = [0.5]
elif(chnum_in_==3):
norm_mean = (0.5, 0.5, 0.5)
norm_std = (0.5, 0.5, 0.5)
frame_trans = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(norm_mean, norm_std)
])
unorm_trans = utils.UnNormalize(mean=norm_mean, std=norm_std)
###### data
video_dataset = data.VideoDataset(tr_data_idx_dir, tr_data_frame_dir, transform=frame_trans)
tr_data_loader = DataLoader(video_dataset,
batch_size=batch_size_in,
shuffle=True,
num_workers=opt.NumWorker
)
###### model
if(opt.ModelName=='MemAE'):
model = AutoEncoderCov3DMem(chnum_in_, mem_dim_in, shrink_thres=sparse_shrink_thres)
else:
model = []
print('Wrong model name.')
model.apply(utils.weights_init)
#########
device = torch.device("cuda" if use_cuda else "cpu")
model.to(device)
tr_recon_loss_func = nn.MSELoss().to(device)
tr_entropy_loss_func = EntropyLossEncap().to(device)
tr_optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
##
data_loader_len = len(tr_data_loader)
textlog_interval = opt.TextLogInterval
snap_save_interval = opt.SnapInterval
save_check_interval = opt.SaveCheckInterval
tb_img_log_interval = opt.TBImgLogInterval
global_ite_idx = 0 # for logging
for epoch_idx in range(0, max_epoch_num):
for batch_idx, (item, frames) in enumerate(tr_data_loader):
frames = frames.to(device)
if (opt.ModelName == 'MemAE'):
recon_res = model(frames)
recon_frames = recon_res['output']
att_w = recon_res['att']
loss = tr_recon_loss_func(recon_frames, frames)
recon_loss_val = loss.item()
entropy_loss = tr_entropy_loss_func(att_w)
entropy_loss_val = entropy_loss.item()
loss = loss + entropy_loss_weight * entropy_loss
loss_val = loss.item()
##
tr_optimizer.zero_grad()
loss.backward()
tr_optimizer.step()
##
## TB log val
if(opt.IsTbLog):
tb_info = {
'loss': loss_val,
'recon_loss': recon_loss_val,
'entropy_loss': entropy_loss_val
}
for tag, value in tb_info.items():
tb_logger.scalar_summary(tag, value, global_ite_idx)
# TB log img
if( (global_ite_idx % tb_img_log_interval)==0 ):
frames_vis = utils.vframes2imgs(unorm_trans(frames.data), step=5, batch_idx=0)
frames_vis = np.concatenate(frames_vis, axis=-1)
frames_vis = frames_vis[None, :, :] * np.ones(3, dtype=int)[:, None, None]
frames_recon_vis = utils.vframes2imgs(unorm_trans(recon_frames.data), step=5, batch_idx=0)
frames_recon_vis = np.concatenate(frames_recon_vis, axis=-1)
frames_recon_vis = frames_recon_vis[None, :, :] * np.ones(3, dtype=int)[:, None, None]
tb_info = {
'x': frames_vis,
'x_rec': frames_recon_vis
}
for tag, imgs in tb_info.items():
tb_logger.image_summary(tag, imgs, global_ite_idx)
##
if((batch_idx % textlog_interval)==0):
print('[%s, epoch %d/%d, bt %d/%d] loss=%f, rc_losss=%f, ent_loss=%f' % (model_setting, epoch_idx, max_epoch_num, batch_idx, data_loader_len, loss_val, recon_loss_val, entropy_loss_val) )
if((global_ite_idx % snap_save_interval)==0):
torch.save(model.state_dict(), '%s/%s_snap.pt' % (saving_model_path, model_setting) )
global_ite_idx += 1
if((epoch_idx % save_check_interval)==0):
torch.save(model.state_dict(), '%s/%s_epoch_%04d.pt' % (saving_model_path, model_setting, epoch_idx) )
torch.save(model.state_dict(), '%s/%s_epoch_%04d_final.pt' % (saving_model_path, model_setting, epoch_idx) )
|
flowtorch/distributions/__init__.py
|
sankethvedula/flowtorch
| 207 |
54737
|
# Copyright (c) Meta Platforms, Inc
"""
Warning: This file was generated by flowtorch/scripts/generate_imports.py
Do not modify or delete!
"""
from flowtorch.distributions.flow import Flow
from flowtorch.distributions.neals_funnel import NealsFunnel
__all__ = ["Flow", "NealsFunnel"]
|
test/fixtures/python/corpus/assignment.B.py
|
matsubara0507/semantic
| 8,844 |
54738
|
<gh_stars>1000+
a, b = 2, 1
c = 1
b, = 1, 2
|
ckan/tests/config/test_middleware.py
|
jbrown-xentity/ckan
| 2,805 |
54746
|
# encoding: utf-8
import pytest
import six
from flask import Blueprint
import ckan.plugins as p
from ckan.common import config, _
class MockRoutingPlugin(p.SingletonPlugin):
p.implements(p.IBlueprint)
def get_blueprint(self):
# Create Blueprint for plugin
blueprint = Blueprint(self.name, self.__module__)
blueprint.add_url_rule(
u"/simple_flask", u"flask_plugin_view", flask_plugin_view
)
blueprint.add_url_rule(
u"/flask_translated", u"flask_translated", flask_translated_view
)
return blueprint
def flask_plugin_view():
return u"Hello World, this is served from a Flask extension"
def flask_translated_view():
return _(u"Dataset")
@pytest.fixture
def patched_app(app):
flask_app = app.flask_app
def test_view():
return u"This was served from Flask"
flask_app.add_url_rule(
u"/flask_core", view_func=test_view, endpoint=u"flask_core.index"
)
return app
def test_flask_core_route_is_served(patched_app):
res = patched_app.get(u"/")
assert res.status_code == 200
res = patched_app.get(u"/flask_core")
assert six.ensure_text(res.data) == u"This was served from Flask"
@pytest.mark.ckan_config(u"SECRET_KEY", u"super_secret_stuff")
def test_secret_key_is_used_if_present(app):
assert app.flask_app.config[u"SECRET_KEY"] == u"super_secret_stuff"
@pytest.mark.ckan_config(u"SECRET_KEY", None)
def test_beaker_secret_is_used_by_default(app):
assert (
app.flask_app.config[u"SECRET_KEY"] == config[u"beaker.session.secret"]
)
@pytest.mark.ckan_config(u"SECRET_KEY", None)
@pytest.mark.ckan_config(u"beaker.session.secret", None)
def test_no_beaker_secret_crashes(make_app):
# TODO: When Pylons is finally removed, we should test for
# RuntimeError instead (thrown on `make_flask_stack`)
with pytest.raises(RuntimeError):
make_app()
|
designate/tests/unit/scheduler/test_permutations.py
|
mrlesmithjr/designate
| 145 |
54758
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from unittest import mock
from oslo_config import cfg
from oslo_config import fixture as cfg_fixture
from designate import exceptions
from designate import objects
from designate import scheduler
from designate import tests
DEFAULT_POOL_ID = BRONZE_POOL_ID = '67d71c2a-645c-4dde-a6b8-60a172c9ede8'
SILVER_POOL_ID = '5fabcd37-262c-4cf3-8625-7f419434b6df'
GOLD_POOL_ID = '24702e43-8a52-440f-ab74-19fc16048860'
def build_test_pools():
pools = objects.PoolList.from_list(
[
{'id': DEFAULT_POOL_ID},
{'id': SILVER_POOL_ID},
{'id': GOLD_POOL_ID},
]
)
# Pool 0 is also the default pool.
pool_0_attributes = objects.PoolAttributeList.from_list([
{
'key': 'service_tier',
'value': 'bronze'
},
])
pool_1_attributes = objects.PoolAttributeList.from_list([
{
'key': 'service_tier',
'value': 'silver'
},
])
pool_2_attributes = objects.PoolAttributeList.from_list([
{
'key': 'service_tier',
'value': 'gold'
},
])
pools[0].attributes = pool_0_attributes
pools[1].attributes = pool_1_attributes
pools[2].attributes = pool_2_attributes
return pools
class AttributeSchedulerPermutationsTest(tests.TestCase):
def setUp(self):
super(AttributeSchedulerPermutationsTest, self).setUp()
self.CONF = self.useFixture(cfg_fixture.Config(cfg.CONF)).conf
self.context = self.get_context()
self.CONF.set_override(
'scheduler_filters', ['attribute'], 'service:central'
)
self.CONF.set_override(
'default_pool_id', DEFAULT_POOL_ID, 'service:central'
)
attrs = {
'find_pools.return_value': build_test_pools()
}
mock_storage = mock.Mock(**attrs)
self.scheduler = scheduler.get_scheduler(storage=mock_storage)
def test_get_gold_tier(self):
zone = objects.Zone(
name='example.com.',
type='PRIMARY',
email='<EMAIL>',
attributes=objects.ZoneAttributeList.from_list(
[
{
'key': 'service_tier',
'value': 'gold'
},
]
)
)
result = self.scheduler.schedule_zone(self.context, zone)
self.assertEqual(GOLD_POOL_ID, result)
def test_get_silver_tier(self):
zone = objects.Zone(
name='example.com.',
type='PRIMARY',
email='<EMAIL>',
attributes=objects.ZoneAttributeList.from_list(
[
{
'key': 'service_tier',
'value': 'silver'
},
]
)
)
result = self.scheduler.schedule_zone(self.context, zone)
self.assertEqual(SILVER_POOL_ID, result)
def test_get_bronze_tier(self):
zone = objects.Zone(
name='example.com.',
type='PRIMARY',
email='<EMAIL>',
attributes=objects.ZoneAttributeList.from_list(
[
{
'key': 'service_tier',
'value': 'bronze'
},
]
)
)
result = self.scheduler.schedule_zone(self.context, zone)
self.assertEqual(BRONZE_POOL_ID, result)
def test_tier_not_found_raises_exception(self):
zone = objects.Zone(
name='example.com.',
type='PRIMARY',
email='<EMAIL>',
attributes=objects.ZoneAttributeList.from_list(
[
{
'key': 'service_tier',
'value': 'blue'
},
]
)
)
self.assertRaises(
exceptions.NoValidPoolFound,
self.scheduler.schedule_zone, self.context, zone
)
def test_no_tier_raises_exception(self):
zone = objects.Zone(
name='example.com.',
type='PRIMARY',
email='<EMAIL>',
attributes=objects.ZoneAttributeList.from_list(
[]
)
)
# When no attribute is requested it will return all available pools.
# NOTE(eandersson): This is probably not intended behavior.
# We probably want this to return NoValidPoolFound,
# so that we can use a fallback filter with the
# attribute filter.
self.assertRaises(
exceptions.MultiplePoolsFound,
self.scheduler.schedule_zone, self.context, zone
)
class DefaultSchedulerPermutationsTest(tests.TestCase):
def setUp(self):
super(DefaultSchedulerPermutationsTest, self).setUp()
self.CONF = self.useFixture(cfg_fixture.Config(cfg.CONF)).conf
self.context = self.get_context()
self.CONF.set_override(
'scheduler_filters', ['default_pool'], 'service:central'
)
self.CONF.set_override(
'default_pool_id', DEFAULT_POOL_ID, 'service:central'
)
attrs = {
'find_pools.return_value': build_test_pools()
}
mock_storage = mock.Mock(**attrs)
self.scheduler = scheduler.get_scheduler(storage=mock_storage)
def test_get_default_pool(self):
zone = objects.Zone(
name='example.com.',
type='PRIMARY',
email='<EMAIL>',
)
result = self.scheduler.schedule_zone(self.context, zone)
self.assertEqual(DEFAULT_POOL_ID, result)
class FallbackSchedulerPermutationsTest(tests.TestCase):
def setUp(self):
super(FallbackSchedulerPermutationsTest, self).setUp()
self.CONF = self.useFixture(cfg_fixture.Config(cfg.CONF)).conf
self.context = self.get_context()
self.CONF.set_override(
'scheduler_filters', ['attribute', 'fallback'], 'service:central'
)
self.CONF.set_override(
'default_pool_id', DEFAULT_POOL_ID, 'service:central'
)
attrs = {
'find_pools.return_value': build_test_pools()
}
mock_storage = mock.Mock(**attrs)
self.scheduler = scheduler.get_scheduler(storage=mock_storage)
def test_tier_not_found_return_default(self):
zone = objects.Zone(
name='example.com.',
type='PRIMARY',
email='<EMAIL>',
attributes=objects.ZoneAttributeList.from_list(
[
{
'key': 'service_tier',
'value': 'that does not exist'
},
]
)
)
result = self.scheduler.schedule_zone(self.context, zone)
self.assertEqual(DEFAULT_POOL_ID, result)
|
src/genie/libs/parser/iosxe/tests/ShowSnmpMib/cli/equal/golden_output1_expected.py
|
balmasea/genieparser
| 204 |
54777
|
expected_output = {
"aal5VccEntry": {"3": {}, "4": {}, "5": {}},
"aarpEntry": {"1": {}, "2": {}, "3": {}},
"adslAtucChanConfFastMaxTxRate": {},
"adslAtucChanConfFastMinTxRate": {},
"adslAtucChanConfInterleaveMaxTxRate": {},
"adslAtucChanConfInterleaveMinTxRate": {},
"adslAtucChanConfMaxInterleaveDelay": {},
"adslAtucChanCorrectedBlks": {},
"adslAtucChanCrcBlockLength": {},
"adslAtucChanCurrTxRate": {},
"adslAtucChanInterleaveDelay": {},
"adslAtucChanIntervalCorrectedBlks": {},
"adslAtucChanIntervalReceivedBlks": {},
"adslAtucChanIntervalTransmittedBlks": {},
"adslAtucChanIntervalUncorrectBlks": {},
"adslAtucChanIntervalValidData": {},
"adslAtucChanPerfCurr15MinCorrectedBlks": {},
"adslAtucChanPerfCurr15MinReceivedBlks": {},
"adslAtucChanPerfCurr15MinTimeElapsed": {},
"adslAtucChanPerfCurr15MinTransmittedBlks": {},
"adslAtucChanPerfCurr15MinUncorrectBlks": {},
"adslAtucChanPerfCurr1DayCorrectedBlks": {},
"adslAtucChanPerfCurr1DayReceivedBlks": {},
"adslAtucChanPerfCurr1DayTimeElapsed": {},
"adslAtucChanPerfCurr1DayTransmittedBlks": {},
"adslAtucChanPerfCurr1DayUncorrectBlks": {},
"adslAtucChanPerfInvalidIntervals": {},
"adslAtucChanPerfPrev1DayCorrectedBlks": {},
"adslAtucChanPerfPrev1DayMoniSecs": {},
"adslAtucChanPerfPrev1DayReceivedBlks": {},
"adslAtucChanPerfPrev1DayTransmittedBlks": {},
"adslAtucChanPerfPrev1DayUncorrectBlks": {},
"adslAtucChanPerfValidIntervals": {},
"adslAtucChanPrevTxRate": {},
"adslAtucChanReceivedBlks": {},
"adslAtucChanTransmittedBlks": {},
"adslAtucChanUncorrectBlks": {},
"adslAtucConfDownshiftSnrMgn": {},
"adslAtucConfMaxSnrMgn": {},
"adslAtucConfMinDownshiftTime": {},
"adslAtucConfMinSnrMgn": {},
"adslAtucConfMinUpshiftTime": {},
"adslAtucConfRateChanRatio": {},
"adslAtucConfRateMode": {},
"adslAtucConfTargetSnrMgn": {},
"adslAtucConfUpshiftSnrMgn": {},
"adslAtucCurrAtn": {},
"adslAtucCurrAttainableRate": {},
"adslAtucCurrOutputPwr": {},
"adslAtucCurrSnrMgn": {},
"adslAtucCurrStatus": {},
"adslAtucDmtConfFastPath": {},
"adslAtucDmtConfFreqBins": {},
"adslAtucDmtConfInterleavePath": {},
"adslAtucDmtFastPath": {},
"adslAtucDmtInterleavePath": {},
"adslAtucDmtIssue": {},
"adslAtucDmtState": {},
"adslAtucInitFailureTrapEnable": {},
"adslAtucIntervalESs": {},
"adslAtucIntervalInits": {},
"adslAtucIntervalLofs": {},
"adslAtucIntervalLols": {},
"adslAtucIntervalLoss": {},
"adslAtucIntervalLprs": {},
"adslAtucIntervalValidData": {},
"adslAtucInvSerialNumber": {},
"adslAtucInvVendorID": {},
"adslAtucInvVersionNumber": {},
"adslAtucPerfCurr15MinESs": {},
"adslAtucPerfCurr15MinInits": {},
"adslAtucPerfCurr15MinLofs": {},
"adslAtucPerfCurr15MinLols": {},
"adslAtucPerfCurr15MinLoss": {},
"adslAtucPerfCurr15MinLprs": {},
"adslAtucPerfCurr15MinTimeElapsed": {},
"adslAtucPerfCurr1DayESs": {},
"adslAtucPerfCurr1DayInits": {},
"adslAtucPerfCurr1DayLofs": {},
"adslAtucPerfCurr1DayLols": {},
"adslAtucPerfCurr1DayLoss": {},
"adslAtucPerfCurr1DayLprs": {},
"adslAtucPerfCurr1DayTimeElapsed": {},
"adslAtucPerfESs": {},
"adslAtucPerfInits": {},
"adslAtucPerfInvalidIntervals": {},
"adslAtucPerfLofs": {},
"adslAtucPerfLols": {},
"adslAtucPerfLoss": {},
"adslAtucPerfLprs": {},
"adslAtucPerfPrev1DayESs": {},
"adslAtucPerfPrev1DayInits": {},
"adslAtucPerfPrev1DayLofs": {},
"adslAtucPerfPrev1DayLols": {},
"adslAtucPerfPrev1DayLoss": {},
"adslAtucPerfPrev1DayLprs": {},
"adslAtucPerfPrev1DayMoniSecs": {},
"adslAtucPerfValidIntervals": {},
"adslAtucThresh15MinESs": {},
"adslAtucThresh15MinLofs": {},
"adslAtucThresh15MinLols": {},
"adslAtucThresh15MinLoss": {},
"adslAtucThresh15MinLprs": {},
"adslAtucThreshFastRateDown": {},
"adslAtucThreshFastRateUp": {},
"adslAtucThreshInterleaveRateDown": {},
"adslAtucThreshInterleaveRateUp": {},
"adslAturChanConfFastMaxTxRate": {},
"adslAturChanConfFastMinTxRate": {},
"adslAturChanConfInterleaveMaxTxRate": {},
"adslAturChanConfInterleaveMinTxRate": {},
"adslAturChanConfMaxInterleaveDelay": {},
"adslAturChanCorrectedBlks": {},
"adslAturChanCrcBlockLength": {},
"adslAturChanCurrTxRate": {},
"adslAturChanInterleaveDelay": {},
"adslAturChanIntervalCorrectedBlks": {},
"adslAturChanIntervalReceivedBlks": {},
"adslAturChanIntervalTransmittedBlks": {},
"adslAturChanIntervalUncorrectBlks": {},
"adslAturChanIntervalValidData": {},
"adslAturChanPerfCurr15MinCorrectedBlks": {},
"adslAturChanPerfCurr15MinReceivedBlks": {},
"adslAturChanPerfCurr15MinTimeElapsed": {},
"adslAturChanPerfCurr15MinTransmittedBlks": {},
"adslAturChanPerfCurr15MinUncorrectBlks": {},
"adslAturChanPerfCurr1DayCorrectedBlks": {},
"adslAturChanPerfCurr1DayReceivedBlks": {},
"adslAturChanPerfCurr1DayTimeElapsed": {},
"adslAturChanPerfCurr1DayTransmittedBlks": {},
"adslAturChanPerfCurr1DayUncorrectBlks": {},
"adslAturChanPerfInvalidIntervals": {},
"adslAturChanPerfPrev1DayCorrectedBlks": {},
"adslAturChanPerfPrev1DayMoniSecs": {},
"adslAturChanPerfPrev1DayReceivedBlks": {},
"adslAturChanPerfPrev1DayTransmittedBlks": {},
"adslAturChanPerfPrev1DayUncorrectBlks": {},
"adslAturChanPerfValidIntervals": {},
"adslAturChanPrevTxRate": {},
"adslAturChanReceivedBlks": {},
"adslAturChanTransmittedBlks": {},
"adslAturChanUncorrectBlks": {},
"adslAturConfDownshiftSnrMgn": {},
"adslAturConfMaxSnrMgn": {},
"adslAturConfMinDownshiftTime": {},
"adslAturConfMinSnrMgn": {},
"adslAturConfMinUpshiftTime": {},
"adslAturConfRateChanRatio": {},
"adslAturConfRateMode": {},
"adslAturConfTargetSnrMgn": {},
"adslAturConfUpshiftSnrMgn": {},
"adslAturCurrAtn": {},
"adslAturCurrAttainableRate": {},
"adslAturCurrOutputPwr": {},
"adslAturCurrSnrMgn": {},
"adslAturCurrStatus": {},
"adslAturDmtConfFastPath": {},
"adslAturDmtConfFreqBins": {},
"adslAturDmtConfInterleavePath": {},
"adslAturDmtFastPath": {},
"adslAturDmtInterleavePath": {},
"adslAturDmtIssue": {},
"adslAturDmtState": {},
"adslAturIntervalESs": {},
"adslAturIntervalLofs": {},
"adslAturIntervalLoss": {},
"adslAturIntervalLprs": {},
"adslAturIntervalValidData": {},
"adslAturInvSerialNumber": {},
"adslAturInvVendorID": {},
"adslAturInvVersionNumber": {},
"adslAturPerfCurr15MinESs": {},
"adslAturPerfCurr15MinLofs": {},
"adslAturPerfCurr15MinLoss": {},
"adslAturPerfCurr15MinLprs": {},
"adslAturPerfCurr15MinTimeElapsed": {},
"adslAturPerfCurr1DayESs": {},
"adslAturPerfCurr1DayLofs": {},
"adslAturPerfCurr1DayLoss": {},
"adslAturPerfCurr1DayLprs": {},
"adslAturPerfCurr1DayTimeElapsed": {},
"adslAturPerfESs": {},
"adslAturPerfInvalidIntervals": {},
"adslAturPerfLofs": {},
"adslAturPerfLoss": {},
"adslAturPerfLprs": {},
"adslAturPerfPrev1DayESs": {},
"adslAturPerfPrev1DayLofs": {},
"adslAturPerfPrev1DayLoss": {},
"adslAturPerfPrev1DayLprs": {},
"adslAturPerfPrev1DayMoniSecs": {},
"adslAturPerfValidIntervals": {},
"adslAturThresh15MinESs": {},
"adslAturThresh15MinLofs": {},
"adslAturThresh15MinLoss": {},
"adslAturThresh15MinLprs": {},
"adslAturThreshFastRateDown": {},
"adslAturThreshFastRateUp": {},
"adslAturThreshInterleaveRateDown": {},
"adslAturThreshInterleaveRateUp": {},
"adslLineAlarmConfProfile": {},
"adslLineAlarmConfProfileRowStatus": {},
"adslLineCoding": {},
"adslLineConfProfile": {},
"adslLineConfProfileRowStatus": {},
"adslLineDmtConfEOC": {},
"adslLineDmtConfMode": {},
"adslLineDmtConfTrellis": {},
"adslLineDmtEOC": {},
"adslLineDmtTrellis": {},
"adslLineSpecific": {},
"adslLineType": {},
"alarmEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"alpsAscuA1": {},
"alpsAscuA2": {},
"alpsAscuAlarmsEnabled": {},
"alpsAscuCktName": {},
"alpsAscuDownReason": {},
"alpsAscuDropsAscuDisabled": {},
"alpsAscuDropsAscuDown": {},
"alpsAscuDropsGarbledPkts": {},
"alpsAscuEnabled": {},
"alpsAscuEntry": {"20": {}},
"alpsAscuFwdStatusOption": {},
"alpsAscuInOctets": {},
"alpsAscuInPackets": {},
"alpsAscuMaxMsgLength": {},
"alpsAscuOutOctets": {},
"alpsAscuOutPackets": {},
"alpsAscuRetryOption": {},
"alpsAscuRowStatus": {},
"alpsAscuState": {},
"alpsCktAscuId": {},
"alpsCktAscuIfIndex": {},
"alpsCktAscuStatus": {},
"alpsCktBaseAlarmsEnabled": {},
"alpsCktBaseConnType": {},
"alpsCktBaseCurrPeerConnId": {},
"alpsCktBaseCurrentPeer": {},
"alpsCktBaseDownReason": {},
"alpsCktBaseDropsCktDisabled": {},
"alpsCktBaseDropsLifeTimeExpd": {},
"alpsCktBaseDropsQOverflow": {},
"alpsCktBaseEnabled": {},
"alpsCktBaseHostLinkNumber": {},
"alpsCktBaseHostLinkType": {},
"alpsCktBaseInOctets": {},
"alpsCktBaseInPackets": {},
"alpsCktBaseLifeTimeTimer": {},
"alpsCktBaseLocalHld": {},
"alpsCktBaseNumActiveAscus": {},
"alpsCktBaseOutOctets": {},
"alpsCktBaseOutPackets": {},
"alpsCktBasePriPeerAddr": {},
"alpsCktBaseRemHld": {},
"alpsCktBaseRowStatus": {},
"alpsCktBaseState": {},
"alpsCktP1024Ax25LCN": {},
"alpsCktP1024BackupPeerAddr": {},
"alpsCktP1024DropsUnkAscu": {},
"alpsCktP1024EmtoxX121": {},
"alpsCktP1024IdleTimer": {},
"alpsCktP1024InPktSize": {},
"alpsCktP1024MatipCloseDelay": {},
"alpsCktP1024OutPktSize": {},
"alpsCktP1024RetryTimer": {},
"alpsCktP1024RowStatus": {},
"alpsCktP1024SvcMsgIntvl": {},
"alpsCktP1024SvcMsgList": {},
"alpsCktP1024WinIn": {},
"alpsCktP1024WinOut": {},
"alpsCktX25DropsVcReset": {},
"alpsCktX25HostX121": {},
"alpsCktX25IfIndex": {},
"alpsCktX25LCN": {},
"alpsCktX25RemoteX121": {},
"alpsIfHLinkActiveCkts": {},
"alpsIfHLinkAx25PvcDamp": {},
"alpsIfHLinkEmtoxHostX121": {},
"alpsIfHLinkX25ProtocolType": {},
"alpsIfP1024CurrErrCnt": {},
"alpsIfP1024EncapType": {},
"alpsIfP1024Entry": {"11": {}, "12": {}, "13": {}},
"alpsIfP1024GATimeout": {},
"alpsIfP1024MaxErrCnt": {},
"alpsIfP1024MaxRetrans": {},
"alpsIfP1024MinGoodPollResp": {},
"alpsIfP1024NumAscus": {},
"alpsIfP1024PollPauseTimeout": {},
"alpsIfP1024PollRespTimeout": {},
"alpsIfP1024PollingRatio": {},
"alpsIpAddress": {},
"alpsPeerInCallsAcceptFlag": {},
"alpsPeerKeepaliveMaxRetries": {},
"alpsPeerKeepaliveTimeout": {},
"alpsPeerLocalAtpPort": {},
"alpsPeerLocalIpAddr": {},
"alpsRemPeerAlarmsEnabled": {},
"alpsRemPeerCfgActivation": {},
"alpsRemPeerCfgAlarmsOn": {},
"alpsRemPeerCfgIdleTimer": {},
"alpsRemPeerCfgNoCircTimer": {},
"alpsRemPeerCfgRowStatus": {},
"alpsRemPeerCfgStatIntvl": {},
"alpsRemPeerCfgStatRetry": {},
"alpsRemPeerCfgTCPQLen": {},
"alpsRemPeerConnActivation": {},
"alpsRemPeerConnAlarmsOn": {},
"alpsRemPeerConnCreation": {},
"alpsRemPeerConnDownReason": {},
"alpsRemPeerConnDropsGiant": {},
"alpsRemPeerConnDropsQFull": {},
"alpsRemPeerConnDropsUnreach": {},
"alpsRemPeerConnDropsVersion": {},
"alpsRemPeerConnForeignPort": {},
"alpsRemPeerConnIdleTimer": {},
"alpsRemPeerConnInOctets": {},
"alpsRemPeerConnInPackets": {},
"alpsRemPeerConnLastRxAny": {},
"alpsRemPeerConnLastTxRx": {},
"alpsRemPeerConnLocalPort": {},
"alpsRemPeerConnNoCircTimer": {},
"alpsRemPeerConnNumActCirc": {},
"alpsRemPeerConnOutOctets": {},
"alpsRemPeerConnOutPackets": {},
"alpsRemPeerConnProtocol": {},
"alpsRemPeerConnStatIntvl": {},
"alpsRemPeerConnStatRetry": {},
"alpsRemPeerConnState": {},
"alpsRemPeerConnTCPQLen": {},
"alpsRemPeerConnType": {},
"alpsRemPeerConnUptime": {},
"alpsRemPeerDropsGiant": {},
"alpsRemPeerDropsPeerUnreach": {},
"alpsRemPeerDropsQFull": {},
"alpsRemPeerIdleTimer": {},
"alpsRemPeerInOctets": {},
"alpsRemPeerInPackets": {},
"alpsRemPeerLocalPort": {},
"alpsRemPeerNumActiveCkts": {},
"alpsRemPeerOutOctets": {},
"alpsRemPeerOutPackets": {},
"alpsRemPeerRemotePort": {},
"alpsRemPeerRowStatus": {},
"alpsRemPeerState": {},
"alpsRemPeerTCPQlen": {},
"alpsRemPeerUptime": {},
"alpsSvcMsg": {},
"alpsSvcMsgRowStatus": {},
"alpsX121ToIpTransRowStatus": {},
"atEntry": {"1": {}, "2": {}, "3": {}},
"atecho": {"1": {}, "2": {}},
"atmCurrentlyFailingPVclTimeStamp": {},
"atmForumUni.10.1.1.1": {},
"atmForumUni.10.1.1.10": {},
"atmForumUni.10.1.1.11": {},
"atmForumUni.10.1.1.2": {},
"atmForumUni.10.1.1.3": {},
"atmForumUni.10.1.1.4": {},
"atmForumUni.10.1.1.5": {},
"atmForumUni.10.1.1.6": {},
"atmForumUni.10.1.1.7": {},
"atmForumUni.10.1.1.8": {},
"atmForumUni.10.1.1.9": {},
"atmForumUni.10.144.1.1": {},
"atmForumUni.10.144.1.2": {},
"atmForumUni.10.100.1.1": {},
"atmForumUni.10.100.1.10": {},
"atmForumUni.10.100.1.2": {},
"atmForumUni.10.100.1.3": {},
"atmForumUni.10.100.1.4": {},
"atmForumUni.10.100.1.5": {},
"atmForumUni.10.100.1.6": {},
"atmForumUni.10.100.1.7": {},
"atmForumUni.10.100.1.8": {},
"atmForumUni.10.100.1.9": {},
"atmInterfaceConfEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"atmIntfCurrentlyDownToUpPVcls": {},
"atmIntfCurrentlyFailingPVcls": {},
"atmIntfCurrentlyOAMFailingPVcls": {},
"atmIntfOAMFailedPVcls": {},
"atmIntfPvcFailures": {},
"atmIntfPvcFailuresTrapEnable": {},
"atmIntfPvcNotificationInterval": {},
"atmPVclHigherRangeValue": {},
"atmPVclLowerRangeValue": {},
"atmPVclRangeStatusChangeEnd": {},
"atmPVclRangeStatusChangeStart": {},
"atmPVclStatusChangeEnd": {},
"atmPVclStatusChangeStart": {},
"atmPVclStatusTransition": {},
"atmPreviouslyFailedPVclInterval": {},
"atmPreviouslyFailedPVclTimeStamp": {},
"atmTrafficDescrParamEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"atmVclEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"atmVplEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"atmfAddressEntry": {"3": {}, "4": {}},
"atmfAtmLayerEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"atmfAtmStatsEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"atmfNetPrefixEntry": {"3": {}},
"atmfPhysicalGroup": {"2": {}, "4": {}},
"atmfPortEntry": {"1": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"atmfVccEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"atmfVpcEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"atportEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"bcpConfigEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"bcpOperEntry": {"1": {}},
"bgp4PathAttrASPathSegment": {},
"bgp4PathAttrAggregatorAS": {},
"bgp4PathAttrAggregatorAddr": {},
"bgp4PathAttrAtomicAggregate": {},
"bgp4PathAttrBest": {},
"bgp4PathAttrCalcLocalPref": {},
"bgp4PathAttrIpAddrPrefix": {},
"bgp4PathAttrIpAddrPrefixLen": {},
"bgp4PathAttrLocalPref": {},
"bgp4PathAttrMultiExitDisc": {},
"bgp4PathAttrNextHop": {},
"bgp4PathAttrOrigin": {},
"bgp4PathAttrPeer": {},
"bgp4PathAttrUnknown": {},
"bgpIdentifier": {},
"bgpLocalAs": {},
"bgpPeerAdminStatus": {},
"bgpPeerConnectRetryInterval": {},
"bgpPeerEntry": {"14": {}, "2": {}},
"bgpPeerFsmEstablishedTime": {},
"bgpPeerFsmEstablishedTransitions": {},
"bgpPeerHoldTime": {},
"bgpPeerHoldTimeConfigured": {},
"bgpPeerIdentifier": {},
"bgpPeerInTotalMessages": {},
"bgpPeerInUpdateElapsedTime": {},
"bgpPeerInUpdates": {},
"bgpPeerKeepAlive": {},
"bgpPeerKeepAliveConfigured": {},
"bgpPeerLocalAddr": {},
"bgpPeerLocalPort": {},
"bgpPeerMinASOriginationInterval": {},
"bgpPeerMinRouteAdvertisementInterval": {},
"bgpPeerNegotiatedVersion": {},
"bgpPeerOutTotalMessages": {},
"bgpPeerOutUpdates": {},
"bgpPeerRemoteAddr": {},
"bgpPeerRemoteAs": {},
"bgpPeerRemotePort": {},
"bgpVersion": {},
"bscCUEntry": {
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"bscExtAddressEntry": {"2": {}},
"bscPortEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"bstunGlobal": {"1": {}, "2": {}, "3": {}, "4": {}},
"bstunGroupEntry": {"2": {}, "3": {}, "4": {}, "5": {}},
"bstunPortEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"bstunRouteEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cAal5VccEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cBootpHCCountDropNotServingSubnet": {},
"cBootpHCCountDropUnknownClients": {},
"cBootpHCCountInvalids": {},
"cBootpHCCountReplies": {},
"cBootpHCCountRequests": {},
"cCallHistoryEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cCallHistoryIecEntry": {"2": {}},
"cContextMappingEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"cContextMappingMIBObjects.2.1.1": {},
"cContextMappingMIBObjects.2.1.2": {},
"cContextMappingMIBObjects.2.1.3": {},
"cDhcpv4HCCountAcks": {},
"cDhcpv4HCCountDeclines": {},
"cDhcpv4HCCountDiscovers": {},
"cDhcpv4HCCountDropNotServingSubnet": {},
"cDhcpv4HCCountDropUnknownClient": {},
"cDhcpv4HCCountForcedRenews": {},
"cDhcpv4HCCountInforms": {},
"cDhcpv4HCCountInvalids": {},
"cDhcpv4HCCountNaks": {},
"cDhcpv4HCCountOffers": {},
"cDhcpv4HCCountReleases": {},
"cDhcpv4HCCountRequests": {},
"cDhcpv4ServerClientAllowedProtocol": {},
"cDhcpv4ServerClientClientId": {},
"cDhcpv4ServerClientDomainName": {},
"cDhcpv4ServerClientHostName": {},
"cDhcpv4ServerClientLeaseType": {},
"cDhcpv4ServerClientPhysicalAddress": {},
"cDhcpv4ServerClientRange": {},
"cDhcpv4ServerClientServedProtocol": {},
"cDhcpv4ServerClientSubnetMask": {},
"cDhcpv4ServerClientTimeRemaining": {},
"cDhcpv4ServerDefaultRouterAddress": {},
"cDhcpv4ServerIfLeaseLimit": {},
"cDhcpv4ServerRangeInUse": {},
"cDhcpv4ServerRangeOutstandingOffers": {},
"cDhcpv4ServerRangeSubnetMask": {},
"cDhcpv4ServerSharedNetFreeAddrHighThreshold": {},
"cDhcpv4ServerSharedNetFreeAddrLowThreshold": {},
"cDhcpv4ServerSharedNetFreeAddresses": {},
"cDhcpv4ServerSharedNetReservedAddresses": {},
"cDhcpv4ServerSharedNetTotalAddresses": {},
"cDhcpv4ServerSubnetEndAddress": {},
"cDhcpv4ServerSubnetFreeAddrHighThreshold": {},
"cDhcpv4ServerSubnetFreeAddrLowThreshold": {},
"cDhcpv4ServerSubnetFreeAddresses": {},
"cDhcpv4ServerSubnetMask": {},
"cDhcpv4ServerSubnetSharedNetworkName": {},
"cDhcpv4ServerSubnetStartAddress": {},
"cDhcpv4SrvSystemDescr": {},
"cDhcpv4SrvSystemObjectID": {},
"cEigrpAcksRcvd": {},
"cEigrpAcksSent": {},
"cEigrpAcksSuppressed": {},
"cEigrpActive": {},
"cEigrpAsRouterId": {},
"cEigrpAsRouterIdType": {},
"cEigrpAuthKeyChain": {},
"cEigrpAuthMode": {},
"cEigrpCRpkts": {},
"cEigrpDestSuccessors": {},
"cEigrpDistance": {},
"cEigrpFdistance": {},
"cEigrpHeadSerial": {},
"cEigrpHelloInterval": {},
"cEigrpHellosRcvd": {},
"cEigrpHellosSent": {},
"cEigrpHoldTime": {},
"cEigrpInputQDrops": {},
"cEigrpInputQHighMark": {},
"cEigrpLastSeq": {},
"cEigrpMFlowTimer": {},
"cEigrpMcastExcepts": {},
"cEigrpMeanSrtt": {},
"cEigrpNbrCount": {},
"cEigrpNextHopAddress": {},
"cEigrpNextHopAddressType": {},
"cEigrpNextHopInterface": {},
"cEigrpNextSerial": {},
"cEigrpOOSrvcd": {},
"cEigrpPacingReliable": {},
"cEigrpPacingUnreliable": {},
"cEigrpPeerAddr": {},
"cEigrpPeerAddrType": {},
"cEigrpPeerCount": {},
"cEigrpPeerIfIndex": {},
"cEigrpPendingRoutes": {},
"cEigrpPktsEnqueued": {},
"cEigrpQueriesRcvd": {},
"cEigrpQueriesSent": {},
"cEigrpRMcasts": {},
"cEigrpRUcasts": {},
"cEigrpRepliesRcvd": {},
"cEigrpRepliesSent": {},
"cEigrpReportDistance": {},
"cEigrpRetrans": {},
"cEigrpRetransSent": {},
"cEigrpRetries": {},
"cEigrpRouteOriginAddr": {},
"cEigrpRouteOriginAddrType": {},
"cEigrpRouteOriginType": {},
"cEigrpRto": {},
"cEigrpSiaQueriesRcvd": {},
"cEigrpSiaQueriesSent": {},
"cEigrpSrtt": {},
"cEigrpStuckInActive": {},
"cEigrpTopoEntry": {"17": {}, "18": {}, "19": {}},
"cEigrpTopoRoutes": {},
"cEigrpUMcasts": {},
"cEigrpUUcasts": {},
"cEigrpUpTime": {},
"cEigrpUpdatesRcvd": {},
"cEigrpUpdatesSent": {},
"cEigrpVersion": {},
"cEigrpVpnName": {},
"cEigrpXmitDummies": {},
"cEigrpXmitNextSerial": {},
"cEigrpXmitPendReplies": {},
"cEigrpXmitReliableQ": {},
"cEigrpXmitUnreliableQ": {},
"cEtherCfmEventCode": {},
"cEtherCfmEventDeleteRow": {},
"cEtherCfmEventDomainName": {},
"cEtherCfmEventLastChange": {},
"cEtherCfmEventLclIfCount": {},
"cEtherCfmEventLclMacAddress": {},
"cEtherCfmEventLclMepCount": {},
"cEtherCfmEventLclMepid": {},
"cEtherCfmEventRmtMacAddress": {},
"cEtherCfmEventRmtMepid": {},
"cEtherCfmEventRmtPortState": {},
"cEtherCfmEventRmtServiceId": {},
"cEtherCfmEventServiceId": {},
"cEtherCfmEventType": {},
"cEtherCfmMaxEventIndex": {},
"cHsrpExtIfEntry": {"1": {}, "2": {}},
"cHsrpExtIfTrackedEntry": {"2": {}, "3": {}},
"cHsrpExtSecAddrEntry": {"2": {}},
"cHsrpGlobalConfig": {"1": {}},
"cHsrpGrpEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cIgmpFilterApplyStatus": {},
"cIgmpFilterEditEndAddress": {},
"cIgmpFilterEditEndAddressType": {},
"cIgmpFilterEditOperation": {},
"cIgmpFilterEditProfileAction": {},
"cIgmpFilterEditProfileIndex": {},
"cIgmpFilterEditSpinLock": {},
"cIgmpFilterEditStartAddress": {},
"cIgmpFilterEditStartAddressType": {},
"cIgmpFilterEnable": {},
"cIgmpFilterEndAddress": {},
"cIgmpFilterEndAddressType": {},
"cIgmpFilterInterfaceProfileIndex": {},
"cIgmpFilterMaxProfiles": {},
"cIgmpFilterProfileAction": {},
"cIpLocalPoolAllocEntry": {"3": {}, "4": {}},
"cIpLocalPoolConfigEntry": {"4": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"cIpLocalPoolGroupContainsEntry": {"2": {}},
"cIpLocalPoolGroupEntry": {"1": {}, "2": {}},
"cIpLocalPoolNotificationsEnable": {},
"cIpLocalPoolStatsEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"cMTCommonMetricsBitmaps": {},
"cMTCommonMetricsFlowCounter": {},
"cMTCommonMetricsFlowDirection": {},
"cMTCommonMetricsFlowSamplingStartTime": {},
"cMTCommonMetricsIpByteRate": {},
"cMTCommonMetricsIpDscp": {},
"cMTCommonMetricsIpOctets": {},
"cMTCommonMetricsIpPktCount": {},
"cMTCommonMetricsIpPktDropped": {},
"cMTCommonMetricsIpProtocol": {},
"cMTCommonMetricsIpTtl": {},
"cMTCommonMetricsLossMeasurement": {},
"cMTCommonMetricsMediaStopOccurred": {},
"cMTCommonMetricsRouteForward": {},
"cMTFlowSpecifierDestAddr": {},
"cMTFlowSpecifierDestAddrType": {},
"cMTFlowSpecifierDestPort": {},
"cMTFlowSpecifierIpProtocol": {},
"cMTFlowSpecifierMetadataGlobalId": {},
"cMTFlowSpecifierRowStatus": {},
"cMTFlowSpecifierSourceAddr": {},
"cMTFlowSpecifierSourceAddrType": {},
"cMTFlowSpecifierSourcePort": {},
"cMTHopStatsCollectionStatus": {},
"cMTHopStatsEgressInterface": {},
"cMTHopStatsIngressInterface": {},
"cMTHopStatsMaskBitmaps": {},
"cMTHopStatsMediatraceTtl": {},
"cMTHopStatsName": {},
"cMTInitiatorActiveSessions": {},
"cMTInitiatorConfiguredSessions": {},
"cMTInitiatorEnable": {},
"cMTInitiatorInactiveSessions": {},
"cMTInitiatorMaxSessions": {},
"cMTInitiatorPendingSessions": {},
"cMTInitiatorProtocolVersionMajor": {},
"cMTInitiatorProtocolVersionMinor": {},
"cMTInitiatorSoftwareVersionMajor": {},
"cMTInitiatorSoftwareVersionMinor": {},
"cMTInitiatorSourceAddress": {},
"cMTInitiatorSourceAddressType": {},
"cMTInitiatorSourceInterface": {},
"cMTInterfaceBitmaps": {},
"cMTInterfaceInDiscards": {},
"cMTInterfaceInErrors": {},
"cMTInterfaceInOctets": {},
"cMTInterfaceInSpeed": {},
"cMTInterfaceOutDiscards": {},
"cMTInterfaceOutErrors": {},
"cMTInterfaceOutOctets": {},
"cMTInterfaceOutSpeed": {},
"cMTMediaMonitorProfileInterval": {},
"cMTMediaMonitorProfileMetric": {},
"cMTMediaMonitorProfileRowStatus": {},
"cMTMediaMonitorProfileRtpMaxDropout": {},
"cMTMediaMonitorProfileRtpMaxReorder": {},
"cMTMediaMonitorProfileRtpMinimalSequential": {},
"cMTPathHopAddr": {},
"cMTPathHopAddrType": {},
"cMTPathHopAlternate1Addr": {},
"cMTPathHopAlternate1AddrType": {},
"cMTPathHopAlternate2Addr": {},
"cMTPathHopAlternate2AddrType": {},
"cMTPathHopAlternate3Addr": {},
"cMTPathHopAlternate3AddrType": {},
"cMTPathHopType": {},
"cMTPathSpecifierDestAddr": {},
"cMTPathSpecifierDestAddrType": {},
"cMTPathSpecifierDestPort": {},
"cMTPathSpecifierGatewayAddr": {},
"cMTPathSpecifierGatewayAddrType": {},
"cMTPathSpecifierGatewayVlanId": {},
"cMTPathSpecifierIpProtocol": {},
"cMTPathSpecifierMetadataGlobalId": {},
"cMTPathSpecifierProtocolForDiscovery": {},
"cMTPathSpecifierRowStatus": {},
"cMTPathSpecifierSourceAddr": {},
"cMTPathSpecifierSourceAddrType": {},
"cMTPathSpecifierSourcePort": {},
"cMTResponderActiveSessions": {},
"cMTResponderEnable": {},
"cMTResponderMaxSessions": {},
"cMTRtpMetricsBitRate": {},
"cMTRtpMetricsBitmaps": {},
"cMTRtpMetricsExpectedPkts": {},
"cMTRtpMetricsJitter": {},
"cMTRtpMetricsLossPercent": {},
"cMTRtpMetricsLostPktEvents": {},
"cMTRtpMetricsLostPkts": {},
"cMTRtpMetricsOctets": {},
"cMTRtpMetricsPkts": {},
"cMTScheduleEntryAgeout": {},
"cMTScheduleLife": {},
"cMTScheduleRecurring": {},
"cMTScheduleRowStatus": {},
"cMTScheduleStartTime": {},
"cMTSessionFlowSpecifierName": {},
"cMTSessionParamName": {},
"cMTSessionParamsFrequency": {},
"cMTSessionParamsHistoryBuckets": {},
"cMTSessionParamsInactivityTimeout": {},
"cMTSessionParamsResponseTimeout": {},
"cMTSessionParamsRouteChangeReactiontime": {},
"cMTSessionParamsRowStatus": {},
"cMTSessionPathSpecifierName": {},
"cMTSessionProfileName": {},
"cMTSessionRequestStatsBitmaps": {},
"cMTSessionRequestStatsMDAppName": {},
"cMTSessionRequestStatsMDGlobalId": {},
"cMTSessionRequestStatsMDMultiPartySessionId": {},
"cMTSessionRequestStatsNumberOfErrorHops": {},
"cMTSessionRequestStatsNumberOfMediatraceHops": {},
"cMTSessionRequestStatsNumberOfNoDataRecordHops": {},
"cMTSessionRequestStatsNumberOfNonMediatraceHops": {},
"cMTSessionRequestStatsNumberOfValidHops": {},
"cMTSessionRequestStatsRequestStatus": {},
"cMTSessionRequestStatsRequestTimestamp": {},
"cMTSessionRequestStatsRouteIndex": {},
"cMTSessionRequestStatsTracerouteStatus": {},
"cMTSessionRowStatus": {},
"cMTSessionStatusBitmaps": {},
"cMTSessionStatusGlobalSessionId": {},
"cMTSessionStatusOperationState": {},
"cMTSessionStatusOperationTimeToLive": {},
"cMTSessionTraceRouteEnabled": {},
"cMTSystemMetricBitmaps": {},
"cMTSystemMetricCpuFiveMinutesUtilization": {},
"cMTSystemMetricCpuOneMinuteUtilization": {},
"cMTSystemMetricMemoryUtilization": {},
"cMTSystemProfileMetric": {},
"cMTSystemProfileRowStatus": {},
"cMTTcpMetricBitmaps": {},
"cMTTcpMetricConnectRoundTripDelay": {},
"cMTTcpMetricLostEventCount": {},
"cMTTcpMetricMediaByteCount": {},
"cMTTraceRouteHopNumber": {},
"cMTTraceRouteHopRtt": {},
"cPeerSearchType": {},
"cPppoeFwdedSessions": {},
"cPppoePerInterfaceSessionLossPercent": {},
"cPppoePerInterfaceSessionLossThreshold": {},
"cPppoePtaSessions": {},
"cPppoeSystemCurrSessions": {},
"cPppoeSystemExceededSessionErrors": {},
"cPppoeSystemHighWaterSessions": {},
"cPppoeSystemMaxAllowedSessions": {},
"cPppoeSystemPerMACSessionIWFlimit": {},
"cPppoeSystemPerMACSessionlimit": {},
"cPppoeSystemPerMacThrottleRatelimit": {},
"cPppoeSystemPerVCThrottleRatelimit": {},
"cPppoeSystemPerVClimit": {},
"cPppoeSystemPerVLANlimit": {},
"cPppoeSystemPerVLANthrottleRatelimit": {},
"cPppoeSystemSessionLossPercent": {},
"cPppoeSystemSessionLossThreshold": {},
"cPppoeSystemSessionNotifyObjects": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"cPppoeSystemThresholdSessions": {},
"cPppoeTotalSessions": {},
"cPppoeTransSessions": {},
"cPppoeVcCurrSessions": {},
"cPppoeVcExceededSessionErrors": {},
"cPppoeVcHighWaterSessions": {},
"cPppoeVcMaxAllowedSessions": {},
"cPppoeVcThresholdSessions": {},
"cPtpClockCurrentDSMeanPathDelay": {},
"cPtpClockCurrentDSOffsetFromMaster": {},
"cPtpClockCurrentDSStepsRemoved": {},
"cPtpClockDefaultDSClockIdentity": {},
"cPtpClockDefaultDSPriority1": {},
"cPtpClockDefaultDSPriority2": {},
"cPtpClockDefaultDSQualityAccuracy": {},
"cPtpClockDefaultDSQualityClass": {},
"cPtpClockDefaultDSQualityOffset": {},
"cPtpClockDefaultDSSlaveOnly": {},
"cPtpClockDefaultDSTwoStepFlag": {},
"cPtpClockInput1ppsEnabled": {},
"cPtpClockInput1ppsInterface": {},
"cPtpClockInputFrequencyEnabled": {},
"cPtpClockOutput1ppsEnabled": {},
"cPtpClockOutput1ppsInterface": {},
"cPtpClockOutput1ppsOffsetEnabled": {},
"cPtpClockOutput1ppsOffsetNegative": {},
"cPtpClockOutput1ppsOffsetValue": {},
"cPtpClockParentDSClockPhChRate": {},
"cPtpClockParentDSGMClockIdentity": {},
"cPtpClockParentDSGMClockPriority1": {},
"cPtpClockParentDSGMClockPriority2": {},
"cPtpClockParentDSGMClockQualityAccuracy": {},
"cPtpClockParentDSGMClockQualityClass": {},
"cPtpClockParentDSGMClockQualityOffset": {},
"cPtpClockParentDSOffset": {},
"cPtpClockParentDSParentPortIdentity": {},
"cPtpClockParentDSParentStats": {},
"cPtpClockPortAssociateAddress": {},
"cPtpClockPortAssociateAddressType": {},
"cPtpClockPortAssociateInErrors": {},
"cPtpClockPortAssociateOutErrors": {},
"cPtpClockPortAssociatePacketsReceived": {},
"cPtpClockPortAssociatePacketsSent": {},
"cPtpClockPortCurrentPeerAddress": {},
"cPtpClockPortCurrentPeerAddressType": {},
"cPtpClockPortDSAnnounceRctTimeout": {},
"cPtpClockPortDSAnnouncementInterval": {},
"cPtpClockPortDSDelayMech": {},
"cPtpClockPortDSGrantDuration": {},
"cPtpClockPortDSMinDelayReqInterval": {},
"cPtpClockPortDSName": {},
"cPtpClockPortDSPTPVersion": {},
"cPtpClockPortDSPeerDelayReqInterval": {},
"cPtpClockPortDSPeerMeanPathDelay": {},
"cPtpClockPortDSPortIdentity": {},
"cPtpClockPortDSSyncInterval": {},
"cPtpClockPortName": {},
"cPtpClockPortNumOfAssociatedPorts": {},
"cPtpClockPortRole": {},
"cPtpClockPortRunningEncapsulationType": {},
"cPtpClockPortRunningIPversion": {},
"cPtpClockPortRunningInterfaceIndex": {},
"cPtpClockPortRunningName": {},
"cPtpClockPortRunningPacketsReceived": {},
"cPtpClockPortRunningPacketsSent": {},
"cPtpClockPortRunningRole": {},
"cPtpClockPortRunningRxMode": {},
"cPtpClockPortRunningState": {},
"cPtpClockPortRunningTxMode": {},
"cPtpClockPortSyncOneStep": {},
"cPtpClockPortTransDSFaultyFlag": {},
"cPtpClockPortTransDSPeerMeanPathDelay": {},
"cPtpClockPortTransDSPortIdentity": {},
"cPtpClockPortTransDSlogMinPdelayReqInt": {},
"cPtpClockRunningPacketsReceived": {},
"cPtpClockRunningPacketsSent": {},
"cPtpClockRunningState": {},
"cPtpClockTODEnabled": {},
"cPtpClockTODInterface": {},
"cPtpClockTimePropertiesDSCurrentUTCOffset": {},
"cPtpClockTimePropertiesDSCurrentUTCOffsetValid": {},
"cPtpClockTimePropertiesDSFreqTraceable": {},
"cPtpClockTimePropertiesDSLeap59": {},
"cPtpClockTimePropertiesDSLeap61": {},
"cPtpClockTimePropertiesDSPTPTimescale": {},
"cPtpClockTimePropertiesDSSource": {},
"cPtpClockTimePropertiesDSTimeTraceable": {},
"cPtpClockTransDefaultDSClockIdentity": {},
"cPtpClockTransDefaultDSDelay": {},
"cPtpClockTransDefaultDSNumOfPorts": {},
"cPtpClockTransDefaultDSPrimaryDomain": {},
"cPtpDomainClockPortPhysicalInterfacesTotal": {},
"cPtpDomainClockPortsTotal": {},
"cPtpSystemDomainTotals": {},
"cPtpSystemProfile": {},
"cQIfEntry": {"1": {}, "2": {}, "3": {}},
"cQRotationEntry": {"1": {}},
"cQStatsEntry": {"2": {}, "3": {}, "4": {}},
"cRFCfgAdminAction": {},
"cRFCfgKeepaliveThresh": {},
"cRFCfgKeepaliveThreshMax": {},
"cRFCfgKeepaliveThreshMin": {},
"cRFCfgKeepaliveTimer": {},
"cRFCfgKeepaliveTimerMax": {},
"cRFCfgKeepaliveTimerMin": {},
"cRFCfgMaintenanceMode": {},
"cRFCfgNotifTimer": {},
"cRFCfgNotifTimerMax": {},
"cRFCfgNotifTimerMin": {},
"cRFCfgNotifsEnabled": {},
"cRFCfgRedundancyMode": {},
"cRFCfgRedundancyModeDescr": {},
"cRFCfgRedundancyOperMode": {},
"cRFCfgSplitMode": {},
"cRFHistoryColdStarts": {},
"cRFHistoryCurrActiveUnitId": {},
"cRFHistoryPrevActiveUnitId": {},
"cRFHistoryStandByAvailTime": {},
"cRFHistorySwactTime": {},
"cRFHistorySwitchOverReason": {},
"cRFHistoryTableMaxLength": {},
"cRFStatusDomainInstanceEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"cRFStatusDuplexMode": {},
"cRFStatusFailoverTime": {},
"cRFStatusIssuFromVersion": {},
"cRFStatusIssuState": {},
"cRFStatusIssuStateRev1": {},
"cRFStatusIssuToVersion": {},
"cRFStatusLastSwactReasonCode": {},
"cRFStatusManualSwactInhibit": {},
"cRFStatusPeerStandByEntryTime": {},
"cRFStatusPeerUnitId": {},
"cRFStatusPeerUnitState": {},
"cRFStatusPrimaryMode": {},
"cRFStatusRFModeCapsModeDescr": {},
"cRFStatusUnitId": {},
"cRFStatusUnitState": {},
"cSipCfgAaa": {"1": {}},
"cSipCfgBase": {
"1": {},
"10": {},
"11": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"cSipCfgBase.12.1.2": {},
"cSipCfgBase.9.1.2": {},
"cSipCfgPeer": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cSipCfgPeer.1.1.10": {},
"cSipCfgPeer.1.1.11": {},
"cSipCfgPeer.1.1.12": {},
"cSipCfgPeer.1.1.13": {},
"cSipCfgPeer.1.1.14": {},
"cSipCfgPeer.1.1.15": {},
"cSipCfgPeer.1.1.16": {},
"cSipCfgPeer.1.1.17": {},
"cSipCfgPeer.1.1.18": {},
"cSipCfgPeer.1.1.2": {},
"cSipCfgPeer.1.1.3": {},
"cSipCfgPeer.1.1.4": {},
"cSipCfgPeer.1.1.5": {},
"cSipCfgPeer.1.1.6": {},
"cSipCfgPeer.1.1.7": {},
"cSipCfgPeer.1.1.8": {},
"cSipCfgPeer.1.1.9": {},
"cSipCfgRetry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cSipCfgStatusCauseMap.1.1.2": {},
"cSipCfgStatusCauseMap.1.1.3": {},
"cSipCfgStatusCauseMap.2.1.2": {},
"cSipCfgStatusCauseMap.2.1.3": {},
"cSipCfgTimer": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cSipStatsErrClient": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"37": {},
"38": {},
"39": {},
"4": {},
"40": {},
"41": {},
"42": {},
"43": {},
"44": {},
"45": {},
"46": {},
"47": {},
"48": {},
"49": {},
"5": {},
"50": {},
"51": {},
"52": {},
"53": {},
"54": {},
"55": {},
"56": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cSipStatsErrServer": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cSipStatsGlobalFail": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"cSipStatsInfo": {
"1": {},
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cSipStatsRedirect": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"cSipStatsRetry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cSipStatsSuccess": {"1": {}, "2": {}, "3": {}, "4": {}},
"cSipStatsSuccess.5.1.2": {},
"cSipStatsSuccess.5.1.3": {},
"cSipStatsTraffic": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"callActiveCallOrigin": {},
"callActiveCallState": {},
"callActiveChargedUnits": {},
"callActiveConnectTime": {},
"callActiveInfoType": {},
"callActiveLogicalIfIndex": {},
"callActivePeerAddress": {},
"callActivePeerId": {},
"callActivePeerIfIndex": {},
"callActivePeerSubAddress": {},
"callActiveReceiveBytes": {},
"callActiveReceivePackets": {},
"callActiveTransmitBytes": {},
"callActiveTransmitPackets": {},
"callHistoryCallOrigin": {},
"callHistoryChargedUnits": {},
"callHistoryConnectTime": {},
"callHistoryDisconnectCause": {},
"callHistoryDisconnectText": {},
"callHistoryDisconnectTime": {},
"callHistoryInfoType": {},
"callHistoryLogicalIfIndex": {},
"callHistoryPeerAddress": {},
"callHistoryPeerId": {},
"callHistoryPeerIfIndex": {},
"callHistoryPeerSubAddress": {},
"callHistoryReceiveBytes": {},
"callHistoryReceivePackets": {},
"callHistoryRetainTimer": {},
"callHistoryTableMaxLength": {},
"callHistoryTransmitBytes": {},
"callHistoryTransmitPackets": {},
"callHomeAlertGroupTypeEntry": {"2": {}, "3": {}, "4": {}},
"callHomeDestEmailAddressEntry": {"2": {}, "3": {}, "4": {}, "5": {}},
"callHomeDestProfileEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"callHomeSwInventoryEntry": {"3": {}, "4": {}},
"callHomeUserDefCmdEntry": {"2": {}, "3": {}},
"caqQueuingParamsClassEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"caqQueuingParamsEntry": {"1": {}},
"caqVccParamsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"caqVpcParamsEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cardIfIndexEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"cardTableEntry": {
"1": {},
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"casAcctIncorrectResponses": {},
"casAcctPort": {},
"casAcctRequestTimeouts": {},
"casAcctRequests": {},
"casAcctResponseTime": {},
"casAcctServerErrorResponses": {},
"casAcctTransactionFailures": {},
"casAcctTransactionSuccesses": {},
"casAcctUnexpectedResponses": {},
"casAddress": {},
"casAuthenIncorrectResponses": {},
"casAuthenPort": {},
"casAuthenRequestTimeouts": {},
"casAuthenRequests": {},
"casAuthenResponseTime": {},
"casAuthenServerErrorResponses": {},
"casAuthenTransactionFailures": {},
"casAuthenTransactionSuccesses": {},
"casAuthenUnexpectedResponses": {},
"casAuthorIncorrectResponses": {},
"casAuthorRequestTimeouts": {},
"casAuthorRequests": {},
"casAuthorResponseTime": {},
"casAuthorServerErrorResponses": {},
"casAuthorTransactionFailures": {},
"casAuthorTransactionSuccesses": {},
"casAuthorUnexpectedResponses": {},
"casConfigRowStatus": {},
"casCurrentStateDuration": {},
"casDeadCount": {},
"casKey": {},
"casPreviousStateDuration": {},
"casPriority": {},
"casServerStateChangeEnable": {},
"casState": {},
"casTotalDeadTime": {},
"catmDownPVclHigherRangeValue": {},
"catmDownPVclLowerRangeValue": {},
"catmDownPVclRangeEnd": {},
"catmDownPVclRangeStart": {},
"catmIntfAISRDIOAMFailedPVcls": {},
"catmIntfAISRDIOAMRcovedPVcls": {},
"catmIntfAnyOAMFailedPVcls": {},
"catmIntfAnyOAMRcovedPVcls": {},
"catmIntfCurAISRDIOAMFailingPVcls": {},
"catmIntfCurAISRDIOAMRcovingPVcls": {},
"catmIntfCurAnyOAMFailingPVcls": {},
"catmIntfCurAnyOAMRcovingPVcls": {},
"catmIntfCurEndAISRDIFailingPVcls": {},
"catmIntfCurEndAISRDIRcovingPVcls": {},
"catmIntfCurEndCCOAMFailingPVcls": {},
"catmIntfCurEndCCOAMRcovingPVcls": {},
"catmIntfCurSegAISRDIFailingPVcls": {},
"catmIntfCurSegAISRDIRcovingPVcls": {},
"catmIntfCurSegCCOAMFailingPVcls": {},
"catmIntfCurSegCCOAMRcovingPVcls": {},
"catmIntfCurrentOAMFailingPVcls": {},
"catmIntfCurrentOAMRcovingPVcls": {},
"catmIntfCurrentlyDownToUpPVcls": {},
"catmIntfEndAISRDIFailedPVcls": {},
"catmIntfEndAISRDIRcovedPVcls": {},
"catmIntfEndCCOAMFailedPVcls": {},
"catmIntfEndCCOAMRcovedPVcls": {},
"catmIntfOAMFailedPVcls": {},
"catmIntfOAMRcovedPVcls": {},
"catmIntfSegAISRDIFailedPVcls": {},
"catmIntfSegAISRDIRcovedPVcls": {},
"catmIntfSegCCOAMFailedPVcls": {},
"catmIntfSegCCOAMRcovedPVcls": {},
"catmIntfTypeOfOAMFailure": {},
"catmIntfTypeOfOAMRecover": {},
"catmPVclAISRDIHigherRangeValue": {},
"catmPVclAISRDILowerRangeValue": {},
"catmPVclAISRDIRangeStatusChEnd": {},
"catmPVclAISRDIRangeStatusChStart": {},
"catmPVclAISRDIRangeStatusUpEnd": {},
"catmPVclAISRDIRangeStatusUpStart": {},
"catmPVclAISRDIStatusChangeEnd": {},
"catmPVclAISRDIStatusChangeStart": {},
"catmPVclAISRDIStatusTransition": {},
"catmPVclAISRDIStatusUpEnd": {},
"catmPVclAISRDIStatusUpStart": {},
"catmPVclAISRDIStatusUpTransition": {},
"catmPVclAISRDIUpHigherRangeValue": {},
"catmPVclAISRDIUpLowerRangeValue": {},
"catmPVclCurFailTime": {},
"catmPVclCurRecoverTime": {},
"catmPVclEndAISRDIHigherRngeValue": {},
"catmPVclEndAISRDILowerRangeValue": {},
"catmPVclEndAISRDIRangeStatChEnd": {},
"catmPVclEndAISRDIRangeStatUpEnd": {},
"catmPVclEndAISRDIRngeStatChStart": {},
"catmPVclEndAISRDIRngeStatUpStart": {},
"catmPVclEndAISRDIStatChangeEnd": {},
"catmPVclEndAISRDIStatChangeStart": {},
"catmPVclEndAISRDIStatTransition": {},
"catmPVclEndAISRDIStatUpEnd": {},
"catmPVclEndAISRDIStatUpStart": {},
"catmPVclEndAISRDIStatUpTransit": {},
"catmPVclEndAISRDIUpHigherRngeVal": {},
"catmPVclEndAISRDIUpLowerRangeVal": {},
"catmPVclEndCCHigherRangeValue": {},
"catmPVclEndCCLowerRangeValue": {},
"catmPVclEndCCRangeStatusChEnd": {},
"catmPVclEndCCRangeStatusChStart": {},
"catmPVclEndCCRangeStatusUpEnd": {},
"catmPVclEndCCRangeStatusUpStart": {},
"catmPVclEndCCStatusChangeEnd": {},
"catmPVclEndCCStatusChangeStart": {},
"catmPVclEndCCStatusTransition": {},
"catmPVclEndCCStatusUpEnd": {},
"catmPVclEndCCStatusUpStart": {},
"catmPVclEndCCStatusUpTransition": {},
"catmPVclEndCCUpHigherRangeValue": {},
"catmPVclEndCCUpLowerRangeValue": {},
"catmPVclFailureReason": {},
"catmPVclHigherRangeValue": {},
"catmPVclLowerRangeValue": {},
"catmPVclPrevFailTime": {},
"catmPVclPrevRecoverTime": {},
"catmPVclRangeFailureReason": {},
"catmPVclRangeRecoveryReason": {},
"catmPVclRangeStatusChangeEnd": {},
"catmPVclRangeStatusChangeStart": {},
"catmPVclRangeStatusUpEnd": {},
"catmPVclRangeStatusUpStart": {},
"catmPVclRecoveryReason": {},
"catmPVclSegAISRDIHigherRangeValue": {},
"catmPVclSegAISRDILowerRangeValue": {},
"catmPVclSegAISRDIRangeStatChEnd": {},
"catmPVclSegAISRDIRangeStatChStart": {},
"catmPVclSegAISRDIRangeStatUpEnd": {},
"catmPVclSegAISRDIRngeStatUpStart": {},
"catmPVclSegAISRDIStatChangeEnd": {},
"catmPVclSegAISRDIStatChangeStart": {},
"catmPVclSegAISRDIStatTransition": {},
"catmPVclSegAISRDIStatUpEnd": {},
"catmPVclSegAISRDIStatUpStart": {},
"catmPVclSegAISRDIStatUpTransit": {},
"catmPVclSegAISRDIUpHigherRngeVal": {},
"catmPVclSegAISRDIUpLowerRangeVal": {},
"catmPVclSegCCHigherRangeValue": {},
"catmPVclSegCCLowerRangeValue": {},
"catmPVclSegCCRangeStatusChEnd": {},
"catmPVclSegCCRangeStatusChStart": {},
"catmPVclSegCCRangeStatusUpEnd": {},
"catmPVclSegCCRangeStatusUpStart": {},
"catmPVclSegCCStatusChangeEnd": {},
"catmPVclSegCCStatusChangeStart": {},
"catmPVclSegCCStatusTransition": {},
"catmPVclSegCCStatusUpEnd": {},
"catmPVclSegCCStatusUpStart": {},
"catmPVclSegCCStatusUpTransition": {},
"catmPVclSegCCUpHigherRangeValue": {},
"catmPVclSegCCUpLowerRangeValue": {},
"catmPVclStatusChangeEnd": {},
"catmPVclStatusChangeStart": {},
"catmPVclStatusTransition": {},
"catmPVclStatusUpEnd": {},
"catmPVclStatusUpStart": {},
"catmPVclStatusUpTransition": {},
"catmPVclUpHigherRangeValue": {},
"catmPVclUpLowerRangeValue": {},
"catmPrevDownPVclRangeEnd": {},
"catmPrevDownPVclRangeStart": {},
"catmPrevUpPVclRangeEnd": {},
"catmPrevUpPVclRangeStart": {},
"catmUpPVclHigherRangeValue": {},
"catmUpPVclLowerRangeValue": {},
"catmUpPVclRangeEnd": {},
"catmUpPVclRangeStart": {},
"cbQosATMPVCPolicyEntry": {"1": {}},
"cbQosCMCfgEntry": {"1": {}, "2": {}, "3": {}},
"cbQosCMStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosEBCfgEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"cbQosEBStatsEntry": {"1": {}, "2": {}, "3": {}},
"cbQosFrameRelayPolicyEntry": {"1": {}},
"cbQosIPHCCfgEntry": {"1": {}, "2": {}},
"cbQosIPHCStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"32": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosInterfacePolicyEntry": {"1": {}},
"cbQosMatchStmtCfgEntry": {"1": {}, "2": {}},
"cbQosMatchStmtStatsEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
},
"cbQosObjectsEntry": {"2": {}, "3": {}, "4": {}},
"cbQosPoliceActionCfgEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"cbQosPoliceCfgEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosPoliceColorStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosPoliceStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosPolicyMapCfgEntry": {"1": {}, "2": {}},
"cbQosQueueingCfgEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosQueueingStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosREDCfgEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"cbQosREDClassCfgEntry": {
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosREDClassStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosServicePolicyEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"cbQosSetCfgEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosSetStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosTSCfgEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosTSStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosTableMapCfgEntry": {"2": {}, "3": {}, "4": {}},
"cbQosTableMapSetCfgEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cbQosTableMapValueCfgEntry": {"2": {}},
"cbQosVlanIndex": {},
"cbfDefineFileTable.1.2": {},
"cbfDefineFileTable.1.3": {},
"cbfDefineFileTable.1.4": {},
"cbfDefineFileTable.1.5": {},
"cbfDefineFileTable.1.6": {},
"cbfDefineFileTable.1.7": {},
"cbfDefineObjectTable.1.2": {},
"cbfDefineObjectTable.1.3": {},
"cbfDefineObjectTable.1.4": {},
"cbfDefineObjectTable.1.5": {},
"cbfDefineObjectTable.1.6": {},
"cbfDefineObjectTable.1.7": {},
"cbfStatusFileTable.1.2": {},
"cbfStatusFileTable.1.3": {},
"cbfStatusFileTable.1.4": {},
"cbgpGlobal": {"2": {}},
"cbgpNotifsEnable": {},
"cbgpPeer2AcceptedPrefixes": {},
"cbgpPeer2AddrFamilyName": {},
"cbgpPeer2AdminStatus": {},
"cbgpPeer2AdvertisedPrefixes": {},
"cbgpPeer2CapValue": {},
"cbgpPeer2ConnectRetryInterval": {},
"cbgpPeer2DeniedPrefixes": {},
"cbgpPeer2FsmEstablishedTime": {},
"cbgpPeer2FsmEstablishedTransitions": {},
"cbgpPeer2HoldTime": {},
"cbgpPeer2HoldTimeConfigured": {},
"cbgpPeer2InTotalMessages": {},
"cbgpPeer2InUpdateElapsedTime": {},
"cbgpPeer2InUpdates": {},
"cbgpPeer2KeepAlive": {},
"cbgpPeer2KeepAliveConfigured": {},
"cbgpPeer2LastError": {},
"cbgpPeer2LastErrorTxt": {},
"cbgpPeer2LocalAddr": {},
"cbgpPeer2LocalAs": {},
"cbgpPeer2LocalIdentifier": {},
"cbgpPeer2LocalPort": {},
"cbgpPeer2MinASOriginationInterval": {},
"cbgpPeer2MinRouteAdvertisementInterval": {},
"cbgpPeer2NegotiatedVersion": {},
"cbgpPeer2OutTotalMessages": {},
"cbgpPeer2OutUpdates": {},
"cbgpPeer2PrefixAdminLimit": {},
"cbgpPeer2PrefixClearThreshold": {},
"cbgpPeer2PrefixThreshold": {},
"cbgpPeer2PrevState": {},
"cbgpPeer2RemoteAs": {},
"cbgpPeer2RemoteIdentifier": {},
"cbgpPeer2RemotePort": {},
"cbgpPeer2State": {},
"cbgpPeer2SuppressedPrefixes": {},
"cbgpPeer2WithdrawnPrefixes": {},
"cbgpPeerAcceptedPrefixes": {},
"cbgpPeerAddrFamilyName": {},
"cbgpPeerAddrFamilyPrefixEntry": {"3": {}, "4": {}, "5": {}},
"cbgpPeerAdvertisedPrefixes": {},
"cbgpPeerCapValue": {},
"cbgpPeerDeniedPrefixes": {},
"cbgpPeerEntry": {"7": {}, "8": {}},
"cbgpPeerPrefixAccepted": {},
"cbgpPeerPrefixAdvertised": {},
"cbgpPeerPrefixDenied": {},
"cbgpPeerPrefixLimit": {},
"cbgpPeerPrefixSuppressed": {},
"cbgpPeerPrefixWithdrawn": {},
"cbgpPeerSuppressedPrefixes": {},
"cbgpPeerWithdrawnPrefixes": {},
"cbgpRouteASPathSegment": {},
"cbgpRouteAggregatorAS": {},
"cbgpRouteAggregatorAddr": {},
"cbgpRouteAggregatorAddrType": {},
"cbgpRouteAtomicAggregate": {},
"cbgpRouteBest": {},
"cbgpRouteLocalPref": {},
"cbgpRouteLocalPrefPresent": {},
"cbgpRouteMedPresent": {},
"cbgpRouteMultiExitDisc": {},
"cbgpRouteNextHop": {},
"cbgpRouteOrigin": {},
"cbgpRouteUnknownAttr": {},
"cbpAcctEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"ccCopyTable.1.10": {},
"ccCopyTable.1.11": {},
"ccCopyTable.1.12": {},
"ccCopyTable.1.13": {},
"ccCopyTable.1.14": {},
"ccCopyTable.1.15": {},
"ccCopyTable.1.16": {},
"ccCopyTable.1.2": {},
"ccCopyTable.1.3": {},
"ccCopyTable.1.4": {},
"ccCopyTable.1.5": {},
"ccCopyTable.1.6": {},
"ccCopyTable.1.7": {},
"ccCopyTable.1.8": {},
"ccCopyTable.1.9": {},
"ccVoIPCallActivePolicyName": {},
"ccapAppActiveInstances": {},
"ccapAppCallType": {},
"ccapAppDescr": {},
"ccapAppEventLogging": {},
"ccapAppGblActCurrentInstances": {},
"ccapAppGblActHandoffInProgress": {},
"ccapAppGblActIPInCallNowConn": {},
"ccapAppGblActIPOutCallNowConn": {},
"ccapAppGblActPSTNInCallNowConn": {},
"ccapAppGblActPSTNOutCallNowConn": {},
"ccapAppGblActPlaceCallInProgress": {},
"ccapAppGblActPromptPlayActive": {},
"ccapAppGblActRecordingActive": {},
"ccapAppGblActTTSActive": {},
"ccapAppGblEventLogging": {},
"ccapAppGblEvtLogflush": {},
"ccapAppGblHisAAAAuthenticateFailure": {},
"ccapAppGblHisAAAAuthenticateSuccess": {},
"ccapAppGblHisAAAAuthorizeFailure": {},
"ccapAppGblHisAAAAuthorizeSuccess": {},
"ccapAppGblHisASNLNotifReceived": {},
"ccapAppGblHisASNLSubscriptionsFailed": {},
"ccapAppGblHisASNLSubscriptionsSent": {},
"ccapAppGblHisASNLSubscriptionsSuccess": {},
"ccapAppGblHisASRAborted": {},
"ccapAppGblHisASRAttempts": {},
"ccapAppGblHisASRMatch": {},
"ccapAppGblHisASRNoInput": {},
"ccapAppGblHisASRNoMatch": {},
"ccapAppGblHisDTMFAborted": {},
"ccapAppGblHisDTMFAttempts": {},
"ccapAppGblHisDTMFLongPound": {},
"ccapAppGblHisDTMFMatch": {},
"ccapAppGblHisDTMFNoInput": {},
"ccapAppGblHisDTMFNoMatch": {},
"ccapAppGblHisDocumentParseErrors": {},
"ccapAppGblHisDocumentReadAttempts": {},
"ccapAppGblHisDocumentReadFailures": {},
"ccapAppGblHisDocumentReadSuccess": {},
"ccapAppGblHisDocumentWriteAttempts": {},
"ccapAppGblHisDocumentWriteFailures": {},
"ccapAppGblHisDocumentWriteSuccess": {},
"ccapAppGblHisIPInCallDiscNormal": {},
"ccapAppGblHisIPInCallDiscSysErr": {},
"ccapAppGblHisIPInCallDiscUsrErr": {},
"ccapAppGblHisIPInCallHandOutRet": {},
"ccapAppGblHisIPInCallHandedOut": {},
"ccapAppGblHisIPInCallInHandoff": {},
"ccapAppGblHisIPInCallInHandoffRet": {},
"ccapAppGblHisIPInCallSetupInd": {},
"ccapAppGblHisIPInCallTotConn": {},
"ccapAppGblHisIPOutCallDiscNormal": {},
"ccapAppGblHisIPOutCallDiscSysErr": {},
"ccapAppGblHisIPOutCallDiscUsrErr": {},
"ccapAppGblHisIPOutCallHandOutRet": {},
"ccapAppGblHisIPOutCallHandedOut": {},
"ccapAppGblHisIPOutCallInHandoff": {},
"ccapAppGblHisIPOutCallInHandoffRet": {},
"ccapAppGblHisIPOutCallSetupReq": {},
"ccapAppGblHisIPOutCallTotConn": {},
"ccapAppGblHisInHandoffCallback": {},
"ccapAppGblHisInHandoffCallbackRet": {},
"ccapAppGblHisInHandoffNoCallback": {},
"ccapAppGblHisLastReset": {},
"ccapAppGblHisOutHandoffCallback": {},
"ccapAppGblHisOutHandoffCallbackRet": {},
"ccapAppGblHisOutHandoffNoCallback": {},
"ccapAppGblHisOutHandofffailures": {},
"ccapAppGblHisPSTNInCallDiscNormal": {},
"ccapAppGblHisPSTNInCallDiscSysErr": {},
"ccapAppGblHisPSTNInCallDiscUsrErr": {},
"ccapAppGblHisPSTNInCallHandOutRet": {},
"ccapAppGblHisPSTNInCallHandedOut": {},
"ccapAppGblHisPSTNInCallInHandoff": {},
"ccapAppGblHisPSTNInCallInHandoffRet": {},
"ccapAppGblHisPSTNInCallSetupInd": {},
"ccapAppGblHisPSTNInCallTotConn": {},
"ccapAppGblHisPSTNOutCallDiscNormal": {},
"ccapAppGblHisPSTNOutCallDiscSysErr": {},
"ccapAppGblHisPSTNOutCallDiscUsrErr": {},
"ccapAppGblHisPSTNOutCallHandOutRet": {},
"ccapAppGblHisPSTNOutCallHandedOut": {},
"ccapAppGblHisPSTNOutCallInHandoff": {},
"ccapAppGblHisPSTNOutCallInHandoffRet": {},
"ccapAppGblHisPSTNOutCallSetupReq": {},
"ccapAppGblHisPSTNOutCallTotConn": {},
"ccapAppGblHisPlaceCallAttempts": {},
"ccapAppGblHisPlaceCallFailure": {},
"ccapAppGblHisPlaceCallSuccess": {},
"ccapAppGblHisPromptPlayAttempts": {},
"ccapAppGblHisPromptPlayDuration": {},
"ccapAppGblHisPromptPlayFailed": {},
"ccapAppGblHisPromptPlaySuccess": {},
"ccapAppGblHisRecordingAttempts": {},
"ccapAppGblHisRecordingDuration": {},
"ccapAppGblHisRecordingFailed": {},
"ccapAppGblHisRecordingSuccess": {},
"ccapAppGblHisTTSAttempts": {},
"ccapAppGblHisTTSFailed": {},
"ccapAppGblHisTTSSuccess": {},
"ccapAppGblHisTotalInstances": {},
"ccapAppGblLastResetTime": {},
"ccapAppGblStatsClear": {},
"ccapAppGblStatsLogging": {},
"ccapAppHandoffInProgress": {},
"ccapAppIPInCallNowConn": {},
"ccapAppIPOutCallNowConn": {},
"ccapAppInstHisAAAAuthenticateFailure": {},
"ccapAppInstHisAAAAuthenticateSuccess": {},
"ccapAppInstHisAAAAuthorizeFailure": {},
"ccapAppInstHisAAAAuthorizeSuccess": {},
"ccapAppInstHisASNLNotifReceived": {},
"ccapAppInstHisASNLSubscriptionsFailed": {},
"ccapAppInstHisASNLSubscriptionsSent": {},
"ccapAppInstHisASNLSubscriptionsSuccess": {},
"ccapAppInstHisASRAborted": {},
"ccapAppInstHisASRAttempts": {},
"ccapAppInstHisASRMatch": {},
"ccapAppInstHisASRNoInput": {},
"ccapAppInstHisASRNoMatch": {},
"ccapAppInstHisAppName": {},
"ccapAppInstHisDTMFAborted": {},
"ccapAppInstHisDTMFAttempts": {},
"ccapAppInstHisDTMFLongPound": {},
"ccapAppInstHisDTMFMatch": {},
"ccapAppInstHisDTMFNoInput": {},
"ccapAppInstHisDTMFNoMatch": {},
"ccapAppInstHisDocumentParseErrors": {},
"ccapAppInstHisDocumentReadAttempts": {},
"ccapAppInstHisDocumentReadFailures": {},
"ccapAppInstHisDocumentReadSuccess": {},
"ccapAppInstHisDocumentWriteAttempts": {},
"ccapAppInstHisDocumentWriteFailures": {},
"ccapAppInstHisDocumentWriteSuccess": {},
"ccapAppInstHisIPInCallDiscNormal": {},
"ccapAppInstHisIPInCallDiscSysErr": {},
"ccapAppInstHisIPInCallDiscUsrErr": {},
"ccapAppInstHisIPInCallHandOutRet": {},
"ccapAppInstHisIPInCallHandedOut": {},
"ccapAppInstHisIPInCallInHandoff": {},
"ccapAppInstHisIPInCallInHandoffRet": {},
"ccapAppInstHisIPInCallSetupInd": {},
"ccapAppInstHisIPInCallTotConn": {},
"ccapAppInstHisIPOutCallDiscNormal": {},
"ccapAppInstHisIPOutCallDiscSysErr": {},
"ccapAppInstHisIPOutCallDiscUsrErr": {},
"ccapAppInstHisIPOutCallHandOutRet": {},
"ccapAppInstHisIPOutCallHandedOut": {},
"ccapAppInstHisIPOutCallInHandoff": {},
"ccapAppInstHisIPOutCallInHandoffRet": {},
"ccapAppInstHisIPOutCallSetupReq": {},
"ccapAppInstHisIPOutCallTotConn": {},
"ccapAppInstHisInHandoffCallback": {},
"ccapAppInstHisInHandoffCallbackRet": {},
"ccapAppInstHisInHandoffNoCallback": {},
"ccapAppInstHisOutHandoffCallback": {},
"ccapAppInstHisOutHandoffCallbackRet": {},
"ccapAppInstHisOutHandoffNoCallback": {},
"ccapAppInstHisOutHandofffailures": {},
"ccapAppInstHisPSTNInCallDiscNormal": {},
"ccapAppInstHisPSTNInCallDiscSysErr": {},
"ccapAppInstHisPSTNInCallDiscUsrErr": {},
"ccapAppInstHisPSTNInCallHandOutRet": {},
"ccapAppInstHisPSTNInCallHandedOut": {},
"ccapAppInstHisPSTNInCallInHandoff": {},
"ccapAppInstHisPSTNInCallInHandoffRet": {},
"ccapAppInstHisPSTNInCallSetupInd": {},
"ccapAppInstHisPSTNInCallTotConn": {},
"ccapAppInstHisPSTNOutCallDiscNormal": {},
"ccapAppInstHisPSTNOutCallDiscSysErr": {},
"ccapAppInstHisPSTNOutCallDiscUsrErr": {},
"ccapAppInstHisPSTNOutCallHandOutRet": {},
"ccapAppInstHisPSTNOutCallHandedOut": {},
"ccapAppInstHisPSTNOutCallInHandoff": {},
"ccapAppInstHisPSTNOutCallInHandoffRet": {},
"ccapAppInstHisPSTNOutCallSetupReq": {},
"ccapAppInstHisPSTNOutCallTotConn": {},
"ccapAppInstHisPlaceCallAttempts": {},
"ccapAppInstHisPlaceCallFailure": {},
"ccapAppInstHisPlaceCallSuccess": {},
"ccapAppInstHisPromptPlayAttempts": {},
"ccapAppInstHisPromptPlayDuration": {},
"ccapAppInstHisPromptPlayFailed": {},
"ccapAppInstHisPromptPlaySuccess": {},
"ccapAppInstHisRecordingAttempts": {},
"ccapAppInstHisRecordingDuration": {},
"ccapAppInstHisRecordingFailed": {},
"ccapAppInstHisRecordingSuccess": {},
"ccapAppInstHisSessionID": {},
"ccapAppInstHisTTSAttempts": {},
"ccapAppInstHisTTSFailed": {},
"ccapAppInstHisTTSSuccess": {},
"ccapAppInstHistEvtLogging": {},
"ccapAppIntfAAAMethodListEvtLog": {},
"ccapAppIntfAAAMethodListLastResetTime": {},
"ccapAppIntfAAAMethodListReadFailure": {},
"ccapAppIntfAAAMethodListReadRequest": {},
"ccapAppIntfAAAMethodListReadSuccess": {},
"ccapAppIntfAAAMethodListStats": {},
"ccapAppIntfASREvtLog": {},
"ccapAppIntfASRLastResetTime": {},
"ccapAppIntfASRReadFailure": {},
"ccapAppIntfASRReadRequest": {},
"ccapAppIntfASRReadSuccess": {},
"ccapAppIntfASRStats": {},
"ccapAppIntfFlashReadFailure": {},
"ccapAppIntfFlashReadRequest": {},
"ccapAppIntfFlashReadSuccess": {},
"ccapAppIntfGblEventLogging": {},
"ccapAppIntfGblEvtLogFlush": {},
"ccapAppIntfGblLastResetTime": {},
"ccapAppIntfGblStatsClear": {},
"ccapAppIntfGblStatsLogging": {},
"ccapAppIntfHTTPAvgXferRate": {},
"ccapAppIntfHTTPEvtLog": {},
"ccapAppIntfHTTPGetFailure": {},
"ccapAppIntfHTTPGetRequest": {},
"ccapAppIntfHTTPGetSuccess": {},
"ccapAppIntfHTTPLastResetTime": {},
"ccapAppIntfHTTPMaxXferRate": {},
"ccapAppIntfHTTPMinXferRate": {},
"ccapAppIntfHTTPPostFailure": {},
"ccapAppIntfHTTPPostRequest": {},
"ccapAppIntfHTTPPostSuccess": {},
"ccapAppIntfHTTPRxBytes": {},
"ccapAppIntfHTTPStats": {},
"ccapAppIntfHTTPTxBytes": {},
"ccapAppIntfRAMRecordReadRequest": {},
"ccapAppIntfRAMRecordReadSuccess": {},
"ccapAppIntfRAMRecordRequest": {},
"ccapAppIntfRAMRecordSuccess": {},
"ccapAppIntfRAMRecordiongFailure": {},
"ccapAppIntfRAMRecordiongReadFailure": {},
"ccapAppIntfRTSPAvgXferRate": {},
"ccapAppIntfRTSPEvtLog": {},
"ccapAppIntfRTSPLastResetTime": {},
"ccapAppIntfRTSPMaxXferRate": {},
"ccapAppIntfRTSPMinXferRate": {},
"ccapAppIntfRTSPReadFailure": {},
"ccapAppIntfRTSPReadRequest": {},
"ccapAppIntfRTSPReadSuccess": {},
"ccapAppIntfRTSPRxBytes": {},
"ccapAppIntfRTSPStats": {},
"ccapAppIntfRTSPTxBytes": {},
"ccapAppIntfRTSPWriteFailure": {},
"ccapAppIntfRTSPWriteRequest": {},
"ccapAppIntfRTSPWriteSuccess": {},
"ccapAppIntfSMTPAvgXferRate": {},
"ccapAppIntfSMTPEvtLog": {},
"ccapAppIntfSMTPLastResetTime": {},
"ccapAppIntfSMTPMaxXferRate": {},
"ccapAppIntfSMTPMinXferRate": {},
"ccapAppIntfSMTPReadFailure": {},
"ccapAppIntfSMTPReadRequest": {},
"ccapAppIntfSMTPReadSuccess": {},
"ccapAppIntfSMTPRxBytes": {},
"ccapAppIntfSMTPStats": {},
"ccapAppIntfSMTPTxBytes": {},
"ccapAppIntfSMTPWriteFailure": {},
"ccapAppIntfSMTPWriteRequest": {},
"ccapAppIntfSMTPWriteSuccess": {},
"ccapAppIntfTFTPAvgXferRate": {},
"ccapAppIntfTFTPEvtLog": {},
"ccapAppIntfTFTPLastResetTime": {},
"ccapAppIntfTFTPMaxXferRate": {},
"ccapAppIntfTFTPMinXferRate": {},
"ccapAppIntfTFTPReadFailure": {},
"ccapAppIntfTFTPReadRequest": {},
"ccapAppIntfTFTPReadSuccess": {},
"ccapAppIntfTFTPRxBytes": {},
"ccapAppIntfTFTPStats": {},
"ccapAppIntfTFTPTxBytes": {},
"ccapAppIntfTFTPWriteFailure": {},
"ccapAppIntfTFTPWriteRequest": {},
"ccapAppIntfTFTPWriteSuccess": {},
"ccapAppIntfTTSEvtLog": {},
"ccapAppIntfTTSLastResetTime": {},
"ccapAppIntfTTSReadFailure": {},
"ccapAppIntfTTSReadRequest": {},
"ccapAppIntfTTSReadSuccess": {},
"ccapAppIntfTTSStats": {},
"ccapAppLoadFailReason": {},
"ccapAppLoadState": {},
"ccapAppLocation": {},
"ccapAppPSTNInCallNowConn": {},
"ccapAppPSTNOutCallNowConn": {},
"ccapAppPlaceCallInProgress": {},
"ccapAppPromptPlayActive": {},
"ccapAppRecordingActive": {},
"ccapAppRowStatus": {},
"ccapAppTTSActive": {},
"ccapAppTypeHisAAAAuthenticateFailure": {},
"ccapAppTypeHisAAAAuthenticateSuccess": {},
"ccapAppTypeHisAAAAuthorizeFailure": {},
"ccapAppTypeHisAAAAuthorizeSuccess": {},
"ccapAppTypeHisASNLNotifReceived": {},
"ccapAppTypeHisASNLSubscriptionsFailed": {},
"ccapAppTypeHisASNLSubscriptionsSent": {},
"ccapAppTypeHisASNLSubscriptionsSuccess": {},
"ccapAppTypeHisASRAborted": {},
"ccapAppTypeHisASRAttempts": {},
"ccapAppTypeHisASRMatch": {},
"ccapAppTypeHisASRNoInput": {},
"ccapAppTypeHisASRNoMatch": {},
"ccapAppTypeHisDTMFAborted": {},
"ccapAppTypeHisDTMFAttempts": {},
"ccapAppTypeHisDTMFLongPound": {},
"ccapAppTypeHisDTMFMatch": {},
"ccapAppTypeHisDTMFNoInput": {},
"ccapAppTypeHisDTMFNoMatch": {},
"ccapAppTypeHisDocumentParseErrors": {},
"ccapAppTypeHisDocumentReadAttempts": {},
"ccapAppTypeHisDocumentReadFailures": {},
"ccapAppTypeHisDocumentReadSuccess": {},
"ccapAppTypeHisDocumentWriteAttempts": {},
"ccapAppTypeHisDocumentWriteFailures": {},
"ccapAppTypeHisDocumentWriteSuccess": {},
"ccapAppTypeHisEvtLogging": {},
"ccapAppTypeHisIPInCallDiscNormal": {},
"ccapAppTypeHisIPInCallDiscSysErr": {},
"ccapAppTypeHisIPInCallDiscUsrErr": {},
"ccapAppTypeHisIPInCallHandOutRet": {},
"ccapAppTypeHisIPInCallHandedOut": {},
"ccapAppTypeHisIPInCallInHandoff": {},
"ccapAppTypeHisIPInCallInHandoffRet": {},
"ccapAppTypeHisIPInCallSetupInd": {},
"ccapAppTypeHisIPInCallTotConn": {},
"ccapAppTypeHisIPOutCallDiscNormal": {},
"ccapAppTypeHisIPOutCallDiscSysErr": {},
"ccapAppTypeHisIPOutCallDiscUsrErr": {},
"ccapAppTypeHisIPOutCallHandOutRet": {},
"ccapAppTypeHisIPOutCallHandedOut": {},
"ccapAppTypeHisIPOutCallInHandoff": {},
"ccapAppTypeHisIPOutCallInHandoffRet": {},
"ccapAppTypeHisIPOutCallSetupReq": {},
"ccapAppTypeHisIPOutCallTotConn": {},
"ccapAppTypeHisInHandoffCallback": {},
"ccapAppTypeHisInHandoffCallbackRet": {},
"ccapAppTypeHisInHandoffNoCallback": {},
"ccapAppTypeHisLastResetTime": {},
"ccapAppTypeHisOutHandoffCallback": {},
"ccapAppTypeHisOutHandoffCallbackRet": {},
"ccapAppTypeHisOutHandoffNoCallback": {},
"ccapAppTypeHisOutHandofffailures": {},
"ccapAppTypeHisPSTNInCallDiscNormal": {},
"ccapAppTypeHisPSTNInCallDiscSysErr": {},
"ccapAppTypeHisPSTNInCallDiscUsrErr": {},
"ccapAppTypeHisPSTNInCallHandOutRet": {},
"ccapAppTypeHisPSTNInCallHandedOut": {},
"ccapAppTypeHisPSTNInCallInHandoff": {},
"ccapAppTypeHisPSTNInCallInHandoffRet": {},
"ccapAppTypeHisPSTNInCallSetupInd": {},
"ccapAppTypeHisPSTNInCallTotConn": {},
"ccapAppTypeHisPSTNOutCallDiscNormal": {},
"ccapAppTypeHisPSTNOutCallDiscSysErr": {},
"ccapAppTypeHisPSTNOutCallDiscUsrErr": {},
"ccapAppTypeHisPSTNOutCallHandOutRet": {},
"ccapAppTypeHisPSTNOutCallHandedOut": {},
"ccapAppTypeHisPSTNOutCallInHandoff": {},
"ccapAppTypeHisPSTNOutCallInHandoffRet": {},
"ccapAppTypeHisPSTNOutCallSetupReq": {},
"ccapAppTypeHisPSTNOutCallTotConn": {},
"ccapAppTypeHisPlaceCallAttempts": {},
"ccapAppTypeHisPlaceCallFailure": {},
"ccapAppTypeHisPlaceCallSuccess": {},
"ccapAppTypeHisPromptPlayAttempts": {},
"ccapAppTypeHisPromptPlayDuration": {},
"ccapAppTypeHisPromptPlayFailed": {},
"ccapAppTypeHisPromptPlaySuccess": {},
"ccapAppTypeHisRecordingAttempts": {},
"ccapAppTypeHisRecordingDuration": {},
"ccapAppTypeHisRecordingFailed": {},
"ccapAppTypeHisRecordingSuccess": {},
"ccapAppTypeHisTTSAttempts": {},
"ccapAppTypeHisTTSFailed": {},
"ccapAppTypeHisTTSSuccess": {},
"ccarConfigAccIdx": {},
"ccarConfigConformAction": {},
"ccarConfigExceedAction": {},
"ccarConfigExtLimit": {},
"ccarConfigLimit": {},
"ccarConfigRate": {},
"ccarConfigType": {},
"ccarStatCurBurst": {},
"ccarStatFilteredBytes": {},
"ccarStatFilteredBytesOverflow": {},
"ccarStatFilteredPkts": {},
"ccarStatFilteredPktsOverflow": {},
"ccarStatHCFilteredBytes": {},
"ccarStatHCFilteredPkts": {},
"ccarStatHCSwitchedBytes": {},
"ccarStatHCSwitchedPkts": {},
"ccarStatSwitchedBytes": {},
"ccarStatSwitchedBytesOverflow": {},
"ccarStatSwitchedPkts": {},
"ccarStatSwitchedPktsOverflow": {},
"ccbptPolicyIdNext": {},
"ccbptTargetTable.1.10": {},
"ccbptTargetTable.1.6": {},
"ccbptTargetTable.1.7": {},
"ccbptTargetTable.1.8": {},
"ccbptTargetTable.1.9": {},
"ccbptTargetTableLastChange": {},
"cciDescriptionEntry": {"1": {}, "2": {}},
"ccmCLICfgRunConfNotifEnable": {},
"ccmCLIHistoryCmdEntries": {},
"ccmCLIHistoryCmdEntriesAllowed": {},
"ccmCLIHistoryCommand": {},
"ccmCLIHistoryMaxCmdEntries": {},
"ccmCTID": {},
"ccmCTIDLastChangeTime": {},
"ccmCTIDRolledOverNotifEnable": {},
"ccmCTIDWhoChanged": {},
"ccmCallHomeAlertGroupCfg": {"3": {}, "5": {}},
"ccmCallHomeConfiguration": {
"1": {},
"10": {},
"11": {},
"13": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"23": {},
"24": {},
"27": {},
"28": {},
"29": {},
"3": {},
"34": {},
"35": {},
"36": {},
"37": {},
"38": {},
"39": {},
"4": {},
"40": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ccmCallHomeDiagSignature": {"2": {}, "3": {}},
"ccmCallHomeDiagSignatureInfoEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ccmCallHomeMessageSource": {"1": {}, "2": {}, "3": {}},
"ccmCallHomeNotifConfig": {"1": {}},
"ccmCallHomeReporting": {"1": {}},
"ccmCallHomeSecurity": {"1": {}},
"ccmCallHomeStats": {"1": {}, "2": {}, "3": {}, "4": {}},
"ccmCallHomeStatus": {"1": {}, "2": {}, "3": {}, "5": {}},
"ccmCallHomeVrf": {"1": {}},
"ccmDestProfileTestEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"ccmEventAlertGroupEntry": {"1": {}, "2": {}},
"ccmEventStatsEntry": {
"10": {},
"11": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ccmHistoryCLICmdEntriesBumped": {},
"ccmHistoryEventCommandSource": {},
"ccmHistoryEventCommandSourceAddrRev1": {},
"ccmHistoryEventCommandSourceAddrType": {},
"ccmHistoryEventCommandSourceAddress": {},
"ccmHistoryEventConfigDestination": {},
"ccmHistoryEventConfigSource": {},
"ccmHistoryEventEntriesBumped": {},
"ccmHistoryEventFile": {},
"ccmHistoryEventRcpUser": {},
"ccmHistoryEventServerAddrRev1": {},
"ccmHistoryEventServerAddrType": {},
"ccmHistoryEventServerAddress": {},
"ccmHistoryEventTerminalLocation": {},
"ccmHistoryEventTerminalNumber": {},
"ccmHistoryEventTerminalType": {},
"ccmHistoryEventTerminalUser": {},
"ccmHistoryEventTime": {},
"ccmHistoryEventVirtualHostName": {},
"ccmHistoryMaxEventEntries": {},
"ccmHistoryRunningLastChanged": {},
"ccmHistoryRunningLastSaved": {},
"ccmHistoryStartupLastChanged": {},
"ccmOnDemandCliMsgControl": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"ccmOnDemandMsgSendControl": {"1": {}, "2": {}, "3": {}, "4": {}},
"ccmPatternAlertGroupEntry": {"2": {}, "3": {}, "4": {}},
"ccmPeriodicAlertGroupEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
},
"ccmPeriodicSwInventoryCfg": {"1": {}},
"ccmSeverityAlertGroupEntry": {"1": {}},
"ccmSmartCallHomeActions": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"ccmSmtpServerStatusEntry": {"1": {}},
"ccmSmtpServersEntry": {"3": {}, "4": {}, "5": {}, "6": {}},
"cdeCircuitEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"cdeFastEntry": {
"10": {},
"11": {},
"12": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cdeIfEntry": {"1": {}},
"cdeNode": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cdeTConnConfigEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cdeTConnDirectConfigEntry": {"1": {}, "2": {}, "3": {}},
"cdeTConnOperEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"cdeTConnTcpConfigEntry": {"1": {}},
"cdeTrapControl": {"1": {}, "2": {}},
"cdlCivicAddrLocationStatus": {},
"cdlCivicAddrLocationStorageType": {},
"cdlCivicAddrLocationValue": {},
"cdlCustomLocationStatus": {},
"cdlCustomLocationStorageType": {},
"cdlCustomLocationValue": {},
"cdlGeoAltitude": {},
"cdlGeoAltitudeResolution": {},
"cdlGeoAltitudeType": {},
"cdlGeoLatitude": {},
"cdlGeoLatitudeResolution": {},
"cdlGeoLongitude": {},
"cdlGeoLongitudeResolution": {},
"cdlGeoResolution": {},
"cdlGeoStatus": {},
"cdlGeoStorageType": {},
"cdlKey": {},
"cdlLocationCountryCode": {},
"cdlLocationPreferWeightValue": {},
"cdlLocationSubTypeCapability": {},
"cdlLocationTargetIdentifier": {},
"cdlLocationTargetType": {},
"cdot3OamAdminState": {},
"cdot3OamConfigRevision": {},
"cdot3OamCriticalEventEnable": {},
"cdot3OamDuplicateEventNotificationRx": {},
"cdot3OamDuplicateEventNotificationTx": {},
"cdot3OamDyingGaspEnable": {},
"cdot3OamErrFrameEvNotifEnable": {},
"cdot3OamErrFramePeriodEvNotifEnable": {},
"cdot3OamErrFramePeriodThreshold": {},
"cdot3OamErrFramePeriodWindow": {},
"cdot3OamErrFrameSecsEvNotifEnable": {},
"cdot3OamErrFrameSecsSummaryThreshold": {},
"cdot3OamErrFrameSecsSummaryWindow": {},
"cdot3OamErrFrameThreshold": {},
"cdot3OamErrFrameWindow": {},
"cdot3OamErrSymPeriodEvNotifEnable": {},
"cdot3OamErrSymPeriodThresholdHi": {},
"cdot3OamErrSymPeriodThresholdLo": {},
"cdot3OamErrSymPeriodWindowHi": {},
"cdot3OamErrSymPeriodWindowLo": {},
"cdot3OamEventLogEventTotal": {},
"cdot3OamEventLogLocation": {},
"cdot3OamEventLogOui": {},
"cdot3OamEventLogRunningTotal": {},
"cdot3OamEventLogThresholdHi": {},
"cdot3OamEventLogThresholdLo": {},
"cdot3OamEventLogTimestamp": {},
"cdot3OamEventLogType": {},
"cdot3OamEventLogValue": {},
"cdot3OamEventLogWindowHi": {},
"cdot3OamEventLogWindowLo": {},
"cdot3OamFramesLostDueToOam": {},
"cdot3OamFunctionsSupported": {},
"cdot3OamInformationRx": {},
"cdot3OamInformationTx": {},
"cdot3OamLoopbackControlRx": {},
"cdot3OamLoopbackControlTx": {},
"cdot3OamLoopbackIgnoreRx": {},
"cdot3OamLoopbackStatus": {},
"cdot3OamMaxOamPduSize": {},
"cdot3OamMode": {},
"cdot3OamOperStatus": {},
"cdot3OamOrgSpecificRx": {},
"cdot3OamOrgSpecificTx": {},
"cdot3OamPeerConfigRevision": {},
"cdot3OamPeerFunctionsSupported": {},
"cdot3OamPeerMacAddress": {},
"cdot3OamPeerMaxOamPduSize": {},
"cdot3OamPeerMode": {},
"cdot3OamPeerVendorInfo": {},
"cdot3OamPeerVendorOui": {},
"cdot3OamUniqueEventNotificationRx": {},
"cdot3OamUniqueEventNotificationTx": {},
"cdot3OamUnsupportedCodesRx": {},
"cdot3OamUnsupportedCodesTx": {},
"cdot3OamVariableRequestRx": {},
"cdot3OamVariableRequestTx": {},
"cdot3OamVariableResponseRx": {},
"cdot3OamVariableResponseTx": {},
"cdpCache.2.1.4": {},
"cdpCache.2.1.5": {},
"cdpCacheEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cdpGlobal": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"cdpInterface.2.1.1": {},
"cdpInterface.2.1.2": {},
"cdpInterfaceEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"cdspActiveChannels": {},
"cdspAlarms": {},
"cdspCardIndex": {},
"cdspCardLastHiWaterUtilization": {},
"cdspCardLastResetTime": {},
"cdspCardMaxChanPerDSP": {},
"cdspCardResourceUtilization": {},
"cdspCardState": {},
"cdspCardVideoPoolUtilization": {},
"cdspCardVideoPoolUtilizationThreshold": {},
"cdspCodecTemplateSupported": {},
"cdspCongestedDsp": {},
"cdspCurrentAvlbCap": {},
"cdspCurrentUtilCap": {},
"cdspDspNum": {},
"cdspDspSwitchOverThreshold": {},
"cdspDspfarmObjects.5.1.10": {},
"cdspDspfarmObjects.5.1.11": {},
"cdspDspfarmObjects.5.1.2": {},
"cdspDspfarmObjects.5.1.3": {},
"cdspDspfarmObjects.5.1.4": {},
"cdspDspfarmObjects.5.1.5": {},
"cdspDspfarmObjects.5.1.6": {},
"cdspDspfarmObjects.5.1.7": {},
"cdspDspfarmObjects.5.1.8": {},
"cdspDspfarmObjects.5.1.9": {},
"cdspDtmfPowerLevel": {},
"cdspDtmfPowerTwist": {},
"cdspEnableOperStateNotification": {},
"cdspFailedDsp": {},
"cdspGlobMaxAvailTranscodeSess": {},
"cdspGlobMaxConfTranscodeSess": {},
"cdspInUseChannels": {},
"cdspLastAlarmCause": {},
"cdspLastAlarmCauseText": {},
"cdspLastAlarmTime": {},
"cdspMIBEnableCardStatusNotification": {},
"cdspMtpProfileEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cdspMtpProfileMaxAvailHardSess": {},
"cdspMtpProfileMaxConfHardSess": {},
"cdspMtpProfileMaxConfSoftSess": {},
"cdspMtpProfileRowStatus": {},
"cdspNormalDsp": {},
"cdspNumCongestionOccurrence": {},
"cdspNx64Dsp": {},
"cdspOperState": {},
"cdspPktLossConcealment": {},
"cdspRtcpControl": {},
"cdspRtcpRecvMultiplier": {},
"cdspRtcpTimerControl": {},
"cdspRtcpTransInterval": {},
"cdspRtcpXrControl": {},
"cdspRtcpXrExtRfactor": {},
"cdspRtcpXrGminDefault": {},
"cdspRtcpXrTransMultiplier": {},
"cdspRtpSidPayloadType": {},
"cdspSigBearerChannelSplit": {},
"cdspTotAvailMtpSess": {},
"cdspTotAvailTranscodeSess": {},
"cdspTotUnusedMtpSess": {},
"cdspTotUnusedTranscodeSess": {},
"cdspTotalChannels": {},
"cdspTotalDsp": {},
"cdspTranscodeProfileEntry": {
"10": {},
"11": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cdspTranscodeProfileMaxAvailSess": {},
"cdspTranscodeProfileMaxConfSess": {},
"cdspTranscodeProfileRowStatus": {},
"cdspTransparentIpIp": {},
"cdspVadAdaptive": {},
"cdspVideoOutOfResourceNotificationEnable": {},
"cdspVideoUsageNotificationEnable": {},
"cdspVoiceModeIpIp": {},
"cdspVqmControl": {},
"cdspVqmThreshSES": {},
"cdspXAvailableBearerBandwidth": {},
"cdspXAvailableSigBandwidth": {},
"cdspXNumberOfBearerCalls": {},
"cdspXNumberOfSigCalls": {},
"cdtCommonAddrPool": {},
"cdtCommonDescr": {},
"cdtCommonIpv4AccessGroup": {},
"cdtCommonIpv4Unreachables": {},
"cdtCommonIpv6AccessGroup": {},
"cdtCommonIpv6Unreachables": {},
"cdtCommonKeepaliveInt": {},
"cdtCommonKeepaliveRetries": {},
"cdtCommonSrvAcct": {},
"cdtCommonSrvNetflow": {},
"cdtCommonSrvQos": {},
"cdtCommonSrvRedirect": {},
"cdtCommonSrvSubControl": {},
"cdtCommonValid": {},
"cdtCommonVrf": {},
"cdtEthernetBridgeDomain": {},
"cdtEthernetIpv4PointToPoint": {},
"cdtEthernetMacAddr": {},
"cdtEthernetPppoeEnable": {},
"cdtEthernetValid": {},
"cdtIfCdpEnable": {},
"cdtIfFlowMonitor": {},
"cdtIfIpv4Mtu": {},
"cdtIfIpv4SubEnable": {},
"cdtIfIpv4TcpMssAdjust": {},
"cdtIfIpv4Unnumbered": {},
"cdtIfIpv4VerifyUniRpf": {},
"cdtIfIpv4VerifyUniRpfAcl": {},
"cdtIfIpv4VerifyUniRpfOpts": {},
"cdtIfIpv6Enable": {},
"cdtIfIpv6NdDadAttempts": {},
"cdtIfIpv6NdNsInterval": {},
"cdtIfIpv6NdOpts": {},
"cdtIfIpv6NdPreferredLife": {},
"cdtIfIpv6NdPrefix": {},
"cdtIfIpv6NdPrefixLength": {},
"cdtIfIpv6NdRaIntervalMax": {},
"cdtIfIpv6NdRaIntervalMin": {},
"cdtIfIpv6NdRaIntervalUnits": {},
"cdtIfIpv6NdRaLife": {},
"cdtIfIpv6NdReachableTime": {},
"cdtIfIpv6NdRouterPreference": {},
"cdtIfIpv6NdValidLife": {},
"cdtIfIpv6SubEnable": {},
"cdtIfIpv6TcpMssAdjust": {},
"cdtIfIpv6VerifyUniRpf": {},
"cdtIfIpv6VerifyUniRpfAcl": {},
"cdtIfIpv6VerifyUniRpfOpts": {},
"cdtIfMtu": {},
"cdtIfValid": {},
"cdtPppAccounting": {},
"cdtPppAuthentication": {},
"cdtPppAuthenticationMethods": {},
"cdtPppAuthorization": {},
"cdtPppChapHostname": {},
"cdtPppChapOpts": {},
"cdtPppChapPassword": {},
"cdtPppEapIdentity": {},
"cdtPppEapOpts": {},
"cdtPppEapPassword": {},
"cdtPppIpcpAddrOption": {},
"cdtPppIpcpDnsOption": {},
"cdtPppIpcpDnsPrimary": {},
"cdtPppIpcpDnsSecondary": {},
"cdtPppIpcpMask": {},
"cdtPppIpcpMaskOption": {},
"cdtPppIpcpWinsOption": {},
"cdtPppIpcpWinsPrimary": {},
"cdtPppIpcpWinsSecondary": {},
"cdtPppLoopbackIgnore": {},
"cdtPppMaxBadAuth": {},
"cdtPppMaxConfigure": {},
"cdtPppMaxFailure": {},
"cdtPppMaxTerminate": {},
"cdtPppMsChapV1Hostname": {},
"cdtPppMsChapV1Opts": {},
"cdtPppMsChapV1Password": {},
"cdtPppMsChapV2Hostname": {},
"cdtPppMsChapV2Opts": {},
"cdtPppMsChapV2Password": {},
"cdtPppPapOpts": {},
"cdtPppPapPassword": {},
"cdtPppPapUsername": {},
"cdtPppPeerDefIpAddr": {},
"cdtPppPeerDefIpAddrOpts": {},
"cdtPppPeerDefIpAddrSrc": {},
"cdtPppPeerIpAddrPoolName": {},
"cdtPppPeerIpAddrPoolStatus": {},
"cdtPppPeerIpAddrPoolStorage": {},
"cdtPppTimeoutAuthentication": {},
"cdtPppTimeoutRetry": {},
"cdtPppValid": {},
"cdtSrvMulticast": {},
"cdtSrvNetworkSrv": {},
"cdtSrvSgSrvGroup": {},
"cdtSrvSgSrvType": {},
"cdtSrvValid": {},
"cdtSrvVpdnGroup": {},
"cdtTemplateAssociationName": {},
"cdtTemplateAssociationPrecedence": {},
"cdtTemplateName": {},
"cdtTemplateSrc": {},
"cdtTemplateStatus": {},
"cdtTemplateStorage": {},
"cdtTemplateTargetStatus": {},
"cdtTemplateTargetStorage": {},
"cdtTemplateType": {},
"cdtTemplateUsageCount": {},
"cdtTemplateUsageTargetId": {},
"cdtTemplateUsageTargetType": {},
"ceAlarmCriticalCount": {},
"ceAlarmCutOff": {},
"ceAlarmDescrSeverity": {},
"ceAlarmDescrText": {},
"ceAlarmDescrVendorType": {},
"ceAlarmFilterAlarmsEnabled": {},
"ceAlarmFilterAlias": {},
"ceAlarmFilterNotifiesEnabled": {},
"ceAlarmFilterProfile": {},
"ceAlarmFilterProfileIndexNext": {},
"ceAlarmFilterStatus": {},
"ceAlarmFilterSyslogEnabled": {},
"ceAlarmHistAlarmType": {},
"ceAlarmHistEntPhysicalIndex": {},
"ceAlarmHistLastIndex": {},
"ceAlarmHistSeverity": {},
"ceAlarmHistTableSize": {},
"ceAlarmHistTimeStamp": {},
"ceAlarmHistType": {},
"ceAlarmList": {},
"ceAlarmMajorCount": {},
"ceAlarmMinorCount": {},
"ceAlarmNotifiesEnable": {},
"ceAlarmSeverity": {},
"ceAlarmSyslogEnable": {},
"ceAssetAlias": {},
"ceAssetCLEI": {},
"ceAssetFirmwareID": {},
"ceAssetFirmwareRevision": {},
"ceAssetHardwareRevision": {},
"ceAssetIsFRU": {},
"ceAssetMfgAssyNumber": {},
"ceAssetMfgAssyRevision": {},
"ceAssetOEMString": {},
"ceAssetOrderablePartNumber": {},
"ceAssetSerialNumber": {},
"ceAssetSoftwareID": {},
"ceAssetSoftwareRevision": {},
"ceAssetTag": {},
"ceDiagEntityCurrentTestEntry": {"1": {}},
"ceDiagEntityEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"ceDiagErrorInfoEntry": {"2": {}},
"ceDiagEventQueryEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"ceDiagEventResultEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"ceDiagEvents": {"1": {}, "2": {}, "3": {}},
"ceDiagHMTestEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ceDiagHealthMonitor": {"1": {}},
"ceDiagNotificationControl": {"1": {}, "2": {}, "3": {}, "4": {}},
"ceDiagOnDemand": {"1": {}, "2": {}, "3": {}},
"ceDiagOnDemandJobEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"ceDiagScheduledJobEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ceDiagTestCustomAttributeEntry": {"2": {}},
"ceDiagTestInfoEntry": {"2": {}, "3": {}},
"ceDiagTestPerfEntry": {
"1": {},
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ceExtConfigRegNext": {},
"ceExtConfigRegister": {},
"ceExtEntBreakOutPortNotifEnable": {},
"ceExtEntDoorNotifEnable": {},
"ceExtEntityLEDColor": {},
"ceExtHCProcessorRam": {},
"ceExtKickstartImageList": {},
"ceExtNVRAMSize": {},
"ceExtNVRAMUsed": {},
"ceExtNotificationControlObjects": {"3": {}},
"ceExtProcessorRam": {},
"ceExtProcessorRamOverflow": {},
"ceExtSysBootImageList": {},
"ceExtUSBModemIMEI": {},
"ceExtUSBModemIMSI": {},
"ceExtUSBModemServiceProvider": {},
"ceExtUSBModemSignalStrength": {},
"ceImage.1.1.2": {},
"ceImage.1.1.3": {},
"ceImage.1.1.4": {},
"ceImage.1.1.5": {},
"ceImage.1.1.6": {},
"ceImage.1.1.7": {},
"ceImageInstallableTable.1.2": {},
"ceImageInstallableTable.1.3": {},
"ceImageInstallableTable.1.4": {},
"ceImageInstallableTable.1.5": {},
"ceImageInstallableTable.1.6": {},
"ceImageInstallableTable.1.7": {},
"ceImageInstallableTable.1.8": {},
"ceImageInstallableTable.1.9": {},
"ceImageLocationTable.1.2": {},
"ceImageLocationTable.1.3": {},
"ceImageTags.1.1.2": {},
"ceImageTags.1.1.3": {},
"ceImageTags.1.1.4": {},
"ceeDot3PauseExtAdminMode": {},
"ceeDot3PauseExtOperMode": {},
"ceeSubInterfaceCount": {},
"ceemEventMapEntry": {"2": {}, "3": {}},
"ceemHistory": {"1": {}},
"ceemHistoryEventEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ceemHistoryLastEventEntry": {},
"ceemRegisteredPolicyEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cefAdjBytes": {},
"cefAdjEncap": {},
"cefAdjFixup": {},
"cefAdjForwardingInfo": {},
"cefAdjHCBytes": {},
"cefAdjHCPkts": {},
"cefAdjMTU": {},
"cefAdjPkts": {},
"cefAdjSource": {},
"cefAdjSummaryComplete": {},
"cefAdjSummaryFixup": {},
"cefAdjSummaryIncomplete": {},
"cefAdjSummaryRedirect": {},
"cefCCCount": {},
"cefCCEnabled": {},
"cefCCGlobalAutoRepairDelay": {},
"cefCCGlobalAutoRepairEnabled": {},
"cefCCGlobalAutoRepairHoldDown": {},
"cefCCGlobalErrorMsgEnabled": {},
"cefCCGlobalFullScanAction": {},
"cefCCGlobalFullScanStatus": {},
"cefCCPeriod": {},
"cefCCQueriesChecked": {},
"cefCCQueriesIgnored": {},
"cefCCQueriesIterated": {},
"cefCCQueriesSent": {},
"cefCfgAccountingMap": {},
"cefCfgAdminState": {},
"cefCfgDistributionAdminState": {},
"cefCfgDistributionOperState": {},
"cefCfgLoadSharingAlgorithm": {},
"cefCfgLoadSharingID": {},
"cefCfgOperState": {},
"cefCfgTrafficStatsLoadInterval": {},
"cefCfgTrafficStatsUpdateRate": {},
"cefFESelectionAdjConnId": {},
"cefFESelectionAdjInterface": {},
"cefFESelectionAdjLinkType": {},
"cefFESelectionAdjNextHopAddr": {},
"cefFESelectionAdjNextHopAddrType": {},
"cefFESelectionLabels": {},
"cefFESelectionSpecial": {},
"cefFESelectionVrfName": {},
"cefFESelectionWeight": {},
"cefFIBSummaryFwdPrefixes": {},
"cefInconsistencyCCType": {},
"cefInconsistencyEntity": {},
"cefInconsistencyNotifEnable": {},
"cefInconsistencyPrefixAddr": {},
"cefInconsistencyPrefixLen": {},
"cefInconsistencyPrefixType": {},
"cefInconsistencyReason": {},
"cefInconsistencyReset": {},
"cefInconsistencyResetStatus": {},
"cefInconsistencyVrfName": {},
"cefIntLoadSharing": {},
"cefIntNonrecursiveAccouting": {},
"cefIntSwitchingState": {},
"cefLMPrefixAddr": {},
"cefLMPrefixLen": {},
"cefLMPrefixRowStatus": {},
"cefLMPrefixSpinLock": {},
"cefLMPrefixState": {},
"cefNotifThrottlingInterval": {},
"cefPathInterface": {},
"cefPathNextHopAddr": {},
"cefPathRecurseVrfName": {},
"cefPathType": {},
"cefPeerFIBOperState": {},
"cefPeerFIBStateChangeNotifEnable": {},
"cefPeerNumberOfResets": {},
"cefPeerOperState": {},
"cefPeerStateChangeNotifEnable": {},
"cefPrefixBytes": {},
"cefPrefixExternalNRBytes": {},
"cefPrefixExternalNRHCBytes": {},
"cefPrefixExternalNRHCPkts": {},
"cefPrefixExternalNRPkts": {},
"cefPrefixForwardingInfo": {},
"cefPrefixHCBytes": {},
"cefPrefixHCPkts": {},
"cefPrefixInternalNRBytes": {},
"cefPrefixInternalNRHCBytes": {},
"cefPrefixInternalNRHCPkts": {},
"cefPrefixInternalNRPkts": {},
"cefPrefixPkts": {},
"cefResourceFailureNotifEnable": {},
"cefResourceFailureReason": {},
"cefResourceMemoryUsed": {},
"cefStatsPrefixDeletes": {},
"cefStatsPrefixElements": {},
"cefStatsPrefixHCDeletes": {},
"cefStatsPrefixHCElements": {},
"cefStatsPrefixHCInserts": {},
"cefStatsPrefixHCQueries": {},
"cefStatsPrefixInserts": {},
"cefStatsPrefixQueries": {},
"cefSwitchingDrop": {},
"cefSwitchingHCDrop": {},
"cefSwitchingHCPunt": {},
"cefSwitchingHCPunt2Host": {},
"cefSwitchingPath": {},
"cefSwitchingPunt": {},
"cefSwitchingPunt2Host": {},
"cefcFRUPowerStatusTable.1.1": {},
"cefcFRUPowerStatusTable.1.2": {},
"cefcFRUPowerStatusTable.1.3": {},
"cefcFRUPowerStatusTable.1.4": {},
"cefcFRUPowerStatusTable.1.5": {},
"cefcFRUPowerSupplyGroupTable.1.1": {},
"cefcFRUPowerSupplyGroupTable.1.2": {},
"cefcFRUPowerSupplyGroupTable.1.3": {},
"cefcFRUPowerSupplyGroupTable.1.4": {},
"cefcFRUPowerSupplyGroupTable.1.5": {},
"cefcFRUPowerSupplyGroupTable.1.6": {},
"cefcFRUPowerSupplyGroupTable.1.7": {},
"cefcFRUPowerSupplyValueTable.1.1": {},
"cefcFRUPowerSupplyValueTable.1.2": {},
"cefcFRUPowerSupplyValueTable.1.3": {},
"cefcFRUPowerSupplyValueTable.1.4": {},
"cefcMIBEnableStatusNotification": {},
"cefcMaxDefaultInLinePower": {},
"cefcModuleTable.1.1": {},
"cefcModuleTable.1.2": {},
"cefcModuleTable.1.3": {},
"cefcModuleTable.1.4": {},
"cefcModuleTable.1.5": {},
"cefcModuleTable.1.6": {},
"cefcModuleTable.1.7": {},
"cefcModuleTable.1.8": {},
"cempMIBObjects.2.1": {},
"cempMemBufferCachePoolEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
},
"cempMemBufferPoolEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cempMemPoolEntry": {
"10": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cepConfigFallingThreshold": {},
"cepConfigPerfRange": {},
"cepConfigRisingThreshold": {},
"cepConfigThresholdNotifEnabled": {},
"cepEntityLastReloadTime": {},
"cepEntityNumReloads": {},
"cepIntervalStatsCreateTime": {},
"cepIntervalStatsMeasurement": {},
"cepIntervalStatsRange": {},
"cepIntervalStatsValidData": {},
"cepIntervalTimeElapsed": {},
"cepStatsAlgorithm": {},
"cepStatsMeasurement": {},
"cepThresholdNotifEnabled": {},
"cepThroughputAvgRate": {},
"cepThroughputInterval": {},
"cepThroughputLevel": {},
"cepThroughputLicensedBW": {},
"cepThroughputNotifEnabled": {},
"cepThroughputThreshold": {},
"cepValidIntervalCount": {},
"ceqfpFiveMinutesUtilAlgo": {},
"ceqfpFiveSecondUtilAlgo": {},
"ceqfpMemoryResCurrentFallingThresh": {},
"ceqfpMemoryResCurrentRisingThresh": {},
"ceqfpMemoryResFallingThreshold": {},
"ceqfpMemoryResFree": {},
"ceqfpMemoryResInUse": {},
"ceqfpMemoryResLowFreeWatermark": {},
"ceqfpMemoryResRisingThreshold": {},
"ceqfpMemoryResThreshNotifEnabled": {},
"ceqfpMemoryResTotal": {},
"ceqfpMemoryResourceEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"8": {},
"9": {},
},
"ceqfpNumberSystemLoads": {},
"ceqfpOneMinuteUtilAlgo": {},
"ceqfpSixtyMinutesUtilAlgo": {},
"ceqfpSystemLastLoadTime": {},
"ceqfpSystemState": {},
"ceqfpSystemTrafficDirection": {},
"ceqfpThroughputAvgRate": {},
"ceqfpThroughputLevel": {},
"ceqfpThroughputLicensedBW": {},
"ceqfpThroughputNotifEnabled": {},
"ceqfpThroughputSamplePeriod": {},
"ceqfpThroughputThreshold": {},
"ceqfpUtilInputNonPriorityBitRate": {},
"ceqfpUtilInputNonPriorityPktRate": {},
"ceqfpUtilInputPriorityBitRate": {},
"ceqfpUtilInputPriorityPktRate": {},
"ceqfpUtilInputTotalBitRate": {},
"ceqfpUtilInputTotalPktRate": {},
"ceqfpUtilOutputNonPriorityBitRate": {},
"ceqfpUtilOutputNonPriorityPktRate": {},
"ceqfpUtilOutputPriorityBitRate": {},
"ceqfpUtilOutputPriorityPktRate": {},
"ceqfpUtilOutputTotalBitRate": {},
"ceqfpUtilOutputTotalPktRate": {},
"ceqfpUtilProcessingLoad": {},
"cermConfigResGroupRowStatus": {},
"cermConfigResGroupStorageType": {},
"cermConfigResGroupUserRowStatus": {},
"cermConfigResGroupUserStorageType": {},
"cermConfigResGroupUserTypeName": {},
"cermNotifsDirection": {},
"cermNotifsEnabled": {},
"cermNotifsPolicyName": {},
"cermNotifsThresholdIsUserGlob": {},
"cermNotifsThresholdSeverity": {},
"cermNotifsThresholdValue": {},
"cermPolicyApplyPolicyName": {},
"cermPolicyApplyRowStatus": {},
"cermPolicyApplyStorageType": {},
"cermPolicyFallingInterval": {},
"cermPolicyFallingThreshold": {},
"cermPolicyIsGlobal": {},
"cermPolicyLoggingEnabled": {},
"cermPolicyResOwnerThreshRowStatus": {},
"cermPolicyResOwnerThreshStorageType": {},
"cermPolicyRisingInterval": {},
"cermPolicyRisingThreshold": {},
"cermPolicyRowStatus": {},
"cermPolicySnmpNotifEnabled": {},
"cermPolicyStorageType": {},
"cermPolicyUserTypeName": {},
"cermResGroupName": {},
"cermResGroupResUserId": {},
"cermResGroupUserInstanceCount": {},
"cermResMonitorName": {},
"cermResMonitorPolicyName": {},
"cermResMonitorResPolicyName": {},
"cermResOwnerMeasurementUnit": {},
"cermResOwnerName": {},
"cermResOwnerResGroupCount": {},
"cermResOwnerResUserCount": {},
"cermResOwnerSubTypeFallingInterval": {},
"cermResOwnerSubTypeFallingThresh": {},
"cermResOwnerSubTypeGlobNotifSeverity": {},
"cermResOwnerSubTypeMaxUsage": {},
"cermResOwnerSubTypeName": {},
"cermResOwnerSubTypeRisingInterval": {},
"cermResOwnerSubTypeRisingThresh": {},
"cermResOwnerSubTypeUsage": {},
"cermResOwnerSubTypeUsagePct": {},
"cermResOwnerThreshIsConfigurable": {},
"cermResUserName": {},
"cermResUserOrGroupFallingInterval": {},
"cermResUserOrGroupFallingThresh": {},
"cermResUserOrGroupFlag": {},
"cermResUserOrGroupGlobNotifSeverity": {},
"cermResUserOrGroupMaxUsage": {},
"cermResUserOrGroupNotifSeverity": {},
"cermResUserOrGroupRisingInterval": {},
"cermResUserOrGroupRisingThresh": {},
"cermResUserOrGroupThreshFlag": {},
"cermResUserOrGroupUsage": {},
"cermResUserOrGroupUsagePct": {},
"cermResUserPriority": {},
"cermResUserResGroupId": {},
"cermResUserTypeName": {},
"cermResUserTypeResGroupCount": {},
"cermResUserTypeResOwnerCount": {},
"cermResUserTypeResOwnerId": {},
"cermResUserTypeResUserCount": {},
"cermScalarsGlobalPolicyName": {},
"cevcEvcActiveUnis": {},
"cevcEvcCfgUnis": {},
"cevcEvcIdentifier": {},
"cevcEvcLocalUniIfIndex": {},
"cevcEvcNotifyEnabled": {},
"cevcEvcOperStatus": {},
"cevcEvcRowStatus": {},
"cevcEvcStorageType": {},
"cevcEvcType": {},
"cevcEvcUniId": {},
"cevcEvcUniOperStatus": {},
"cevcMacAddress": {},
"cevcMaxMacConfigLimit": {},
"cevcMaxNumEvcs": {},
"cevcNumCfgEvcs": {},
"cevcPortL2ControlProtocolAction": {},
"cevcPortMaxNumEVCs": {},
"cevcPortMaxNumServiceInstances": {},
"cevcPortMode": {},
"cevcSIAdminStatus": {},
"cevcSICEVlanEndingVlan": {},
"cevcSICEVlanRowStatus": {},
"cevcSICEVlanStorageType": {},
"cevcSICreationType": {},
"cevcSIEvcIndex": {},
"cevcSIForwardBdNumber": {},
"cevcSIForwardBdNumber1kBitmap": {},
"cevcSIForwardBdNumber2kBitmap": {},
"cevcSIForwardBdNumber3kBitmap": {},
"cevcSIForwardBdNumber4kBitmap": {},
"cevcSIForwardBdNumberBase": {},
"cevcSIForwardBdRowStatus": {},
"cevcSIForwardBdStorageType": {},
"cevcSIForwardingType": {},
"cevcSIID": {},
"cevcSIL2ControlProtocolAction": {},
"cevcSIMatchCriteriaType": {},
"cevcSIMatchEncapEncapsulation": {},
"cevcSIMatchEncapPayloadType": {},
"cevcSIMatchEncapPayloadTypes": {},
"cevcSIMatchEncapPrimaryCos": {},
"cevcSIMatchEncapPriorityCos": {},
"cevcSIMatchEncapRowStatus": {},
"cevcSIMatchEncapSecondaryCos": {},
"cevcSIMatchEncapStorageType": {},
"cevcSIMatchEncapValid": {},
"cevcSIMatchRowStatus": {},
"cevcSIMatchStorageType": {},
"cevcSIName": {},
"cevcSIOperStatus": {},
"cevcSIPrimaryVlanEndingVlan": {},
"cevcSIPrimaryVlanRowStatus": {},
"cevcSIPrimaryVlanStorageType": {},
"cevcSIRowStatus": {},
"cevcSISecondaryVlanEndingVlan": {},
"cevcSISecondaryVlanRowStatus": {},
"cevcSISecondaryVlanStorageType": {},
"cevcSIStorageType": {},
"cevcSITarget": {},
"cevcSITargetType": {},
"cevcSIType": {},
"cevcSIVlanRewriteAction": {},
"cevcSIVlanRewriteEncapsulation": {},
"cevcSIVlanRewriteRowStatus": {},
"cevcSIVlanRewriteStorageType": {},
"cevcSIVlanRewriteSymmetric": {},
"cevcSIVlanRewriteVlan1": {},
"cevcSIVlanRewriteVlan2": {},
"cevcUniCEVlanEvcEndingVlan": {},
"cevcUniIdentifier": {},
"cevcUniPortType": {},
"cevcUniServiceAttributes": {},
"cevcViolationCause": {},
"cfcRequestTable.1.10": {},
"cfcRequestTable.1.11": {},
"cfcRequestTable.1.12": {},
"cfcRequestTable.1.2": {},
"cfcRequestTable.1.3": {},
"cfcRequestTable.1.4": {},
"cfcRequestTable.1.5": {},
"cfcRequestTable.1.6": {},
"cfcRequestTable.1.7": {},
"cfcRequestTable.1.8": {},
"cfcRequestTable.1.9": {},
"cfmAlarmGroupConditionId": {},
"cfmAlarmGroupConditionsProfile": {},
"cfmAlarmGroupCurrentCount": {},
"cfmAlarmGroupDescr": {},
"cfmAlarmGroupFlowCount": {},
"cfmAlarmGroupFlowId": {},
"cfmAlarmGroupFlowSet": {},
"cfmAlarmGroupFlowTableChanged": {},
"cfmAlarmGroupRaised": {},
"cfmAlarmGroupTableChanged": {},
"cfmAlarmGroupThreshold": {},
"cfmAlarmGroupThresholdUnits": {},
"cfmAlarmHistoryConditionId": {},
"cfmAlarmHistoryConditionsProfile": {},
"cfmAlarmHistoryEntity": {},
"cfmAlarmHistoryLastId": {},
"cfmAlarmHistorySeverity": {},
"cfmAlarmHistorySize": {},
"cfmAlarmHistoryTime": {},
"cfmAlarmHistoryType": {},
"cfmConditionAlarm": {},
"cfmConditionAlarmActions": {},
"cfmConditionAlarmGroup": {},
"cfmConditionAlarmSeverity": {},
"cfmConditionDescr": {},
"cfmConditionMonitoredElement": {},
"cfmConditionSampleType": {},
"cfmConditionSampleWindow": {},
"cfmConditionTableChanged": {},
"cfmConditionThreshFall": {},
"cfmConditionThreshFallPrecision": {},
"cfmConditionThreshFallScale": {},
"cfmConditionThreshRise": {},
"cfmConditionThreshRisePrecision": {},
"cfmConditionThreshRiseScale": {},
"cfmConditionType": {},
"cfmFlowAdminStatus": {},
"cfmFlowCreateTime": {},
"cfmFlowDescr": {},
"cfmFlowDirection": {},
"cfmFlowDiscontinuityTime": {},
"cfmFlowEgress": {},
"cfmFlowEgressType": {},
"cfmFlowExpirationTime": {},
"cfmFlowIngress": {},
"cfmFlowIngressType": {},
"cfmFlowIpAddrDst": {},
"cfmFlowIpAddrSrc": {},
"cfmFlowIpAddrType": {},
"cfmFlowIpEntry": {"10": {}, "8": {}, "9": {}},
"cfmFlowIpHopLimit": {},
"cfmFlowIpNext": {},
"cfmFlowIpTableChanged": {},
"cfmFlowIpTrafficClass": {},
"cfmFlowIpValid": {},
"cfmFlowL2InnerVlanCos": {},
"cfmFlowL2InnerVlanId": {},
"cfmFlowL2VlanCos": {},
"cfmFlowL2VlanId": {},
"cfmFlowL2VlanNext": {},
"cfmFlowL2VlanTableChanged": {},
"cfmFlowMetricsAlarmSeverity": {},
"cfmFlowMetricsAlarms": {},
"cfmFlowMetricsBitRate": {},
"cfmFlowMetricsBitRateUnits": {},
"cfmFlowMetricsCollected": {},
"cfmFlowMetricsConditions": {},
"cfmFlowMetricsConditionsProfile": {},
"cfmFlowMetricsElapsedTime": {},
"cfmFlowMetricsEntry": {
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
},
"cfmFlowMetricsErrorSecs": {},
"cfmFlowMetricsErrorSecsPrecision": {},
"cfmFlowMetricsErrorSecsScale": {},
"cfmFlowMetricsIntAlarmSeverity": {},
"cfmFlowMetricsIntAlarms": {},
"cfmFlowMetricsIntBitRate": {},
"cfmFlowMetricsIntBitRateUnits": {},
"cfmFlowMetricsIntConditions": {},
"cfmFlowMetricsIntEntry": {
"18": {},
"19": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
},
"cfmFlowMetricsIntErrorSecs": {},
"cfmFlowMetricsIntErrorSecsPrecision": {},
"cfmFlowMetricsIntErrorSecsScale": {},
"cfmFlowMetricsIntOctets": {},
"cfmFlowMetricsIntPktRate": {},
"cfmFlowMetricsIntPkts": {},
"cfmFlowMetricsIntTime": {},
"cfmFlowMetricsIntTransportAvailability": {},
"cfmFlowMetricsIntTransportAvailabilityPrecision": {},
"cfmFlowMetricsIntTransportAvailabilityScale": {},
"cfmFlowMetricsIntValid": {},
"cfmFlowMetricsIntervalTime": {},
"cfmFlowMetricsIntervals": {},
"cfmFlowMetricsInvalidIntervals": {},
"cfmFlowMetricsMaxIntervals": {},
"cfmFlowMetricsOctets": {},
"cfmFlowMetricsPktRate": {},
"cfmFlowMetricsPkts": {},
"cfmFlowMetricsTableChanged": {},
"cfmFlowMetricsTransportAvailability": {},
"cfmFlowMetricsTransportAvailabilityPrecision": {},
"cfmFlowMetricsTransportAvailabilityScale": {},
"cfmFlowMonitorAlarmCriticalCount": {},
"cfmFlowMonitorAlarmInfoCount": {},
"cfmFlowMonitorAlarmMajorCount": {},
"cfmFlowMonitorAlarmMinorCount": {},
"cfmFlowMonitorAlarmSeverity": {},
"cfmFlowMonitorAlarmWarningCount": {},
"cfmFlowMonitorAlarms": {},
"cfmFlowMonitorCaps": {},
"cfmFlowMonitorConditions": {},
"cfmFlowMonitorConditionsProfile": {},
"cfmFlowMonitorDescr": {},
"cfmFlowMonitorFlowCount": {},
"cfmFlowMonitorTableChanged": {},
"cfmFlowNext": {},
"cfmFlowOperStatus": {},
"cfmFlowRtpNext": {},
"cfmFlowRtpPayloadType": {},
"cfmFlowRtpSsrc": {},
"cfmFlowRtpTableChanged": {},
"cfmFlowRtpVersion": {},
"cfmFlowTableChanged": {},
"cfmFlowTcpNext": {},
"cfmFlowTcpPortDst": {},
"cfmFlowTcpPortSrc": {},
"cfmFlowTcpTableChanged": {},
"cfmFlowUdpNext": {},
"cfmFlowUdpPortDst": {},
"cfmFlowUdpPortSrc": {},
"cfmFlowUdpTableChanged": {},
"cfmFlows": {"14": {}},
"cfmFlows.13.1.1": {},
"cfmFlows.13.1.2": {},
"cfmFlows.13.1.3": {},
"cfmFlows.13.1.4": {},
"cfmFlows.13.1.5": {},
"cfmFlows.13.1.6": {},
"cfmFlows.13.1.7": {},
"cfmFlows.13.1.8": {},
"cfmIpCbrMetricsCfgBitRate": {},
"cfmIpCbrMetricsCfgMediaPktSize": {},
"cfmIpCbrMetricsCfgRate": {},
"cfmIpCbrMetricsCfgRateType": {},
"cfmIpCbrMetricsEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
},
"cfmIpCbrMetricsIntDf": {},
"cfmIpCbrMetricsIntDfPrecision": {},
"cfmIpCbrMetricsIntDfScale": {},
"cfmIpCbrMetricsIntEntry": {
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
},
"cfmIpCbrMetricsIntLostPkts": {},
"cfmIpCbrMetricsIntMr": {},
"cfmIpCbrMetricsIntMrUnits": {},
"cfmIpCbrMetricsIntMrv": {},
"cfmIpCbrMetricsIntMrvPrecision": {},
"cfmIpCbrMetricsIntMrvScale": {},
"cfmIpCbrMetricsIntValid": {},
"cfmIpCbrMetricsIntVbMax": {},
"cfmIpCbrMetricsIntVbMin": {},
"cfmIpCbrMetricsLostPkts": {},
"cfmIpCbrMetricsMrv": {},
"cfmIpCbrMetricsMrvPrecision": {},
"cfmIpCbrMetricsMrvScale": {},
"cfmIpCbrMetricsTableChanged": {},
"cfmIpCbrMetricsValid": {},
"cfmMdiMetricsCfgBitRate": {},
"cfmMdiMetricsCfgMediaPktSize": {},
"cfmMdiMetricsCfgRate": {},
"cfmMdiMetricsCfgRateType": {},
"cfmMdiMetricsEntry": {"10": {}},
"cfmMdiMetricsIntDf": {},
"cfmMdiMetricsIntDfPrecision": {},
"cfmMdiMetricsIntDfScale": {},
"cfmMdiMetricsIntEntry": {"13": {}},
"cfmMdiMetricsIntLostPkts": {},
"cfmMdiMetricsIntMlr": {},
"cfmMdiMetricsIntMlrPrecision": {},
"cfmMdiMetricsIntMlrScale": {},
"cfmMdiMetricsIntMr": {},
"cfmMdiMetricsIntMrUnits": {},
"cfmMdiMetricsIntValid": {},
"cfmMdiMetricsIntVbMax": {},
"cfmMdiMetricsIntVbMin": {},
"cfmMdiMetricsLostPkts": {},
"cfmMdiMetricsMlr": {},
"cfmMdiMetricsMlrPrecision": {},
"cfmMdiMetricsMlrScale": {},
"cfmMdiMetricsTableChanged": {},
"cfmMdiMetricsValid": {},
"cfmMetadataFlowAllAttrPen": {},
"cfmMetadataFlowAllAttrValue": {},
"cfmMetadataFlowAttrType": {},
"cfmMetadataFlowAttrValue": {},
"cfmMetadataFlowDestAddr": {},
"cfmMetadataFlowDestAddrType": {},
"cfmMetadataFlowDestPort": {},
"cfmMetadataFlowProtocolType": {},
"cfmMetadataFlowSSRC": {},
"cfmMetadataFlowSrcAddr": {},
"cfmMetadataFlowSrcAddrType": {},
"cfmMetadataFlowSrcPort": {},
"cfmNotifyEnable": {},
"cfmRtpMetricsAvgLD": {},
"cfmRtpMetricsAvgLDPrecision": {},
"cfmRtpMetricsAvgLDScale": {},
"cfmRtpMetricsAvgLossDistance": {},
"cfmRtpMetricsEntry": {
"18": {},
"19": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"30": {},
"31": {},
},
"cfmRtpMetricsExpectedPkts": {},
"cfmRtpMetricsFrac": {},
"cfmRtpMetricsFracPrecision": {},
"cfmRtpMetricsFracScale": {},
"cfmRtpMetricsIntAvgLD": {},
"cfmRtpMetricsIntAvgLDPrecision": {},
"cfmRtpMetricsIntAvgLDScale": {},
"cfmRtpMetricsIntAvgLossDistance": {},
"cfmRtpMetricsIntEntry": {
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
},
"cfmRtpMetricsIntExpectedPkts": {},
"cfmRtpMetricsIntFrac": {},
"cfmRtpMetricsIntFracPrecision": {},
"cfmRtpMetricsIntFracScale": {},
"cfmRtpMetricsIntJitter": {},
"cfmRtpMetricsIntJitterPrecision": {},
"cfmRtpMetricsIntJitterScale": {},
"cfmRtpMetricsIntLIs": {},
"cfmRtpMetricsIntLostPkts": {},
"cfmRtpMetricsIntMaxJitter": {},
"cfmRtpMetricsIntMaxJitterPrecision": {},
"cfmRtpMetricsIntMaxJitterScale": {},
"cfmRtpMetricsIntTransit": {},
"cfmRtpMetricsIntTransitPrecision": {},
"cfmRtpMetricsIntTransitScale": {},
"cfmRtpMetricsIntValid": {},
"cfmRtpMetricsJitter": {},
"cfmRtpMetricsJitterPrecision": {},
"cfmRtpMetricsJitterScale": {},
"cfmRtpMetricsLIs": {},
"cfmRtpMetricsLostPkts": {},
"cfmRtpMetricsMaxJitter": {},
"cfmRtpMetricsMaxJitterPrecision": {},
"cfmRtpMetricsMaxJitterScale": {},
"cfmRtpMetricsTableChanged": {},
"cfmRtpMetricsValid": {},
"cfrCircuitEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"cfrConnectionEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cfrElmiEntry": {"1": {}, "2": {}, "3": {}},
"cfrElmiNeighborEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"cfrElmiObjs": {"1": {}},
"cfrExtCircuitEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cfrFragEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cfrLmiEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cfrMapEntry": {
"1": {},
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cfrSvcEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"chassis": {
"1": {},
"10": {},
"12": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cieIfDot1dBaseMappingEntry": {"1": {}},
"cieIfDot1qCustomEtherTypeEntry": {"1": {}, "2": {}},
"cieIfInterfaceEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cieIfNameMappingEntry": {"2": {}},
"cieIfPacketStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cieIfUtilEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"ciiAreaAddrEntry": {"1": {}},
"ciiCircEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"8": {},
"9": {},
},
"ciiCircLevelEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciiCircuitCounterEntry": {
"10": {},
"2": {},
"3": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciiIPRAEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciiISAdjAreaAddrEntry": {"2": {}},
"ciiISAdjEntry": {
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciiISAdjIPAddrEntry": {"2": {}, "3": {}},
"ciiISAdjProtSuppEntry": {"1": {}},
"ciiLSPSummaryEntry": {"3": {}, "4": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"ciiLSPTLVEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"ciiManAreaAddrEntry": {"2": {}},
"ciiPacketCounterEntry": {
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciiRAEntry": {
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ciiRedistributeAddrEntry": {"4": {}},
"ciiRouterEntry": {"3": {}, "4": {}},
"ciiSummAddrEntry": {"4": {}, "5": {}, "6": {}},
"ciiSysLevelEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciiSysObject": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"8": {},
"9": {},
},
"ciiSysProtSuppEntry": {"2": {}},
"ciiSystemCounterEntry": {
"10": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cipMacEntry": {"3": {}, "4": {}},
"cipMacFreeEntry": {"2": {}},
"cipMacXEntry": {"1": {}, "2": {}},
"cipPrecedenceEntry": {"3": {}, "4": {}},
"cipPrecedenceXEntry": {"1": {}, "2": {}},
"cipUrpfComputeInterval": {},
"cipUrpfDropNotifyHoldDownTime": {},
"cipUrpfDropRate": {},
"cipUrpfDropRateWindow": {},
"cipUrpfDrops": {},
"cipUrpfIfCheckStrict": {},
"cipUrpfIfDiscontinuityTime": {},
"cipUrpfIfDropRate": {},
"cipUrpfIfDropRateNotifyEnable": {},
"cipUrpfIfDrops": {},
"cipUrpfIfNotifyDrHoldDownReset": {},
"cipUrpfIfNotifyDropRateThreshold": {},
"cipUrpfIfSuppressedDrops": {},
"cipUrpfIfVrfName": {},
"cipUrpfIfWhichRouteTableID": {},
"cipUrpfVrfIfDiscontinuityTime": {},
"cipUrpfVrfIfDrops": {},
"cipUrpfVrfName": {},
"cipslaAutoGroupDescription": {},
"cipslaAutoGroupDestEndPointName": {},
"cipslaAutoGroupOperTemplateName": {},
"cipslaAutoGroupOperType": {},
"cipslaAutoGroupQoSEnable": {},
"cipslaAutoGroupRowStatus": {},
"cipslaAutoGroupSchedAgeout": {},
"cipslaAutoGroupSchedInterval": {},
"cipslaAutoGroupSchedLife": {},
"cipslaAutoGroupSchedMaxInterval": {},
"cipslaAutoGroupSchedMinInterval": {},
"cipslaAutoGroupSchedPeriod": {},
"cipslaAutoGroupSchedRowStatus": {},
"cipslaAutoGroupSchedStartTime": {},
"cipslaAutoGroupSchedStorageType": {},
"cipslaAutoGroupSchedulerId": {},
"cipslaAutoGroupStorageType": {},
"cipslaAutoGroupType": {},
"cipslaBaseEndPointDescription": {},
"cipslaBaseEndPointRowStatus": {},
"cipslaBaseEndPointStorageType": {},
"cipslaIPEndPointADDestIPAgeout": {},
"cipslaIPEndPointADDestPort": {},
"cipslaIPEndPointADMeasureRetry": {},
"cipslaIPEndPointADRowStatus": {},
"cipslaIPEndPointADStorageType": {},
"cipslaIPEndPointRowStatus": {},
"cipslaIPEndPointStorageType": {},
"cipslaPercentileJitterAvg": {},
"cipslaPercentileJitterDS": {},
"cipslaPercentileJitterSD": {},
"cipslaPercentileLatestAvg": {},
"cipslaPercentileLatestMax": {},
"cipslaPercentileLatestMin": {},
"cipslaPercentileLatestNum": {},
"cipslaPercentileLatestSum": {},
"cipslaPercentileLatestSum2": {},
"cipslaPercentileOWDS": {},
"cipslaPercentileOWSD": {},
"cipslaPercentileRTT": {},
"cipslaReactActionType": {},
"cipslaReactRowStatus": {},
"cipslaReactStorageType": {},
"cipslaReactThresholdCountX": {},
"cipslaReactThresholdCountY": {},
"cipslaReactThresholdFalling": {},
"cipslaReactThresholdRising": {},
"cipslaReactThresholdType": {},
"cipslaReactVar": {},
"ciscoAtmIfPVCs": {},
"ciscoBfdObjects.1.1": {},
"ciscoBfdObjects.1.3": {},
"ciscoBfdObjects.1.4": {},
"ciscoBfdSessDiag": {},
"ciscoBfdSessEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"9": {},
},
"ciscoBfdSessMapEntry": {"1": {}},
"ciscoBfdSessPerfEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoBulkFileMIB.1.1.1": {},
"ciscoBulkFileMIB.1.1.2": {},
"ciscoBulkFileMIB.1.1.3": {},
"ciscoBulkFileMIB.1.1.4": {},
"ciscoBulkFileMIB.1.1.5": {},
"ciscoBulkFileMIB.1.1.6": {},
"ciscoBulkFileMIB.1.1.7": {},
"ciscoBulkFileMIB.1.1.8": {},
"ciscoBulkFileMIB.1.2.1": {},
"ciscoBulkFileMIB.1.2.2": {},
"ciscoBulkFileMIB.1.2.3": {},
"ciscoBulkFileMIB.1.2.4": {},
"ciscoCBQosMIBObjects.10.4.1.1": {},
"ciscoCBQosMIBObjects.10.4.1.2": {},
"ciscoCBQosMIBObjects.10.69.1.3": {},
"ciscoCBQosMIBObjects.10.69.1.4": {},
"ciscoCBQosMIBObjects.10.69.1.5": {},
"ciscoCBQosMIBObjects.10.136.1.1": {},
"ciscoCBQosMIBObjects.10.205.1.1": {},
"ciscoCBQosMIBObjects.10.205.1.10": {},
"ciscoCBQosMIBObjects.10.205.1.11": {},
"ciscoCBQosMIBObjects.10.205.1.12": {},
"ciscoCBQosMIBObjects.10.205.1.2": {},
"ciscoCBQosMIBObjects.10.205.1.3": {},
"ciscoCBQosMIBObjects.10.205.1.4": {},
"ciscoCBQosMIBObjects.10.205.1.5": {},
"ciscoCBQosMIBObjects.10.205.1.6": {},
"ciscoCBQosMIBObjects.10.205.1.7": {},
"ciscoCBQosMIBObjects.10.205.1.8": {},
"ciscoCBQosMIBObjects.10.205.1.9": {},
"ciscoCallHistory": {"1": {}, "2": {}},
"ciscoCallHistoryEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoCallHomeMIB.1.13.1": {},
"ciscoCallHomeMIB.1.13.2": {},
"ciscoDlswCircuitEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"4": {},
"5": {},
"6": {},
"7": {},
},
"ciscoDlswCircuitStat": {"1": {}, "2": {}},
"ciscoDlswIfEntry": {"1": {}, "2": {}, "3": {}},
"ciscoDlswNode": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoDlswTConnConfigEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoDlswTConnOperEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoDlswTConnStat": {"1": {}, "2": {}, "3": {}},
"ciscoDlswTConnTcpConfigEntry": {"1": {}, "2": {}, "3": {}},
"ciscoDlswTConnTcpOperEntry": {"1": {}, "2": {}, "3": {}},
"ciscoDlswTrapControl": {"1": {}, "2": {}, "3": {}, "4": {}},
"ciscoEntityDiagMIB.1.2.1": {},
"ciscoEntityFRUControlMIB.1.1.5": {},
"ciscoEntityFRUControlMIB.10.9.2.1.1": {},
"ciscoEntityFRUControlMIB.10.9.2.1.2": {},
"ciscoEntityFRUControlMIB.10.9.3.1.1": {},
"ciscoEntityFRUControlMIB.1.3.2": {},
"ciscoEntityFRUControlMIB.10.25.1.1.1": {},
"ciscoEntityFRUControlMIB.10.36.1.1.1": {},
"ciscoEntityFRUControlMIB.10.49.1.1.2": {},
"ciscoEntityFRUControlMIB.10.49.2.1.2": {},
"ciscoEntityFRUControlMIB.10.49.2.1.3": {},
"ciscoEntityFRUControlMIB.10.64.1.1.1": {},
"ciscoEntityFRUControlMIB.10.64.1.1.2": {},
"ciscoEntityFRUControlMIB.10.64.2.1.1": {},
"ciscoEntityFRUControlMIB.10.64.2.1.2": {},
"ciscoEntityFRUControlMIB.10.64.3.1.1": {},
"ciscoEntityFRUControlMIB.10.64.3.1.2": {},
"ciscoEntityFRUControlMIB.10.64.4.1.2": {},
"ciscoEntityFRUControlMIB.10.64.4.1.3": {},
"ciscoEntityFRUControlMIB.10.64.4.1.4": {},
"ciscoEntityFRUControlMIB.10.64.4.1.5": {},
"ciscoEntityFRUControlMIB.10.81.1.1.1": {},
"ciscoEntityFRUControlMIB.10.81.2.1.1": {},
"ciscoExperiment.10.151.1.1.2": {},
"ciscoExperiment.10.151.1.1.3": {},
"ciscoExperiment.10.151.1.1.4": {},
"ciscoExperiment.10.151.1.1.5": {},
"ciscoExperiment.10.151.1.1.6": {},
"ciscoExperiment.10.151.1.1.7": {},
"ciscoExperiment.10.151.2.1.1": {},
"ciscoExperiment.10.151.2.1.2": {},
"ciscoExperiment.10.151.2.1.3": {},
"ciscoExperiment.10.151.3.1.1": {},
"ciscoExperiment.10.151.3.1.2": {},
"ciscoExperiment.10.19.1.1.2": {},
"ciscoExperiment.10.19.1.1.3": {},
"ciscoExperiment.10.19.1.1.4": {},
"ciscoExperiment.10.19.1.1.5": {},
"ciscoExperiment.10.19.1.1.6": {},
"ciscoExperiment.10.19.1.1.7": {},
"ciscoExperiment.10.19.1.1.8": {},
"ciscoExperiment.10.19.2.1.2": {},
"ciscoExperiment.10.19.2.1.3": {},
"ciscoExperiment.10.19.2.1.4": {},
"ciscoExperiment.10.19.2.1.5": {},
"ciscoExperiment.10.19.2.1.6": {},
"ciscoExperiment.10.19.2.1.7": {},
"ciscoExperiment.10.225.1.1.13": {},
"ciscoExperiment.10.225.1.1.14": {},
"ciscoFlashChipEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"ciscoFlashCopyEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoFlashDevice": {"1": {}},
"ciscoFlashDeviceEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoFlashFileByTypeEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"ciscoFlashFileEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"ciscoFlashMIB.1.4.1": {},
"ciscoFlashMIB.1.4.2": {},
"ciscoFlashMiscOpEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"ciscoFlashPartitionEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoFlashPartitioningEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoFtpClientMIB.1.1.1": {},
"ciscoFtpClientMIB.1.1.2": {},
"ciscoFtpClientMIB.1.1.3": {},
"ciscoFtpClientMIB.1.1.4": {},
"ciscoIfExtSystemConfig": {"1": {}},
"ciscoImageEntry": {"2": {}},
"ciscoIpMRoute": {"1": {}},
"ciscoIpMRouteEntry": {
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"37": {},
"38": {},
"39": {},
"40": {},
"41": {},
},
"ciscoIpMRouteHeartBeatEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ciscoIpMRouteInterfaceEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
},
"ciscoIpMRouteNextHopEntry": {"10": {}, "11": {}, "9": {}},
"ciscoMemoryPoolEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"ciscoMgmt.10.196.3.1": {},
"ciscoMgmt.10.196.3.10": {},
"ciscoMgmt.10.196.3.2": {},
"ciscoMgmt.10.196.3.3": {},
"ciscoMgmt.10.196.3.4": {},
"ciscoMgmt.10.196.3.5": {},
"ciscoMgmt.10.196.3.6.1.10": {},
"ciscoMgmt.10.196.3.6.1.11": {},
"ciscoMgmt.10.196.3.6.1.12": {},
"ciscoMgmt.10.196.3.6.1.13": {},
"ciscoMgmt.10.196.3.6.1.14": {},
"ciscoMgmt.10.196.3.6.1.15": {},
"ciscoMgmt.10.196.3.6.1.16": {},
"ciscoMgmt.10.196.3.6.1.17": {},
"ciscoMgmt.10.196.3.6.1.18": {},
"ciscoMgmt.10.196.3.6.1.19": {},
"ciscoMgmt.10.196.3.6.1.2": {},
"ciscoMgmt.10.196.3.6.1.20": {},
"ciscoMgmt.10.196.3.6.1.21": {},
"ciscoMgmt.10.196.3.6.1.22": {},
"ciscoMgmt.10.196.3.6.1.23": {},
"ciscoMgmt.10.196.3.6.1.24": {},
"ciscoMgmt.10.196.3.6.1.25": {},
"ciscoMgmt.10.196.3.6.1.3": {},
"ciscoMgmt.10.196.3.6.1.4": {},
"ciscoMgmt.10.196.3.6.1.5": {},
"ciscoMgmt.10.196.3.6.1.6": {},
"ciscoMgmt.10.196.3.6.1.7": {},
"ciscoMgmt.10.196.3.6.1.8": {},
"ciscoMgmt.10.196.3.6.1.9": {},
"ciscoMgmt.10.196.3.7": {},
"ciscoMgmt.10.196.3.8": {},
"ciscoMgmt.10.196.3.9": {},
"ciscoMgmt.10.196.4.1.1.10": {},
"ciscoMgmt.10.196.4.1.1.2": {},
"ciscoMgmt.10.196.4.1.1.3": {},
"ciscoMgmt.10.196.4.1.1.4": {},
"ciscoMgmt.10.196.4.1.1.5": {},
"ciscoMgmt.10.196.4.1.1.6": {},
"ciscoMgmt.10.196.4.1.1.7": {},
"ciscoMgmt.10.196.4.1.1.8": {},
"ciscoMgmt.10.196.4.1.1.9": {},
"ciscoMgmt.10.196.4.2.1.2": {},
"ciscoMgmt.10.84.1.1.1.2": {},
"ciscoMgmt.10.84.1.1.1.3": {},
"ciscoMgmt.10.84.1.1.1.4": {},
"ciscoMgmt.10.84.1.1.1.5": {},
"ciscoMgmt.10.84.1.1.1.6": {},
"ciscoMgmt.10.84.1.1.1.7": {},
"ciscoMgmt.10.84.1.1.1.8": {},
"ciscoMgmt.10.84.1.1.1.9": {},
"ciscoMgmt.10.84.2.1.1.1": {},
"ciscoMgmt.10.84.2.1.1.2": {},
"ciscoMgmt.10.84.2.1.1.3": {},
"ciscoMgmt.10.84.2.1.1.4": {},
"ciscoMgmt.10.84.2.1.1.5": {},
"ciscoMgmt.10.84.2.1.1.6": {},
"ciscoMgmt.10.84.2.1.1.7": {},
"ciscoMgmt.10.84.2.1.1.8": {},
"ciscoMgmt.10.84.2.1.1.9": {},
"ciscoMgmt.10.84.2.2.1.1": {},
"ciscoMgmt.10.84.2.2.1.2": {},
"ciscoMgmt.10.84.3.1.1.2": {},
"ciscoMgmt.10.84.3.1.1.3": {},
"ciscoMgmt.10.84.3.1.1.4": {},
"ciscoMgmt.10.84.3.1.1.5": {},
"ciscoMgmt.10.84.4.1.1.3": {},
"ciscoMgmt.10.84.4.1.1.4": {},
"ciscoMgmt.10.84.4.1.1.5": {},
"ciscoMgmt.10.84.4.1.1.6": {},
"ciscoMgmt.10.84.4.1.1.7": {},
"ciscoMgmt.10.84.4.2.1.3": {},
"ciscoMgmt.10.84.4.2.1.4": {},
"ciscoMgmt.10.84.4.2.1.5": {},
"ciscoMgmt.10.84.4.2.1.6": {},
"ciscoMgmt.10.84.4.2.1.7": {},
"ciscoMgmt.10.84.4.3.1.3": {},
"ciscoMgmt.10.84.4.3.1.4": {},
"ciscoMgmt.10.84.4.3.1.5": {},
"ciscoMgmt.10.84.4.3.1.6": {},
"ciscoMgmt.10.84.4.3.1.7": {},
"ciscoMgmt.172.16.84.1.1": {},
"ciscoMgmt.172.16.115.1.1": {},
"ciscoMgmt.172.16.115.1.10": {},
"ciscoMgmt.172.16.115.1.11": {},
"ciscoMgmt.172.16.115.1.12": {},
"ciscoMgmt.172.16.115.1.2": {},
"ciscoMgmt.172.16.115.1.3": {},
"ciscoMgmt.172.16.115.1.4": {},
"ciscoMgmt.172.16.115.1.5": {},
"ciscoMgmt.172.16.115.1.6": {},
"ciscoMgmt.172.16.115.1.7": {},
"ciscoMgmt.172.16.115.1.8": {},
"ciscoMgmt.172.16.115.1.9": {},
"ciscoMgmt.172.16.151.1.1": {},
"ciscoMgmt.172.16.151.1.2": {},
"ciscoMgmt.172.16.94.1.1": {},
"ciscoMgmt.172.16.120.1.1": {},
"ciscoMgmt.172.16.120.1.2": {},
"ciscoMgmt.172.16.136.1.1": {},
"ciscoMgmt.172.16.136.1.2": {},
"ciscoMgmt.172.16.154.1": {},
"ciscoMgmt.172.16.154.2": {},
"ciscoMgmt.172.16.154.3.1.2": {},
"ciscoMgmt.172.16.154.3.1.3": {},
"ciscoMgmt.172.16.154.3.1.4": {},
"ciscoMgmt.172.16.154.3.1.5": {},
"ciscoMgmt.172.16.154.3.1.6": {},
"ciscoMgmt.172.16.154.3.1.7": {},
"ciscoMgmt.172.16.154.3.1.8": {},
"ciscoMgmt.172.16.204.1": {},
"ciscoMgmt.172.16.204.2": {},
"ciscoMgmt.310.169.1.1": {},
"ciscoMgmt.310.169.1.2": {},
"ciscoMgmt.310.169.1.3.1.10": {},
"ciscoMgmt.310.169.1.3.1.11": {},
"ciscoMgmt.310.169.1.3.1.12": {},
"ciscoMgmt.310.169.1.3.1.13": {},
"ciscoMgmt.310.169.1.3.1.14": {},
"ciscoMgmt.310.169.1.3.1.15": {},
"ciscoMgmt.310.169.1.3.1.2": {},
"ciscoMgmt.310.169.1.3.1.3": {},
"ciscoMgmt.310.169.1.3.1.4": {},
"ciscoMgmt.310.169.1.3.1.5": {},
"ciscoMgmt.310.169.1.3.1.6": {},
"ciscoMgmt.310.169.1.3.1.7": {},
"ciscoMgmt.310.169.1.3.1.8": {},
"ciscoMgmt.310.169.1.3.1.9": {},
"ciscoMgmt.310.169.1.4.1.2": {},
"ciscoMgmt.310.169.1.4.1.3": {},
"ciscoMgmt.310.169.1.4.1.4": {},
"ciscoMgmt.310.169.1.4.1.5": {},
"ciscoMgmt.310.169.1.4.1.6": {},
"ciscoMgmt.310.169.1.4.1.7": {},
"ciscoMgmt.310.169.1.4.1.8": {},
"ciscoMgmt.310.169.2.1.1.10": {},
"ciscoMgmt.310.169.2.1.1.11": {},
"ciscoMgmt.310.169.2.1.1.2": {},
"ciscoMgmt.310.169.2.1.1.3": {},
"ciscoMgmt.310.169.2.1.1.4": {},
"ciscoMgmt.310.169.2.1.1.5": {},
"ciscoMgmt.310.169.2.1.1.6": {},
"ciscoMgmt.310.169.2.1.1.7": {},
"ciscoMgmt.310.169.2.1.1.8": {},
"ciscoMgmt.310.169.2.1.1.9": {},
"ciscoMgmt.310.169.2.2.1.3": {},
"ciscoMgmt.310.169.2.2.1.4": {},
"ciscoMgmt.310.169.2.2.1.5": {},
"ciscoMgmt.310.169.2.3.1.3": {},
"ciscoMgmt.310.169.2.3.1.4": {},
"ciscoMgmt.310.169.2.3.1.5": {},
"ciscoMgmt.310.169.2.3.1.6": {},
"ciscoMgmt.310.169.2.3.1.7": {},
"ciscoMgmt.310.169.2.3.1.8": {},
"ciscoMgmt.310.169.3.1.1.1": {},
"ciscoMgmt.310.169.3.1.1.2": {},
"ciscoMgmt.310.169.3.1.1.3": {},
"ciscoMgmt.310.169.3.1.1.4": {},
"ciscoMgmt.310.169.3.1.1.5": {},
"ciscoMgmt.310.169.3.1.1.6": {},
"ciscoMgmt.410.169.1.1": {},
"ciscoMgmt.410.169.1.2": {},
"ciscoMgmt.410.169.2.1.1": {},
"ciscoMgmt.10.76.1.1.1.1": {},
"ciscoMgmt.10.76.1.1.1.2": {},
"ciscoMgmt.10.76.1.1.1.3": {},
"ciscoMgmt.10.76.1.1.1.4": {},
"ciscoMgmt.610.172.16.31.10": {},
"ciscoMgmt.610.172.16.58.31": {},
"ciscoMgmt.610.21.1.1.12": {},
"ciscoMgmt.610.21.1.1.13": {},
"ciscoMgmt.610.21.1.1.14": {},
"ciscoMgmt.610.21.1.1.15": {},
"ciscoMgmt.610.21.1.1.16": {},
"ciscoMgmt.610.21.1.1.17": {},
"ciscoMgmt.610.172.16.58.38": {},
"ciscoMgmt.610.172.16.58.39": {},
"ciscoMgmt.610.21.1.1.2": {},
"ciscoMgmt.610.21.1.1.20": {},
"ciscoMgmt.610.172.16.17.32": {},
"ciscoMgmt.610.172.16.31.102": {},
"ciscoMgmt.610.172.16.31.103": {},
"ciscoMgmt.610.172.16.31.104": {},
"ciscoMgmt.610.172.16.31.105": {},
"ciscoMgmt.610.172.16.31.106": {},
"ciscoMgmt.610.172.16.31.107": {},
"ciscoMgmt.610.172.16.31.108": {},
"ciscoMgmt.610.21.1.1.3": {},
"ciscoMgmt.610.192.168.127.120": {},
"ciscoMgmt.610.172.16.58.3": {},
"ciscoMgmt.610.192.168.3.11": {},
"ciscoMgmt.610.21.1.1.6": {},
"ciscoMgmt.610.21.1.1.7": {},
"ciscoMgmt.610.21.1.1.8": {},
"ciscoMgmt.610.21.1.1.9": {},
"ciscoMgmt.610.21.2.1.10": {},
"ciscoMgmt.610.21.2.1.11": {},
"ciscoMgmt.610.21.2.1.12": {},
"ciscoMgmt.610.21.2.1.13": {},
"ciscoMgmt.610.21.2.1.14": {},
"ciscoMgmt.610.21.2.1.15": {},
"ciscoMgmt.610.192.168.127.126": {},
"ciscoMgmt.610.21.2.1.2": {},
"ciscoMgmt.610.21.2.1.3": {},
"ciscoMgmt.610.21.2.1.4": {},
"ciscoMgmt.610.21.2.1.5": {},
"ciscoMgmt.610.21.2.1.6": {},
"ciscoMgmt.610.21.2.1.7": {},
"ciscoMgmt.610.21.2.1.8": {},
"ciscoMgmt.610.21.2.1.9": {},
"ciscoMgmt.610.94.1.1.10": {},
"ciscoMgmt.610.94.1.1.11": {},
"ciscoMgmt.610.94.1.1.12": {},
"ciscoMgmt.610.94.1.1.13": {},
"ciscoMgmt.610.94.1.1.14": {},
"ciscoMgmt.610.94.1.1.15": {},
"ciscoMgmt.610.94.1.1.16": {},
"ciscoMgmt.610.94.1.1.17": {},
"ciscoMgmt.610.94.1.1.18": {},
"ciscoMgmt.610.94.1.1.2": {},
"ciscoMgmt.610.94.1.1.3": {},
"ciscoMgmt.610.94.1.1.4": {},
"ciscoMgmt.610.94.1.1.5": {},
"ciscoMgmt.610.94.1.1.6": {},
"ciscoMgmt.610.94.1.1.7": {},
"ciscoMgmt.610.94.1.1.8": {},
"ciscoMgmt.610.94.1.1.9": {},
"ciscoMgmt.610.94.2.1.10": {},
"ciscoMgmt.610.94.2.1.11": {},
"ciscoMgmt.610.94.2.1.12": {},
"ciscoMgmt.610.94.2.1.13": {},
"ciscoMgmt.610.94.2.1.14": {},
"ciscoMgmt.610.94.2.1.15": {},
"ciscoMgmt.610.94.2.1.16": {},
"ciscoMgmt.610.94.2.1.17": {},
"ciscoMgmt.610.94.2.1.18": {},
"ciscoMgmt.610.94.2.1.19": {},
"ciscoMgmt.610.94.2.1.2": {},
"ciscoMgmt.610.94.2.1.20": {},
"ciscoMgmt.610.94.2.1.3": {},
"ciscoMgmt.610.94.2.1.4": {},
"ciscoMgmt.610.94.2.1.5": {},
"ciscoMgmt.610.94.2.1.6": {},
"ciscoMgmt.610.94.2.1.7": {},
"ciscoMgmt.610.94.2.1.8": {},
"ciscoMgmt.610.94.2.1.9": {},
"ciscoMgmt.610.94.3.1.10": {},
"ciscoMgmt.610.94.3.1.11": {},
"ciscoMgmt.610.94.3.1.12": {},
"ciscoMgmt.610.94.3.1.13": {},
"ciscoMgmt.610.94.3.1.14": {},
"ciscoMgmt.610.94.3.1.15": {},
"ciscoMgmt.610.94.3.1.16": {},
"ciscoMgmt.610.94.3.1.17": {},
"ciscoMgmt.610.94.3.1.18": {},
"ciscoMgmt.610.94.3.1.19": {},
"ciscoMgmt.610.94.3.1.2": {},
"ciscoMgmt.610.94.3.1.3": {},
"ciscoMgmt.610.94.3.1.4": {},
"ciscoMgmt.610.94.3.1.5": {},
"ciscoMgmt.610.94.3.1.6": {},
"ciscoMgmt.610.94.3.1.7": {},
"ciscoMgmt.610.94.3.1.8": {},
"ciscoMgmt.610.94.3.1.9": {},
"ciscoMgmt.10.84.1.2.1.4": {},
"ciscoMgmt.10.84.1.2.1.5": {},
"ciscoMgmt.10.84.1.3.1.2": {},
"ciscoMgmt.10.84.2.1.1.10": {},
"ciscoMgmt.10.84.2.1.1.11": {},
"ciscoMgmt.10.84.2.1.1.12": {},
"ciscoMgmt.10.84.2.1.1.13": {},
"ciscoMgmt.10.84.2.1.1.14": {},
"ciscoMgmt.10.84.2.1.1.15": {},
"ciscoMgmt.10.84.2.1.1.16": {},
"ciscoMgmt.10.84.2.1.1.17": {},
"ciscoMgmt.10.64.1.1.1.2": {},
"ciscoMgmt.10.64.1.1.1.3": {},
"ciscoMgmt.10.64.1.1.1.4": {},
"ciscoMgmt.10.64.1.1.1.5": {},
"ciscoMgmt.10.64.1.1.1.6": {},
"ciscoMgmt.10.64.2.1.1.4": {},
"ciscoMgmt.10.64.2.1.1.5": {},
"ciscoMgmt.10.64.2.1.1.6": {},
"ciscoMgmt.10.64.2.1.1.7": {},
"ciscoMgmt.10.64.2.1.1.8": {},
"ciscoMgmt.10.64.2.1.1.9": {},
"ciscoMgmt.10.64.3.1.1.1": {},
"ciscoMgmt.10.64.3.1.1.2": {},
"ciscoMgmt.10.64.3.1.1.3": {},
"ciscoMgmt.10.64.3.1.1.4": {},
"ciscoMgmt.10.64.3.1.1.5": {},
"ciscoMgmt.10.64.3.1.1.6": {},
"ciscoMgmt.10.64.3.1.1.7": {},
"ciscoMgmt.10.64.3.1.1.8": {},
"ciscoMgmt.10.64.3.1.1.9": {},
"ciscoMgmt.10.64.4.1.1.1": {},
"ciscoMgmt.10.64.4.1.1.10": {},
"ciscoMgmt.10.64.4.1.1.2": {},
"ciscoMgmt.10.64.4.1.1.3": {},
"ciscoMgmt.10.64.4.1.1.4": {},
"ciscoMgmt.10.64.4.1.1.5": {},
"ciscoMgmt.10.64.4.1.1.6": {},
"ciscoMgmt.10.64.4.1.1.7": {},
"ciscoMgmt.10.64.4.1.1.8": {},
"ciscoMgmt.10.64.4.1.1.9": {},
"ciscoMgmt.710.19172.16.17.32.1": {},
"ciscoMgmt.710.19172.16.17.32.10": {},
"ciscoMgmt.710.196.1.1.1.11": {},
"ciscoMgmt.710.196.1.1.1.12": {},
"ciscoMgmt.710.196.1.1.1.2": {},
"ciscoMgmt.710.196.1.1.1.3": {},
"ciscoMgmt.710.196.1.1.1.4": {},
"ciscoMgmt.710.196.1.1.1.5": {},
"ciscoMgmt.710.196.1.1.1.6": {},
"ciscoMgmt.710.196.1.1.1.7": {},
"ciscoMgmt.710.196.1.1.1.8": {},
"ciscoMgmt.710.196.1.1.1.9": {},
"ciscoMgmt.710.196.1.2": {},
"ciscoMgmt.710.196.1.3.1.1": {},
"ciscoMgmt.710.196.1.3.1.10": {},
"ciscoMgmt.710.196.1.3.1.11": {},
"ciscoMgmt.710.196.1.3.1.12": {},
"ciscoMgmt.710.196.1.3.1.2": {},
"ciscoMgmt.710.196.1.3.1.3": {},
"ciscoMgmt.710.196.1.3.1.4": {},
"ciscoMgmt.710.196.1.3.1.5": {},
"ciscoMgmt.710.196.1.3.1.6": {},
"ciscoMgmt.710.196.1.3.1.7": {},
"ciscoMgmt.710.196.1.3.1.8": {},
"ciscoMgmt.710.196.1.3.1.9": {},
"ciscoMgmt.710.84.1.1.1.1": {},
"ciscoMgmt.710.84.1.1.1.10": {},
"ciscoMgmt.710.84.1.1.1.11": {},
"ciscoMgmt.710.84.1.1.1.12": {},
"ciscoMgmt.710.84.1.1.1.2": {},
"ciscoMgmt.710.84.1.1.1.3": {},
"ciscoMgmt.710.84.1.1.1.4": {},
"ciscoMgmt.710.84.1.1.1.5": {},
"ciscoMgmt.710.84.1.1.1.6": {},
"ciscoMgmt.710.84.1.1.1.7": {},
"ciscoMgmt.710.84.1.1.1.8": {},
"ciscoMgmt.710.84.1.1.1.9": {},
"ciscoMgmt.710.84.1.2": {},
"ciscoMgmt.710.84.1.3.1.1": {},
"ciscoMgmt.710.84.1.3.1.10": {},
"ciscoMgmt.710.84.1.3.1.11": {},
"ciscoMgmt.710.84.1.3.1.12": {},
"ciscoMgmt.710.84.1.3.1.2": {},
"ciscoMgmt.710.84.1.3.1.3": {},
"ciscoMgmt.710.84.1.3.1.4": {},
"ciscoMgmt.710.84.1.3.1.5": {},
"ciscoMgmt.710.84.1.3.1.6": {},
"ciscoMgmt.710.84.1.3.1.7": {},
"ciscoMgmt.710.84.1.3.1.8": {},
"ciscoMgmt.710.84.1.3.1.9": {},
"ciscoMgmt.10.16.1.1.1": {},
"ciscoMgmt.10.16.1.1.2": {},
"ciscoMgmt.10.16.1.1.3": {},
"ciscoMgmt.10.16.1.1.4": {},
"ciscoMgmt.10.195.1.1.1": {},
"ciscoMgmt.10.195.1.1.10": {},
"ciscoMgmt.10.195.1.1.11": {},
"ciscoMgmt.10.195.1.1.12": {},
"ciscoMgmt.10.195.1.1.13": {},
"ciscoMgmt.10.195.1.1.14": {},
"ciscoMgmt.10.195.1.1.15": {},
"ciscoMgmt.10.195.1.1.16": {},
"ciscoMgmt.10.195.1.1.17": {},
"ciscoMgmt.10.195.1.1.18": {},
"ciscoMgmt.10.195.1.1.19": {},
"ciscoMgmt.10.195.1.1.2": {},
"ciscoMgmt.10.195.1.1.20": {},
"ciscoMgmt.10.195.1.1.21": {},
"ciscoMgmt.10.195.1.1.22": {},
"ciscoMgmt.10.195.1.1.23": {},
"ciscoMgmt.10.195.1.1.24": {},
"ciscoMgmt.10.195.1.1.3": {},
"ciscoMgmt.10.195.1.1.4": {},
"ciscoMgmt.10.195.1.1.5": {},
"ciscoMgmt.10.195.1.1.6": {},
"ciscoMgmt.10.195.1.1.7": {},
"ciscoMgmt.10.195.1.1.8": {},
"ciscoMgmt.10.195.1.1.9": {},
"ciscoMvpnConfig.1.1.1": {},
"ciscoMvpnConfig.1.1.2": {},
"ciscoMvpnConfig.1.1.3": {},
"ciscoMvpnConfig.1.1.4": {},
"ciscoMvpnConfig.2.1.1": {},
"ciscoMvpnConfig.2.1.2": {},
"ciscoMvpnConfig.2.1.3": {},
"ciscoMvpnConfig.2.1.4": {},
"ciscoMvpnConfig.2.1.5": {},
"ciscoMvpnConfig.2.1.6": {},
"ciscoMvpnGeneric.1.1.1": {},
"ciscoMvpnGeneric.1.1.2": {},
"ciscoMvpnGeneric.1.1.3": {},
"ciscoMvpnGeneric.1.1.4": {},
"ciscoMvpnProtocol.1.1.6": {},
"ciscoMvpnProtocol.1.1.7": {},
"ciscoMvpnProtocol.1.1.8": {},
"ciscoMvpnProtocol.2.1.3": {},
"ciscoMvpnProtocol.2.1.6": {},
"ciscoMvpnProtocol.2.1.7": {},
"ciscoMvpnProtocol.2.1.8": {},
"ciscoMvpnProtocol.2.1.9": {},
"ciscoMvpnProtocol.3.1.5": {},
"ciscoMvpnProtocol.3.1.6": {},
"ciscoMvpnProtocol.4.1.5": {},
"ciscoMvpnProtocol.4.1.6": {},
"ciscoMvpnProtocol.4.1.7": {},
"ciscoMvpnProtocol.5.1.1": {},
"ciscoMvpnProtocol.5.1.2": {},
"ciscoMvpnScalars": {"1": {}, "2": {}},
"ciscoNetflowMIB.1.7.1": {},
"ciscoNetflowMIB.1.7.10": {},
"ciscoNetflowMIB.1.7.11": {},
"ciscoNetflowMIB.1.7.12": {},
"ciscoNetflowMIB.1.7.13": {},
"ciscoNetflowMIB.1.7.14": {},
"ciscoNetflowMIB.1.7.15": {},
"ciscoNetflowMIB.1.7.16": {},
"ciscoNetflowMIB.1.7.17": {},
"ciscoNetflowMIB.1.7.18": {},
"ciscoNetflowMIB.1.7.19": {},
"ciscoNetflowMIB.1.7.2": {},
"ciscoNetflowMIB.1.7.20": {},
"ciscoNetflowMIB.1.7.21": {},
"ciscoNetflowMIB.1.7.22": {},
"ciscoNetflowMIB.1.7.23": {},
"ciscoNetflowMIB.1.7.24": {},
"ciscoNetflowMIB.1.7.25": {},
"ciscoNetflowMIB.1.7.26": {},
"ciscoNetflowMIB.1.7.27": {},
"ciscoNetflowMIB.1.7.28": {},
"ciscoNetflowMIB.1.7.29": {},
"ciscoNetflowMIB.1.7.3": {},
"ciscoNetflowMIB.1.7.30": {},
"ciscoNetflowMIB.1.7.31": {},
"ciscoNetflowMIB.1.7.32": {},
"ciscoNetflowMIB.1.7.33": {},
"ciscoNetflowMIB.1.7.34": {},
"ciscoNetflowMIB.1.7.35": {},
"ciscoNetflowMIB.1.7.36": {},
"ciscoNetflowMIB.1.7.37": {},
"ciscoNetflowMIB.1.7.38": {},
"ciscoNetflowMIB.1.7.4": {},
"ciscoNetflowMIB.1.7.5": {},
"ciscoNetflowMIB.1.7.6": {},
"ciscoNetflowMIB.1.7.7": {},
"ciscoNetflowMIB.10.64.8.1.10": {},
"ciscoNetflowMIB.10.64.8.1.11": {},
"ciscoNetflowMIB.10.64.8.1.12": {},
"ciscoNetflowMIB.10.64.8.1.13": {},
"ciscoNetflowMIB.10.64.8.1.14": {},
"ciscoNetflowMIB.10.64.8.1.15": {},
"ciscoNetflowMIB.10.64.8.1.16": {},
"ciscoNetflowMIB.10.64.8.1.17": {},
"ciscoNetflowMIB.10.64.8.1.18": {},
"ciscoNetflowMIB.10.64.8.1.19": {},
"ciscoNetflowMIB.10.64.8.1.2": {},
"ciscoNetflowMIB.10.64.8.1.20": {},
"ciscoNetflowMIB.10.64.8.1.21": {},
"ciscoNetflowMIB.10.64.8.1.22": {},
"ciscoNetflowMIB.10.64.8.1.23": {},
"ciscoNetflowMIB.10.64.8.1.24": {},
"ciscoNetflowMIB.10.64.8.1.25": {},
"ciscoNetflowMIB.10.64.8.1.26": {},
"ciscoNetflowMIB.10.64.8.1.3": {},
"ciscoNetflowMIB.10.64.8.1.4": {},
"ciscoNetflowMIB.10.64.8.1.5": {},
"ciscoNetflowMIB.10.64.8.1.6": {},
"ciscoNetflowMIB.10.64.8.1.7": {},
"ciscoNetflowMIB.10.64.8.1.8": {},
"ciscoNetflowMIB.10.64.8.1.9": {},
"ciscoNetflowMIB.1.7.9": {},
"ciscoPimMIBNotificationObjects": {"1": {}},
"ciscoPingEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoPppoeMIBObjects.10.9.1.1": {},
"ciscoProcessMIB.10.9.3.1.1": {},
"ciscoProcessMIB.10.9.3.1.10": {},
"ciscoProcessMIB.10.9.3.1.11": {},
"ciscoProcessMIB.10.9.3.1.12": {},
"ciscoProcessMIB.10.9.3.1.13": {},
"ciscoProcessMIB.10.9.3.1.14": {},
"ciscoProcessMIB.10.9.3.1.15": {},
"ciscoProcessMIB.10.9.3.1.16": {},
"ciscoProcessMIB.10.9.3.1.17": {},
"ciscoProcessMIB.10.9.3.1.18": {},
"ciscoProcessMIB.10.9.3.1.19": {},
"ciscoProcessMIB.10.9.3.1.2": {},
"ciscoProcessMIB.10.9.3.1.20": {},
"ciscoProcessMIB.10.9.3.1.21": {},
"ciscoProcessMIB.10.9.3.1.22": {},
"ciscoProcessMIB.10.9.3.1.23": {},
"ciscoProcessMIB.10.9.3.1.24": {},
"ciscoProcessMIB.10.9.3.1.25": {},
"ciscoProcessMIB.10.9.3.1.26": {},
"ciscoProcessMIB.10.9.3.1.27": {},
"ciscoProcessMIB.10.9.3.1.28": {},
"ciscoProcessMIB.10.9.3.1.29": {},
"ciscoProcessMIB.10.9.3.1.3": {},
"ciscoProcessMIB.10.9.3.1.30": {},
"ciscoProcessMIB.10.9.3.1.4": {},
"ciscoProcessMIB.10.9.3.1.5": {},
"ciscoProcessMIB.10.9.3.1.6": {},
"ciscoProcessMIB.10.9.3.1.7": {},
"ciscoProcessMIB.10.9.3.1.8": {},
"ciscoProcessMIB.10.9.3.1.9": {},
"ciscoProcessMIB.10.9.5.1": {},
"ciscoProcessMIB.10.9.5.2": {},
"ciscoSessBorderCtrlrMIBObjects": {
"73": {},
"74": {},
"75": {},
"76": {},
"77": {},
"78": {},
"79": {},
},
"ciscoSipUaMIB.10.4.7.1": {},
"ciscoSipUaMIB.10.4.7.2": {},
"ciscoSipUaMIB.10.4.7.3": {},
"ciscoSipUaMIB.10.4.7.4": {},
"ciscoSipUaMIB.10.9.10.1": {},
"ciscoSipUaMIB.10.9.10.10": {},
"ciscoSipUaMIB.10.9.10.11": {},
"ciscoSipUaMIB.10.9.10.12": {},
"ciscoSipUaMIB.10.9.10.13": {},
"ciscoSipUaMIB.10.9.10.14": {},
"ciscoSipUaMIB.10.9.10.2": {},
"ciscoSipUaMIB.10.9.10.3": {},
"ciscoSipUaMIB.10.9.10.4": {},
"ciscoSipUaMIB.10.9.10.5": {},
"ciscoSipUaMIB.10.9.10.6": {},
"ciscoSipUaMIB.10.9.10.7": {},
"ciscoSipUaMIB.10.9.10.8": {},
"ciscoSipUaMIB.10.9.10.9": {},
"ciscoSipUaMIB.10.9.9.1": {},
"ciscoSnapshotActivityEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ciscoSnapshotInterfaceEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ciscoSnapshotMIB.1.1": {},
"ciscoSyslogMIB.1.2.1": {},
"ciscoSyslogMIB.1.2.2": {},
"ciscoTcpConnEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ciscoVpdnMgmtMIB.0.1": {},
"ciscoVpdnMgmtMIB.0.2": {},
"ciscoVpdnMgmtMIBObjects.10.36.1.2": {},
"ciscoVpdnMgmtMIBObjects.6.1": {},
"ciscoVpdnMgmtMIBObjects.6.2": {},
"ciscoVpdnMgmtMIBObjects.6.3": {},
"ciscoVpdnMgmtMIBObjects.10.100.1.2": {},
"ciscoVpdnMgmtMIBObjects.10.100.1.3": {},
"ciscoVpdnMgmtMIBObjects.10.100.1.4": {},
"ciscoVpdnMgmtMIBObjects.10.100.1.5": {},
"ciscoVpdnMgmtMIBObjects.10.100.1.6": {},
"ciscoVpdnMgmtMIBObjects.10.100.1.7": {},
"ciscoVpdnMgmtMIBObjects.6.5": {},
"ciscoVpdnMgmtMIBObjects.10.144.1.3": {},
"ciscoVpdnMgmtMIBObjects.7.1": {},
"ciscoVpdnMgmtMIBObjects.7.2": {},
"clagAggDistributionAddressMode": {},
"clagAggDistributionProtocol": {},
"clagAggPortAdminStatus": {},
"clagAggProtocolType": {},
"clispExtEidRegMoreSpecificCount": {},
"clispExtEidRegMoreSpecificLimit": {},
"clispExtEidRegMoreSpecificWarningThreshold": {},
"clispExtEidRegRlocMembershipConfigured": {},
"clispExtEidRegRlocMembershipGleaned": {},
"clispExtEidRegRlocMembershipMemberSince": {},
"clispExtFeaturesEidRegMoreSpecificLimit": {},
"clispExtFeaturesEidRegMoreSpecificWarningThreshold": {},
"clispExtFeaturesMapCacheWarningThreshold": {},
"clispExtGlobalStatsEidRegMoreSpecificEntryCount": {},
"clispExtReliableTransportSessionBytesIn": {},
"clispExtReliableTransportSessionBytesOut": {},
"clispExtReliableTransportSessionEstablishmentRole": {},
"clispExtReliableTransportSessionLastStateChangeTime": {},
"clispExtReliableTransportSessionMessagesIn": {},
"clispExtReliableTransportSessionMessagesOut": {},
"clispExtReliableTransportSessionState": {},
"clispExtRlocMembershipConfigured": {},
"clispExtRlocMembershipDiscovered": {},
"clispExtRlocMembershipMemberSince": {},
"clogBasic": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"clogHistoryEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"cmiFaAdvertChallengeChapSPI": {},
"cmiFaAdvertChallengeValue": {},
"cmiFaAdvertChallengeWindow": {},
"cmiFaAdvertIsBusy": {},
"cmiFaAdvertRegRequired": {},
"cmiFaChallengeEnable": {},
"cmiFaChallengeSupported": {},
"cmiFaCoaInterfaceOnly": {},
"cmiFaCoaRegAsymLink": {},
"cmiFaCoaTransmitOnly": {},
"cmiFaCvsesFromHaRejected": {},
"cmiFaCvsesFromMnRejected": {},
"cmiFaDeRegRepliesValidFromHA": {},
"cmiFaDeRegRepliesValidRelayToMN": {},
"cmiFaDeRegRequestsDenied": {},
"cmiFaDeRegRequestsDiscarded": {},
"cmiFaDeRegRequestsReceived": {},
"cmiFaDeRegRequestsRelayed": {},
"cmiFaDeliveryStyleUnsupported": {},
"cmiFaEncapDeliveryStyleSupported": {},
"cmiFaInitRegRepliesValidFromHA": {},
"cmiFaInitRegRepliesValidRelayMN": {},
"cmiFaInitRegRequestsDenied": {},
"cmiFaInitRegRequestsDiscarded": {},
"cmiFaInitRegRequestsReceived": {},
"cmiFaInitRegRequestsRelayed": {},
"cmiFaMissingChallenge": {},
"cmiFaMnAAAAuthFailures": {},
"cmiFaMnFaAuthFailures": {},
"cmiFaMnTooDistant": {},
"cmiFaNvsesFromHaNeglected": {},
"cmiFaNvsesFromMnNeglected": {},
"cmiFaReRegRepliesValidFromHA": {},
"cmiFaReRegRepliesValidRelayToMN": {},
"cmiFaReRegRequestsDenied": {},
"cmiFaReRegRequestsDiscarded": {},
"cmiFaReRegRequestsReceived": {},
"cmiFaReRegRequestsRelayed": {},
"cmiFaRegTotalVisitors": {},
"cmiFaRegVisitorChallengeValue": {},
"cmiFaRegVisitorHomeAddress": {},
"cmiFaRegVisitorHomeAgentAddress": {},
"cmiFaRegVisitorRegFlags": {},
"cmiFaRegVisitorRegFlagsRev1": {},
"cmiFaRegVisitorRegIDHigh": {},
"cmiFaRegVisitorRegIDLow": {},
"cmiFaRegVisitorRegIsAccepted": {},
"cmiFaRegVisitorTimeGranted": {},
"cmiFaRegVisitorTimeRemaining": {},
"cmiFaRevTunnelSupported": {},
"cmiFaReverseTunnelBitNotSet": {},
"cmiFaReverseTunnelEnable": {},
"cmiFaReverseTunnelUnavailable": {},
"cmiFaStaleChallenge": {},
"cmiFaTotalRegReplies": {},
"cmiFaTotalRegRequests": {},
"cmiFaUnknownChallenge": {},
"cmiHaCvsesFromFaRejected": {},
"cmiHaCvsesFromMnRejected": {},
"cmiHaDeRegRequestsAccepted": {},
"cmiHaDeRegRequestsDenied": {},
"cmiHaDeRegRequestsDiscarded": {},
"cmiHaDeRegRequestsReceived": {},
"cmiHaEncapUnavailable": {},
"cmiHaEncapsulationUnavailable": {},
"cmiHaInitRegRequestsAccepted": {},
"cmiHaInitRegRequestsDenied": {},
"cmiHaInitRegRequestsDiscarded": {},
"cmiHaInitRegRequestsReceived": {},
"cmiHaMnAAAAuthFailures": {},
"cmiHaMnHaAuthFailures": {},
"cmiHaMobNetDynamic": {},
"cmiHaMobNetStatus": {},
"cmiHaMrDynamic": {},
"cmiHaMrMultiPath": {},
"cmiHaMrMultiPathMetricType": {},
"cmiHaMrStatus": {},
"cmiHaNAICheckFailures": {},
"cmiHaNvsesFromFaNeglected": {},
"cmiHaNvsesFromMnNeglected": {},
"cmiHaReRegRequestsAccepted": {},
"cmiHaReRegRequestsDenied": {},
"cmiHaReRegRequestsDiscarded": {},
"cmiHaReRegRequestsReceived": {},
"cmiHaRedunDroppedBIAcks": {},
"cmiHaRedunDroppedBIReps": {},
"cmiHaRedunFailedBIReps": {},
"cmiHaRedunFailedBIReqs": {},
"cmiHaRedunFailedBUs": {},
"cmiHaRedunReceivedBIAcks": {},
"cmiHaRedunReceivedBIReps": {},
"cmiHaRedunReceivedBIReqs": {},
"cmiHaRedunReceivedBUAcks": {},
"cmiHaRedunReceivedBUs": {},
"cmiHaRedunSecViolations": {},
"cmiHaRedunSentBIAcks": {},
"cmiHaRedunSentBIReps": {},
"cmiHaRedunSentBIReqs": {},
"cmiHaRedunSentBUAcks": {},
"cmiHaRedunSentBUs": {},
"cmiHaRedunTotalSentBIReps": {},
"cmiHaRedunTotalSentBIReqs": {},
"cmiHaRedunTotalSentBUs": {},
"cmiHaRegAvgTimeRegsProcByAAA": {},
"cmiHaRegDateMaxRegsProcByAAA": {},
"cmiHaRegDateMaxRegsProcLoc": {},
"cmiHaRegMaxProcByAAAInMinRegs": {},
"cmiHaRegMaxProcLocInMinRegs": {},
"cmiHaRegMaxTimeRegsProcByAAA": {},
"cmiHaRegMnIdentifier": {},
"cmiHaRegMnIdentifierType": {},
"cmiHaRegMnIfBandwidth": {},
"cmiHaRegMnIfDescription": {},
"cmiHaRegMnIfID": {},
"cmiHaRegMnIfPathMetricType": {},
"cmiHaRegMobilityBindingRegFlags": {},
"cmiHaRegOverallServTime": {},
"cmiHaRegProcAAAInLastByMinRegs": {},
"cmiHaRegProcLocInLastMinRegs": {},
"cmiHaRegRecentServAcceptedTime": {},
"cmiHaRegRecentServDeniedCode": {},
"cmiHaRegRecentServDeniedTime": {},
"cmiHaRegRequestsDenied": {},
"cmiHaRegRequestsDiscarded": {},
"cmiHaRegRequestsReceived": {},
"cmiHaRegServAcceptedRequests": {},
"cmiHaRegServDeniedRequests": {},
"cmiHaRegTotalMobilityBindings": {},
"cmiHaRegTotalProcByAAARegs": {},
"cmiHaRegTotalProcLocRegs": {},
"cmiHaReverseTunnelBitNotSet": {},
"cmiHaReverseTunnelUnavailable": {},
"cmiHaSystemVersion": {},
"cmiMRIfDescription": {},
"cmiMaAdvAddress": {},
"cmiMaAdvAddressType": {},
"cmiMaAdvMaxAdvLifetime": {},
"cmiMaAdvMaxInterval": {},
"cmiMaAdvMaxRegLifetime": {},
"cmiMaAdvMinInterval": {},
"cmiMaAdvPrefixLengthInclusion": {},
"cmiMaAdvResponseSolicitationOnly": {},
"cmiMaAdvStatus": {},
"cmiMaInterfaceAddress": {},
"cmiMaInterfaceAddressType": {},
"cmiMaRegDateMaxRegsReceived": {},
"cmiMaRegInLastMinuteRegs": {},
"cmiMaRegMaxInMinuteRegs": {},
"cmiMnAdvFlags": {},
"cmiMnRegFlags": {},
"cmiMrBetterIfDetected": {},
"cmiMrCollocatedTunnel": {},
"cmiMrHABest": {},
"cmiMrHAPriority": {},
"cmiMrHaTunnelIfIndex": {},
"cmiMrIfCCoaAddress": {},
"cmiMrIfCCoaAddressType": {},
"cmiMrIfCCoaDefaultGw": {},
"cmiMrIfCCoaDefaultGwType": {},
"cmiMrIfCCoaEnable": {},
"cmiMrIfCCoaOnly": {},
"cmiMrIfCCoaRegRetry": {},
"cmiMrIfCCoaRegRetryRemaining": {},
"cmiMrIfCCoaRegistration": {},
"cmiMrIfHaTunnelIfIndex": {},
"cmiMrIfHoldDown": {},
"cmiMrIfID": {},
"cmiMrIfRegisteredCoA": {},
"cmiMrIfRegisteredCoAType": {},
"cmiMrIfRegisteredMaAddr": {},
"cmiMrIfRegisteredMaAddrType": {},
"cmiMrIfRoamPriority": {},
"cmiMrIfRoamStatus": {},
"cmiMrIfSolicitInterval": {},
"cmiMrIfSolicitPeriodic": {},
"cmiMrIfSolicitRetransCount": {},
"cmiMrIfSolicitRetransCurrent": {},
"cmiMrIfSolicitRetransInitial": {},
"cmiMrIfSolicitRetransLimit": {},
"cmiMrIfSolicitRetransMax": {},
"cmiMrIfSolicitRetransRemaining": {},
"cmiMrIfStatus": {},
"cmiMrMaAdvFlags": {},
"cmiMrMaAdvLifetimeRemaining": {},
"cmiMrMaAdvMaxLifetime": {},
"cmiMrMaAdvMaxRegLifetime": {},
"cmiMrMaAdvRcvIf": {},
"cmiMrMaAdvSequence": {},
"cmiMrMaAdvTimeFirstHeard": {},
"cmiMrMaAdvTimeReceived": {},
"cmiMrMaHoldDownRemaining": {},
"cmiMrMaIfMacAddress": {},
"cmiMrMaIsHa": {},
"cmiMrMobNetAddr": {},
"cmiMrMobNetAddrType": {},
"cmiMrMobNetPfxLen": {},
"cmiMrMobNetStatus": {},
"cmiMrMultiPath": {},
"cmiMrMultiPathMetricType": {},
"cmiMrRedStateActive": {},
"cmiMrRedStatePassive": {},
"cmiMrRedundancyGroup": {},
"cmiMrRegExtendExpire": {},
"cmiMrRegExtendInterval": {},
"cmiMrRegExtendRetry": {},
"cmiMrRegLifetime": {},
"cmiMrRegNewHa": {},
"cmiMrRegRetransInitial": {},
"cmiMrRegRetransLimit": {},
"cmiMrRegRetransMax": {},
"cmiMrReverseTunnel": {},
"cmiMrTunnelBytesRcvd": {},
"cmiMrTunnelBytesSent": {},
"cmiMrTunnelPktsRcvd": {},
"cmiMrTunnelPktsSent": {},
"cmiNtRegCOA": {},
"cmiNtRegCOAType": {},
"cmiNtRegDeniedCode": {},
"cmiNtRegHAAddrType": {},
"cmiNtRegHomeAddress": {},
"cmiNtRegHomeAddressType": {},
"cmiNtRegHomeAgent": {},
"cmiNtRegNAI": {},
"cmiSecAlgorithmMode": {},
"cmiSecAlgorithmType": {},
"cmiSecAssocsCount": {},
"cmiSecKey": {},
"cmiSecKey2": {},
"cmiSecRecentViolationIDHigh": {},
"cmiSecRecentViolationIDLow": {},
"cmiSecRecentViolationReason": {},
"cmiSecRecentViolationSPI": {},
"cmiSecRecentViolationTime": {},
"cmiSecReplayMethod": {},
"cmiSecStatus": {},
"cmiSecTotalViolations": {},
"cmiTrapControl": {},
"cmplsFrrConstEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cmplsFrrFacRouteDBEntry": {"7": {}, "8": {}, "9": {}},
"cmplsFrrMIB.1.1": {},
"cmplsFrrMIB.1.10": {},
"cmplsFrrMIB.1.11": {},
"cmplsFrrMIB.1.12": {},
"cmplsFrrMIB.1.13": {},
"cmplsFrrMIB.1.14": {},
"cmplsFrrMIB.1.2": {},
"cmplsFrrMIB.1.3": {},
"cmplsFrrMIB.1.4": {},
"cmplsFrrMIB.1.5": {},
"cmplsFrrMIB.1.6": {},
"cmplsFrrMIB.1.7": {},
"cmplsFrrMIB.1.8": {},
"cmplsFrrMIB.1.9": {},
"cmplsFrrMIB.10.9.2.1.2": {},
"cmplsFrrMIB.10.9.2.1.3": {},
"cmplsFrrMIB.10.9.2.1.4": {},
"cmplsFrrMIB.10.9.2.1.5": {},
"cmplsFrrMIB.10.9.2.1.6": {},
"cmplsNodeConfigGlobalId": {},
"cmplsNodeConfigIccId": {},
"cmplsNodeConfigNodeId": {},
"cmplsNodeConfigRowStatus": {},
"cmplsNodeConfigStorageType": {},
"cmplsNodeIccMapLocalId": {},
"cmplsNodeIpMapLocalId": {},
"cmplsTunnelExtDestTnlIndex": {},
"cmplsTunnelExtDestTnlLspIndex": {},
"cmplsTunnelExtDestTnlValid": {},
"cmplsTunnelExtOppositeDirTnlValid": {},
"cmplsTunnelOppositeDirPtr": {},
"cmplsTunnelReversePerfBytes": {},
"cmplsTunnelReversePerfErrors": {},
"cmplsTunnelReversePerfHCBytes": {},
"cmplsTunnelReversePerfHCPackets": {},
"cmplsTunnelReversePerfPackets": {},
"cmplsXCExtTunnelPointer": {},
"cmplsXCOppositeDirXCPtr": {},
"cmqCommonCallActiveASPCallReferenceId": {},
"cmqCommonCallActiveASPCallType": {},
"cmqCommonCallActiveASPConnectionId": {},
"cmqCommonCallActiveASPDirEar": {},
"cmqCommonCallActiveASPDirMic": {},
"cmqCommonCallActiveASPEnabledEar": {},
"cmqCommonCallActiveASPEnabledMic": {},
"cmqCommonCallActiveASPMode": {},
"cmqCommonCallActiveASPVer": {},
"cmqCommonCallActiveDurSigASPTriggEar": {},
"cmqCommonCallActiveDurSigASPTriggMic": {},
"cmqCommonCallActiveLongestDurEpiEar": {},
"cmqCommonCallActiveLongestDurEpiMic": {},
"cmqCommonCallActiveLoudestFreqEstForLongEpiEar": {},
"cmqCommonCallActiveLoudestFreqEstForLongEpiMic": {},
"cmqCommonCallActiveNRCallReferenceId": {},
"cmqCommonCallActiveNRCallType": {},
"cmqCommonCallActiveNRConnectionId": {},
"cmqCommonCallActiveNRDirEar": {},
"cmqCommonCallActiveNRDirMic": {},
"cmqCommonCallActiveNREnabledEar": {},
"cmqCommonCallActiveNREnabledMic": {},
"cmqCommonCallActiveNRIntensity": {},
"cmqCommonCallActiveNRLibVer": {},
"cmqCommonCallActiveNumSigASPTriggEar": {},
"cmqCommonCallActiveNumSigASPTriggMic": {},
"cmqCommonCallActivePostNRNoiseFloorEstEar": {},
"cmqCommonCallActivePostNRNoiseFloorEstMic": {},
"cmqCommonCallActivePreNRNoiseFloorEstEar": {},
"cmqCommonCallActivePreNRNoiseFloorEstMic": {},
"cmqCommonCallActiveTotASPDurEar": {},
"cmqCommonCallActiveTotASPDurMic": {},
"cmqCommonCallActiveTotNumASPTriggEar": {},
"cmqCommonCallActiveTotNumASPTriggMic": {},
"cmqCommonCallHistoryASPCallReferenceId": {},
"cmqCommonCallHistoryASPCallType": {},
"cmqCommonCallHistoryASPConnectionId": {},
"cmqCommonCallHistoryASPDirEar": {},
"cmqCommonCallHistoryASPDirMic": {},
"cmqCommonCallHistoryASPEnabledEar": {},
"cmqCommonCallHistoryASPEnabledMic": {},
"cmqCommonCallHistoryASPMode": {},
"cmqCommonCallHistoryASPVer": {},
"cmqCommonCallHistoryDurSigASPTriggEar": {},
"cmqCommonCallHistoryDurSigASPTriggMic": {},
"cmqCommonCallHistoryLongestDurEpiEar": {},
"cmqCommonCallHistoryLongestDurEpiMic": {},
"cmqCommonCallHistoryLoudestFreqEstForLongEpiEar": {},
"cmqCommonCallHistoryLoudestFreqEstForLongEpiMic": {},
"cmqCommonCallHistoryNRCallReferenceId": {},
"cmqCommonCallHistoryNRCallType": {},
"cmqCommonCallHistoryNRConnectionId": {},
"cmqCommonCallHistoryNRDirEar": {},
"cmqCommonCallHistoryNRDirMic": {},
"cmqCommonCallHistoryNREnabledEar": {},
"cmqCommonCallHistoryNREnabledMic": {},
"cmqCommonCallHistoryNRIntensity": {},
"cmqCommonCallHistoryNRLibVer": {},
"cmqCommonCallHistoryNumSigASPTriggEar": {},
"cmqCommonCallHistoryNumSigASPTriggMic": {},
"cmqCommonCallHistoryPostNRNoiseFloorEstEar": {},
"cmqCommonCallHistoryPostNRNoiseFloorEstMic": {},
"cmqCommonCallHistoryPreNRNoiseFloorEstEar": {},
"cmqCommonCallHistoryPreNRNoiseFloorEstMic": {},
"cmqCommonCallHistoryTotASPDurEar": {},
"cmqCommonCallHistoryTotASPDurMic": {},
"cmqCommonCallHistoryTotNumASPTriggEar": {},
"cmqCommonCallHistoryTotNumASPTriggMic": {},
"cmqVideoCallActiveCallReferenceId": {},
"cmqVideoCallActiveConnectionId": {},
"cmqVideoCallActiveRxCompressDegradeAverage": {},
"cmqVideoCallActiveRxCompressDegradeInstant": {},
"cmqVideoCallActiveRxMOSAverage": {},
"cmqVideoCallActiveRxMOSInstant": {},
"cmqVideoCallActiveRxNetworkDegradeAverage": {},
"cmqVideoCallActiveRxNetworkDegradeInstant": {},
"cmqVideoCallActiveRxTransscodeDegradeAverage": {},
"cmqVideoCallActiveRxTransscodeDegradeInstant": {},
"cmqVideoCallHistoryCallReferenceId": {},
"cmqVideoCallHistoryConnectionId": {},
"cmqVideoCallHistoryRxCompressDegradeAverage": {},
"cmqVideoCallHistoryRxMOSAverage": {},
"cmqVideoCallHistoryRxNetworkDegradeAverage": {},
"cmqVideoCallHistoryRxTransscodeDegradeAverage": {},
"cmqVoIPCallActive3550JCallAvg": {},
"cmqVoIPCallActive3550JShortTermAvg": {},
"cmqVoIPCallActiveCallReferenceId": {},
"cmqVoIPCallActiveConnectionId": {},
"cmqVoIPCallActiveRxCallConcealRatioPct": {},
"cmqVoIPCallActiveRxCallDur": {},
"cmqVoIPCallActiveRxCodecId": {},
"cmqVoIPCallActiveRxConcealSec": {},
"cmqVoIPCallActiveRxJBufDlyNow": {},
"cmqVoIPCallActiveRxJBufLowWater": {},
"cmqVoIPCallActiveRxJBufMode": {},
"cmqVoIPCallActiveRxJBufNomDelay": {},
"cmqVoIPCallActiveRxJBuffHiWater": {},
"cmqVoIPCallActiveRxPktCntComfortNoise": {},
"cmqVoIPCallActiveRxPktCntDiscarded": {},
"cmqVoIPCallActiveRxPktCntEffLoss": {},
"cmqVoIPCallActiveRxPktCntExpected": {},
"cmqVoIPCallActiveRxPktCntNotArrived": {},
"cmqVoIPCallActiveRxPktCntUnusableLate": {},
"cmqVoIPCallActiveRxPktLossConcealDur": {},
"cmqVoIPCallActiveRxPktLossRatioPct": {},
"cmqVoIPCallActiveRxPred107CodecBPL": {},
"cmqVoIPCallActiveRxPred107CodecIeBase": {},
"cmqVoIPCallActiveRxPred107DefaultR0": {},
"cmqVoIPCallActiveRxPred107Idd": {},
"cmqVoIPCallActiveRxPred107IeEff": {},
"cmqVoIPCallActiveRxPred107RMosConv": {},
"cmqVoIPCallActiveRxPred107RMosListen": {},
"cmqVoIPCallActiveRxPred107RScoreConv": {},
"cmqVoIPCallActiveRxPred107Rscore": {},
"cmqVoIPCallActiveRxPredMosLqoAvg": {},
"cmqVoIPCallActiveRxPredMosLqoBaseline": {},
"cmqVoIPCallActiveRxPredMosLqoBursts": {},
"cmqVoIPCallActiveRxPredMosLqoFrLoss": {},
"cmqVoIPCallActiveRxPredMosLqoMin": {},
"cmqVoIPCallActiveRxPredMosLqoNumWin": {},
"cmqVoIPCallActiveRxPredMosLqoRecent": {},
"cmqVoIPCallActiveRxPredMosLqoVerID": {},
"cmqVoIPCallActiveRxRoundTripTime": {},
"cmqVoIPCallActiveRxSevConcealRatioPct": {},
"cmqVoIPCallActiveRxSevConcealSec": {},
"cmqVoIPCallActiveRxSignalLvl": {},
"cmqVoIPCallActiveRxUnimpairedSecOK": {},
"cmqVoIPCallActiveRxVoiceDur": {},
"cmqVoIPCallActiveTxCodecId": {},
"cmqVoIPCallActiveTxNoiseFloor": {},
"cmqVoIPCallActiveTxSignalLvl": {},
"cmqVoIPCallActiveTxTmrActSpeechDur": {},
"cmqVoIPCallActiveTxTmrCallDur": {},
"cmqVoIPCallActiveTxVadEnabled": {},
"cmqVoIPCallHistory3550JCallAvg": {},
"cmqVoIPCallHistory3550JShortTermAvg": {},
"cmqVoIPCallHistoryCallReferenceId": {},
"cmqVoIPCallHistoryConnectionId": {},
"cmqVoIPCallHistoryRxCallConcealRatioPct": {},
"cmqVoIPCallHistoryRxCallDur": {},
"cmqVoIPCallHistoryRxCodecId": {},
"cmqVoIPCallHistoryRxConcealSec": {},
"cmqVoIPCallHistoryRxJBufDlyNow": {},
"cmqVoIPCallHistoryRxJBufLowWater": {},
"cmqVoIPCallHistoryRxJBufMode": {},
"cmqVoIPCallHistoryRxJBufNomDelay": {},
"cmqVoIPCallHistoryRxJBuffHiWater": {},
"cmqVoIPCallHistoryRxPktCntComfortNoise": {},
"cmqVoIPCallHistoryRxPktCntDiscarded": {},
"cmqVoIPCallHistoryRxPktCntEffLoss": {},
"cmqVoIPCallHistoryRxPktCntExpected": {},
"cmqVoIPCallHistoryRxPktCntNotArrived": {},
"cmqVoIPCallHistoryRxPktCntUnusableLate": {},
"cmqVoIPCallHistoryRxPktLossConcealDur": {},
"cmqVoIPCallHistoryRxPktLossRatioPct": {},
"cmqVoIPCallHistoryRxPred107CodecBPL": {},
"cmqVoIPCallHistoryRxPred107CodecIeBase": {},
"cmqVoIPCallHistoryRxPred107DefaultR0": {},
"cmqVoIPCallHistoryRxPred107Idd": {},
"cmqVoIPCallHistoryRxPred107IeEff": {},
"cmqVoIPCallHistoryRxPred107RMosConv": {},
"cmqVoIPCallHistoryRxPred107RMosListen": {},
"cmqVoIPCallHistoryRxPred107RScoreConv": {},
"cmqVoIPCallHistoryRxPred107Rscore": {},
"cmqVoIPCallHistoryRxPredMosLqoAvg": {},
"cmqVoIPCallHistoryRxPredMosLqoBaseline": {},
"cmqVoIPCallHistoryRxPredMosLqoBursts": {},
"cmqVoIPCallHistoryRxPredMosLqoFrLoss": {},
"cmqVoIPCallHistoryRxPredMosLqoMin": {},
"cmqVoIPCallHistoryRxPredMosLqoNumWin": {},
"cmqVoIPCallHistoryRxPredMosLqoRecent": {},
"cmqVoIPCallHistoryRxPredMosLqoVerID": {},
"cmqVoIPCallHistoryRxRoundTripTime": {},
"cmqVoIPCallHistoryRxSevConcealRatioPct": {},
"cmqVoIPCallHistoryRxSevConcealSec": {},
"cmqVoIPCallHistoryRxSignalLvl": {},
"cmqVoIPCallHistoryRxUnimpairedSecOK": {},
"cmqVoIPCallHistoryRxVoiceDur": {},
"cmqVoIPCallHistoryTxCodecId": {},
"cmqVoIPCallHistoryTxNoiseFloor": {},
"cmqVoIPCallHistoryTxSignalLvl": {},
"cmqVoIPCallHistoryTxTmrActSpeechDur": {},
"cmqVoIPCallHistoryTxTmrCallDur": {},
"cmqVoIPCallHistoryTxVadEnabled": {},
"cnatAddrBindCurrentIdleTime": {},
"cnatAddrBindDirection": {},
"cnatAddrBindGlobalAddr": {},
"cnatAddrBindId": {},
"cnatAddrBindInTranslate": {},
"cnatAddrBindNumberOfEntries": {},
"cnatAddrBindOutTranslate": {},
"cnatAddrBindType": {},
"cnatAddrPortBindCurrentIdleTime": {},
"cnatAddrPortBindDirection": {},
"cnatAddrPortBindGlobalAddr": {},
"cnatAddrPortBindGlobalPort": {},
"cnatAddrPortBindId": {},
"cnatAddrPortBindInTranslate": {},
"cnatAddrPortBindNumberOfEntries": {},
"cnatAddrPortBindOutTranslate": {},
"cnatAddrPortBindType": {},
"cnatInterfaceRealm": {},
"cnatInterfaceStatus": {},
"cnatInterfaceStorageType": {},
"cnatProtocolStatsInTranslate": {},
"cnatProtocolStatsOutTranslate": {},
"cnatProtocolStatsRejectCount": {},
"cndeCollectorStatus": {},
"cndeMaxCollectors": {},
"cneClientStatRedirectRx": {},
"cneNotifEnable": {},
"cneServerStatRedirectTx": {},
"cnfCIBridgedFlowStatsCtrlEntry": {"2": {}, "3": {}},
"cnfCICacheEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cnfCIInterfaceEntry": {"1": {}, "2": {}},
"cnfCacheInfo": {"4": {}},
"cnfEICollectorEntry": {"4": {}},
"cnfEIExportInfoEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"cnfExportInfo": {"2": {}},
"cnfExportStatistics": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"cnfExportTemplate": {"1": {}},
"cnfPSProtocolStatEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"cnfProtocolStatistics": {"1": {}, "2": {}},
"cnfTemplateEntry": {"2": {}, "3": {}, "4": {}},
"cnfTemplateExportInfoEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"cnpdAllStatsEntry": {
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cnpdNotificationsConfig": {"1": {}},
"cnpdStatusEntry": {"1": {}, "2": {}},
"cnpdSupportedProtocolsEntry": {"2": {}},
"cnpdThresholdConfigEntry": {
"10": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cnpdThresholdHistoryEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"cnpdTopNConfigEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"cnpdTopNStatsEntry": {"2": {}, "3": {}, "4": {}},
"cnsClkSelGlobClockMode": {},
"cnsClkSelGlobCurrHoldoverSeconds": {},
"cnsClkSelGlobEECOption": {},
"cnsClkSelGlobESMCMode": {},
"cnsClkSelGlobHoldoffTime": {},
"cnsClkSelGlobLastHoldoverSeconds": {},
"cnsClkSelGlobNetsyncEnable": {},
"cnsClkSelGlobNetworkOption": {},
"cnsClkSelGlobNofSources": {},
"cnsClkSelGlobProcessMode": {},
"cnsClkSelGlobRevertiveMode": {},
"cnsClkSelGlobWtrTime": {},
"cnsExtOutFSW": {},
"cnsExtOutIntfType": {},
"cnsExtOutMSW": {},
"cnsExtOutName": {},
"cnsExtOutPriority": {},
"cnsExtOutQualityLevel": {},
"cnsExtOutSelNetsyncIndex": {},
"cnsExtOutSquelch": {},
"cnsInpSrcAlarm": {},
"cnsInpSrcAlarmInfo": {},
"cnsInpSrcESMCCap": {},
"cnsInpSrcFSW": {},
"cnsInpSrcHoldoffTime": {},
"cnsInpSrcIntfType": {},
"cnsInpSrcLockout": {},
"cnsInpSrcMSW": {},
"cnsInpSrcName": {},
"cnsInpSrcPriority": {},
"cnsInpSrcQualityLevel": {},
"cnsInpSrcQualityLevelRx": {},
"cnsInpSrcQualityLevelRxCfg": {},
"cnsInpSrcQualityLevelTx": {},
"cnsInpSrcQualityLevelTxCfg": {},
"cnsInpSrcSSMCap": {},
"cnsInpSrcSignalFailure": {},
"cnsInpSrcWtrTime": {},
"cnsMIBEnableStatusNotification": {},
"cnsSelInpSrcFSW": {},
"cnsSelInpSrcIntfType": {},
"cnsSelInpSrcMSW": {},
"cnsSelInpSrcName": {},
"cnsSelInpSrcPriority": {},
"cnsSelInpSrcQualityLevel": {},
"cnsSelInpSrcTimestamp": {},
"cnsT4ClkSrcAlarm": {},
"cnsT4ClkSrcAlarmInfo": {},
"cnsT4ClkSrcESMCCap": {},
"cnsT4ClkSrcFSW": {},
"cnsT4ClkSrcHoldoffTime": {},
"cnsT4ClkSrcIntfType": {},
"cnsT4ClkSrcLockout": {},
"cnsT4ClkSrcMSW": {},
"cnsT4ClkSrcName": {},
"cnsT4ClkSrcPriority": {},
"cnsT4ClkSrcQualityLevel": {},
"cnsT4ClkSrcQualityLevelRx": {},
"cnsT4ClkSrcQualityLevelRxCfg": {},
"cnsT4ClkSrcQualityLevelTx": {},
"cnsT4ClkSrcQualityLevelTxCfg": {},
"cnsT4ClkSrcSSMCap": {},
"cnsT4ClkSrcSignalFailure": {},
"cnsT4ClkSrcWtrTime": {},
"cntpFilterRegisterEntry": {"2": {}, "3": {}, "4": {}},
"cntpPeersVarEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cntpSystem": {
"1": {},
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"coiFECCurrentCorBitErrs": {},
"coiFECCurrentCorByteErrs": {},
"coiFECCurrentDetOneErrs": {},
"coiFECCurrentDetZeroErrs": {},
"coiFECCurrentUncorWords": {},
"coiFECIntervalCorBitErrs": {},
"coiFECIntervalCorByteErrs": {},
"coiFECIntervalDetOneErrs": {},
"coiFECIntervalDetZeroErrs": {},
"coiFECIntervalUncorWords": {},
"coiFECIntervalValidData": {},
"coiFECThreshStatus": {},
"coiFECThreshStorageType": {},
"coiFECThreshValue": {},
"coiIfControllerFECMode": {},
"coiIfControllerFECValidIntervals": {},
"coiIfControllerLaserAdminStatus": {},
"coiIfControllerLaserOperStatus": {},
"coiIfControllerLoopback": {},
"coiIfControllerOTNValidIntervals": {},
"coiIfControllerOtnStatus": {},
"coiIfControllerPreFECBERExponent": {},
"coiIfControllerPreFECBERMantissa": {},
"coiIfControllerQFactor": {},
"coiIfControllerQMargin": {},
"coiIfControllerTDCOperMode": {},
"coiIfControllerTDCOperSetting": {},
"coiIfControllerTDCOperStatus": {},
"coiIfControllerWavelength": {},
"coiOtnFarEndCurrentBBERs": {},
"coiOtnFarEndCurrentBBEs": {},
"coiOtnFarEndCurrentESRs": {},
"coiOtnFarEndCurrentESs": {},
"coiOtnFarEndCurrentFCs": {},
"coiOtnFarEndCurrentSESRs": {},
"coiOtnFarEndCurrentSESs": {},
"coiOtnFarEndCurrentUASs": {},
"coiOtnFarEndIntervalBBERs": {},
"coiOtnFarEndIntervalBBEs": {},
"coiOtnFarEndIntervalESRs": {},
"coiOtnFarEndIntervalESs": {},
"coiOtnFarEndIntervalFCs": {},
"coiOtnFarEndIntervalSESRs": {},
"coiOtnFarEndIntervalSESs": {},
"coiOtnFarEndIntervalUASs": {},
"coiOtnFarEndIntervalValidData": {},
"coiOtnFarEndThreshStatus": {},
"coiOtnFarEndThreshStorageType": {},
"coiOtnFarEndThreshValue": {},
"coiOtnIfNotifEnabled": {},
"coiOtnIfODUStatus": {},
"coiOtnIfOTUStatus": {},
"coiOtnNearEndCurrentBBERs": {},
"coiOtnNearEndCurrentBBEs": {},
"coiOtnNearEndCurrentESRs": {},
"coiOtnNearEndCurrentESs": {},
"coiOtnNearEndCurrentFCs": {},
"coiOtnNearEndCurrentSESRs": {},
"coiOtnNearEndCurrentSESs": {},
"coiOtnNearEndCurrentUASs": {},
"coiOtnNearEndIntervalBBERs": {},
"coiOtnNearEndIntervalBBEs": {},
"coiOtnNearEndIntervalESRs": {},
"coiOtnNearEndIntervalESs": {},
"coiOtnNearEndIntervalFCs": {},
"coiOtnNearEndIntervalSESRs": {},
"coiOtnNearEndIntervalSESs": {},
"coiOtnNearEndIntervalUASs": {},
"coiOtnNearEndIntervalValidData": {},
"coiOtnNearEndThreshStatus": {},
"coiOtnNearEndThreshStorageType": {},
"coiOtnNearEndThreshValue": {},
"convQllcAdminEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"convQllcOperEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"convSdllcAddrEntry": {"2": {}, "3": {}, "4": {}, "5": {}},
"convSdllcPortEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
},
"cospfAreaEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"cospfGeneralGroup": {"5": {}},
"cospfIfEntry": {"1": {}, "2": {}},
"cospfLocalLsdbEntry": {"6": {}, "7": {}, "8": {}, "9": {}},
"cospfLsdbEntry": {"2": {}, "3": {}, "4": {}, "5": {}},
"cospfShamLinkEntry": {"4": {}, "5": {}, "6": {}, "7": {}, "8": {}, "9": {}},
"cospfShamLinkNbrEntry": {"4": {}, "5": {}, "6": {}, "7": {}, "8": {}, "9": {}},
"cospfShamLinksEntry": {"10": {}, "11": {}, "6": {}, "7": {}, "8": {}, "9": {}},
"cospfTrapControl": {"1": {}, "2": {}, "3": {}, "4": {}},
"cospfVirtIfEntry": {"1": {}, "2": {}},
"cospfVirtLocalLsdbEntry": {"6": {}, "7": {}, "8": {}, "9": {}},
"cpfrActiveProbeAdminStatus": {},
"cpfrActiveProbeAssignedPfxAddress": {},
"cpfrActiveProbeAssignedPfxAddressType": {},
"cpfrActiveProbeAssignedPfxLen": {},
"cpfrActiveProbeCodecName": {},
"cpfrActiveProbeDscpValue": {},
"cpfrActiveProbeMapIndex": {},
"cpfrActiveProbeMapPolicyIndex": {},
"cpfrActiveProbeMethod": {},
"cpfrActiveProbeOperStatus": {},
"cpfrActiveProbePfrMapIndex": {},
"cpfrActiveProbeRowStatus": {},
"cpfrActiveProbeStorageType": {},
"cpfrActiveProbeTargetAddress": {},
"cpfrActiveProbeTargetAddressType": {},
"cpfrActiveProbeTargetPortNumber": {},
"cpfrActiveProbeType": {},
"cpfrBRAddress": {},
"cpfrBRAddressType": {},
"cpfrBRAuthFailCount": {},
"cpfrBRConnFailureReason": {},
"cpfrBRConnStatus": {},
"cpfrBRKeyName": {},
"cpfrBROperStatus": {},
"cpfrBRRowStatus": {},
"cpfrBRStorageType": {},
"cpfrBRUpTime": {},
"cpfrDowngradeBgpCommunity": {},
"cpfrExitCapacity": {},
"cpfrExitCost1": {},
"cpfrExitCost2": {},
"cpfrExitCost3": {},
"cpfrExitCostCalcMethod": {},
"cpfrExitCostDiscard": {},
"cpfrExitCostDiscardAbsolute": {},
"cpfrExitCostDiscardPercent": {},
"cpfrExitCostDiscardType": {},
"cpfrExitCostEndDayOfMonth": {},
"cpfrExitCostEndOffset": {},
"cpfrExitCostEndOffsetType": {},
"cpfrExitCostFixedFeeCost": {},
"cpfrExitCostNickName": {},
"cpfrExitCostRollupPeriod": {},
"cpfrExitCostSamplingPeriod": {},
"cpfrExitCostSummerTimeEnd": {},
"cpfrExitCostSummerTimeOffset": {},
"cpfrExitCostSummerTimeStart": {},
"cpfrExitCostTierFee": {},
"cpfrExitCostTierRowStatus": {},
"cpfrExitCostTierStorageType": {},
"cpfrExitMaxUtilRxAbsolute": {},
"cpfrExitMaxUtilRxPercentage": {},
"cpfrExitMaxUtilRxType": {},
"cpfrExitMaxUtilTxAbsolute": {},
"cpfrExitMaxUtilTxPercentage": {},
"cpfrExitMaxUtilTxType": {},
"cpfrExitName": {},
"cpfrExitNickName": {},
"cpfrExitOperStatus": {},
"cpfrExitRollupCollected": {},
"cpfrExitRollupCumRxBytes": {},
"cpfrExitRollupCumTxBytes": {},
"cpfrExitRollupCurrentTgtUtil": {},
"cpfrExitRollupDiscard": {},
"cpfrExitRollupLeft": {},
"cpfrExitRollupMomTgtUtil": {},
"cpfrExitRollupStartingTgtUtil": {},
"cpfrExitRollupTimeRemain": {},
"cpfrExitRollupTotal": {},
"cpfrExitRowStatus": {},
"cpfrExitRsvpBandwidthPool": {},
"cpfrExitRxBandwidth": {},
"cpfrExitRxLoad": {},
"cpfrExitStorageType": {},
"cpfrExitSustainedUtil1": {},
"cpfrExitSustainedUtil2": {},
"cpfrExitSustainedUtil3": {},
"cpfrExitTxBandwidth": {},
"cpfrExitTxLoad": {},
"cpfrExitType": {},
"cpfrLearnAggAccesslistName": {},
"cpfrLearnAggregationPrefixLen": {},
"cpfrLearnAggregationType": {},
"cpfrLearnExpireSessionNum": {},
"cpfrLearnExpireTime": {},
"cpfrLearnExpireType": {},
"cpfrLearnFilterAccessListName": {},
"cpfrLearnListAclFilterPfxName": {},
"cpfrLearnListAclName": {},
"cpfrLearnListMethod": {},
"cpfrLearnListNbarAppl": {},
"cpfrLearnListPfxInside": {},
"cpfrLearnListPfxName": {},
"cpfrLearnListReferenceName": {},
"cpfrLearnListRowStatus": {},
"cpfrLearnListSequenceNum": {},
"cpfrLearnListStorageType": {},
"cpfrLearnMethod": {},
"cpfrLearnMonitorPeriod": {},
"cpfrLearnPeriodInterval": {},
"cpfrLearnPrefixesNumber": {},
"cpfrLinkGroupBRIndex": {},
"cpfrLinkGroupExitEntry": {"6": {}, "7": {}},
"cpfrLinkGroupExitIndex": {},
"cpfrLinkGroupRowStatus": {},
"cpfrMCAdminStatus": {},
"cpfrMCConnStatus": {},
"cpfrMCEntranceLinksMaxUtil": {},
"cpfrMCEntry": {"26": {}, "27": {}, "28": {}, "29": {}, "30": {}},
"cpfrMCExitLinksMaxUtil": {},
"cpfrMCKeepAliveTimer": {},
"cpfrMCLearnState": {},
"cpfrMCLearnStateTimeRemain": {},
"cpfrMCMapIndex": {},
"cpfrMCMaxPrefixLearn": {},
"cpfrMCMaxPrefixTotal": {},
"cpfrMCNetflowExporter": {},
"cpfrMCNumofBorderRouters": {},
"cpfrMCNumofExits": {},
"cpfrMCOperStatus": {},
"cpfrMCPbrMet": {},
"cpfrMCPortNumber": {},
"cpfrMCPrefixConfigured": {},
"cpfrMCPrefixCount": {},
"cpfrMCPrefixLearned": {},
"cpfrMCResolveMapPolicyIndex": {},
"cpfrMCResolvePolicyType": {},
"cpfrMCResolvePriority": {},
"cpfrMCResolveRowStatus": {},
"cpfrMCResolveStorageType": {},
"cpfrMCResolveVariance": {},
"cpfrMCRowStatus": {},
"cpfrMCRsvpPostDialDelay": {},
"cpfrMCRsvpSignalingRetries": {},
"cpfrMCStorageType": {},
"cpfrMCTracerouteProbeDelay": {},
"cpfrMapActiveProbeFrequency": {},
"cpfrMapActiveProbePackets": {},
"cpfrMapBackoffMaxTimer": {},
"cpfrMapBackoffMinTimer": {},
"cpfrMapBackoffStepTimer": {},
"cpfrMapDelayRelativePercent": {},
"cpfrMapDelayThresholdMax": {},
"cpfrMapDelayType": {},
"cpfrMapEntry": {"38": {}, "39": {}, "40": {}},
"cpfrMapFallbackLinkGroupName": {},
"cpfrMapHolddownTimer": {},
"cpfrMapJitterThresholdMax": {},
"cpfrMapLinkGroupName": {},
"cpfrMapLossRelativeAvg": {},
"cpfrMapLossThresholdMax": {},
"cpfrMapLossType": {},
"cpfrMapModeMonitor": {},
"cpfrMapModeRouteOpts": {},
"cpfrMapModeSelectExitType": {},
"cpfrMapMossPercentage": {},
"cpfrMapMossThresholdMin": {},
"cpfrMapName": {},
"cpfrMapNextHopAddress": {},
"cpfrMapNextHopAddressType": {},
"cpfrMapPeriodicTimer": {},
"cpfrMapPrefixForwardInterface": {},
"cpfrMapRoundRobinResolver": {},
"cpfrMapRouteMetricBgpLocalPref": {},
"cpfrMapRouteMetricEigrpTagCommunity": {},
"cpfrMapRouteMetricStaticTag": {},
"cpfrMapRowStatus": {},
"cpfrMapStorageType": {},
"cpfrMapTracerouteReporting": {},
"cpfrMapUnreachableRelativeAvg": {},
"cpfrMapUnreachableThresholdMax": {},
"cpfrMapUnreachableType": {},
"cpfrMatchAddrAccessList": {},
"cpfrMatchAddrPrefixInside": {},
"cpfrMatchAddrPrefixList": {},
"cpfrMatchLearnListName": {},
"cpfrMatchLearnMode": {},
"cpfrMatchTCAccessListName": {},
"cpfrMatchTCNbarApplPfxList": {},
"cpfrMatchTCNbarListName": {},
"cpfrMatchValid": {},
"cpfrNbarApplListRowStatus": {},
"cpfrNbarApplListStorageType": {},
"cpfrNbarApplPdIndex": {},
"cpfrResolveMapIndex": {},
"cpfrTCBRExitIndex": {},
"cpfrTCBRIndex": {},
"cpfrTCDscpValue": {},
"cpfrTCDstMaxPort": {},
"cpfrTCDstMinPort": {},
"cpfrTCDstPrefix": {},
"cpfrTCDstPrefixLen": {},
"cpfrTCDstPrefixType": {},
"cpfrTCMActiveLTDelayAvg": {},
"cpfrTCMActiveLTUnreachableAvg": {},
"cpfrTCMActiveSTDelayAvg": {},
"cpfrTCMActiveSTJitterAvg": {},
"cpfrTCMActiveSTUnreachableAvg": {},
"cpfrTCMAge": {},
"cpfrTCMAttempts": {},
"cpfrTCMLastUpdateTime": {},
"cpfrTCMMOSPercentage": {},
"cpfrTCMPackets": {},
"cpfrTCMPassiveLTDelayAvg": {},
"cpfrTCMPassiveLTLossAvg": {},
"cpfrTCMPassiveLTUnreachableAvg": {},
"cpfrTCMPassiveSTDelayAvg": {},
"cpfrTCMPassiveSTLossAvg": {},
"cpfrTCMPassiveSTUnreachableAvg": {},
"cpfrTCMapIndex": {},
"cpfrTCMapPolicyIndex": {},
"cpfrTCMetricsValid": {},
"cpfrTCNbarApplication": {},
"cpfrTCProtocol": {},
"cpfrTCSControlBy": {},
"cpfrTCSControlState": {},
"cpfrTCSLastOOPEventTime": {},
"cpfrTCSLastOOPReason": {},
"cpfrTCSLastRouteChangeEvent": {},
"cpfrTCSLastRouteChangeReason": {},
"cpfrTCSLearnListIndex": {},
"cpfrTCSTimeOnCurrExit": {},
"cpfrTCSTimeRemainCurrState": {},
"cpfrTCSType": {},
"cpfrTCSrcMaxPort": {},
"cpfrTCSrcMinPort": {},
"cpfrTCSrcPrefix": {},
"cpfrTCSrcPrefixLen": {},
"cpfrTCSrcPrefixType": {},
"cpfrTCStatus": {},
"cpfrTrafficClassValid": {},
"cpim": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cpmCPUHistoryTable.1.2": {},
"cpmCPUHistoryTable.1.3": {},
"cpmCPUHistoryTable.1.4": {},
"cpmCPUHistoryTable.1.5": {},
"cpmCPUProcessHistoryTable.1.2": {},
"cpmCPUProcessHistoryTable.1.3": {},
"cpmCPUProcessHistoryTable.1.4": {},
"cpmCPUProcessHistoryTable.1.5": {},
"cpmCPUThresholdTable.1.2": {},
"cpmCPUThresholdTable.1.3": {},
"cpmCPUThresholdTable.1.4": {},
"cpmCPUThresholdTable.1.5": {},
"cpmCPUThresholdTable.1.6": {},
"cpmCPUTotalTable.1.10": {},
"cpmCPUTotalTable.1.11": {},
"cpmCPUTotalTable.1.12": {},
"cpmCPUTotalTable.1.13": {},
"cpmCPUTotalTable.1.14": {},
"cpmCPUTotalTable.1.15": {},
"cpmCPUTotalTable.1.16": {},
"cpmCPUTotalTable.1.17": {},
"cpmCPUTotalTable.1.18": {},
"cpmCPUTotalTable.1.19": {},
"cpmCPUTotalTable.1.2": {},
"cpmCPUTotalTable.1.20": {},
"cpmCPUTotalTable.1.21": {},
"cpmCPUTotalTable.1.22": {},
"cpmCPUTotalTable.1.23": {},
"cpmCPUTotalTable.1.24": {},
"cpmCPUTotalTable.1.25": {},
"cpmCPUTotalTable.1.26": {},
"cpmCPUTotalTable.1.27": {},
"cpmCPUTotalTable.1.28": {},
"cpmCPUTotalTable.1.29": {},
"cpmCPUTotalTable.1.3": {},
"cpmCPUTotalTable.1.4": {},
"cpmCPUTotalTable.1.5": {},
"cpmCPUTotalTable.1.6": {},
"cpmCPUTotalTable.1.7": {},
"cpmCPUTotalTable.1.8": {},
"cpmCPUTotalTable.1.9": {},
"cpmProcessExtTable.1.1": {},
"cpmProcessExtTable.1.2": {},
"cpmProcessExtTable.1.3": {},
"cpmProcessExtTable.1.4": {},
"cpmProcessExtTable.1.5": {},
"cpmProcessExtTable.1.6": {},
"cpmProcessExtTable.1.7": {},
"cpmProcessExtTable.1.8": {},
"cpmProcessTable.1.1": {},
"cpmProcessTable.1.2": {},
"cpmProcessTable.1.4": {},
"cpmProcessTable.1.5": {},
"cpmProcessTable.1.6": {},
"cpmThreadTable.1.2": {},
"cpmThreadTable.1.3": {},
"cpmThreadTable.1.4": {},
"cpmThreadTable.1.5": {},
"cpmThreadTable.1.6": {},
"cpmThreadTable.1.7": {},
"cpmThreadTable.1.8": {},
"cpmThreadTable.1.9": {},
"cpmVirtualProcessTable.1.10": {},
"cpmVirtualProcessTable.1.11": {},
"cpmVirtualProcessTable.1.12": {},
"cpmVirtualProcessTable.1.13": {},
"cpmVirtualProcessTable.1.2": {},
"cpmVirtualProcessTable.1.3": {},
"cpmVirtualProcessTable.1.4": {},
"cpmVirtualProcessTable.1.5": {},
"cpmVirtualProcessTable.1.6": {},
"cpmVirtualProcessTable.1.7": {},
"cpmVirtualProcessTable.1.8": {},
"cpmVirtualProcessTable.1.9": {},
"cpwAtmAvgCellsPacked": {},
"cpwAtmCellPacking": {},
"cpwAtmCellsReceived": {},
"cpwAtmCellsRejected": {},
"cpwAtmCellsSent": {},
"cpwAtmCellsTagged": {},
"cpwAtmClpQosMapping": {},
"cpwAtmEncap": {},
"cpwAtmHCCellsReceived": {},
"cpwAtmHCCellsRejected": {},
"cpwAtmHCCellsTagged": {},
"cpwAtmIf": {},
"cpwAtmMcptTimeout": {},
"cpwAtmMncp": {},
"cpwAtmOamCellSupported": {},
"cpwAtmPeerMncp": {},
"cpwAtmPktsReceived": {},
"cpwAtmPktsRejected": {},
"cpwAtmPktsSent": {},
"cpwAtmQosScalingFactor": {},
"cpwAtmRowStatus": {},
"cpwAtmVci": {},
"cpwAtmVpi": {},
"cpwVcAdminStatus": {},
"cpwVcControlWord": {},
"cpwVcCreateTime": {},
"cpwVcDescr": {},
"cpwVcHoldingPriority": {},
"cpwVcID": {},
"cpwVcIdMappingVcIndex": {},
"cpwVcInboundMode": {},
"cpwVcInboundOperStatus": {},
"cpwVcInboundVcLabel": {},
"cpwVcIndexNext": {},
"cpwVcLocalGroupID": {},
"cpwVcLocalIfMtu": {},
"cpwVcLocalIfString": {},
"cpwVcMplsEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"cpwVcMplsInboundEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cpwVcMplsMIB.1.2": {},
"cpwVcMplsMIB.1.4": {},
"cpwVcMplsNonTeMappingEntry": {"4": {}},
"cpwVcMplsOutboundEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cpwVcMplsTeMappingEntry": {"6": {}},
"cpwVcName": {},
"cpwVcNotifRate": {},
"cpwVcOperStatus": {},
"cpwVcOutboundOperStatus": {},
"cpwVcOutboundVcLabel": {},
"cpwVcOwner": {},
"cpwVcPeerAddr": {},
"cpwVcPeerAddrType": {},
"cpwVcPeerMappingVcIndex": {},
"cpwVcPerfCurrentInHCBytes": {},
"cpwVcPerfCurrentInHCPackets": {},
"cpwVcPerfCurrentOutHCBytes": {},
"cpwVcPerfCurrentOutHCPackets": {},
"cpwVcPerfIntervalInHCBytes": {},
"cpwVcPerfIntervalInHCPackets": {},
"cpwVcPerfIntervalOutHCBytes": {},
"cpwVcPerfIntervalOutHCPackets": {},
"cpwVcPerfIntervalTimeElapsed": {},
"cpwVcPerfIntervalValidData": {},
"cpwVcPerfTotalDiscontinuityTime": {},
"cpwVcPerfTotalErrorPackets": {},
"cpwVcPerfTotalInHCBytes": {},
"cpwVcPerfTotalInHCPackets": {},
"cpwVcPerfTotalOutHCBytes": {},
"cpwVcPerfTotalOutHCPackets": {},
"cpwVcPsnType": {},
"cpwVcRemoteControlWord": {},
"cpwVcRemoteGroupID": {},
"cpwVcRemoteIfMtu": {},
"cpwVcRemoteIfString": {},
"cpwVcRowStatus": {},
"cpwVcSetUpPriority": {},
"cpwVcStorageType": {},
"cpwVcTimeElapsed": {},
"cpwVcType": {},
"cpwVcUpDownNotifEnable": {},
"cpwVcUpTime": {},
"cpwVcValidIntervals": {},
"cqvTerminationPeEncap": {},
"cqvTerminationRowStatus": {},
"cqvTranslationEntry": {"3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"creAcctClientAverageResponseDelay": {},
"creAcctClientBadAuthenticators": {},
"creAcctClientBufferAllocFailures": {},
"creAcctClientDupIDs": {},
"creAcctClientLastUsedSourceId": {},
"creAcctClientMalformedResponses": {},
"creAcctClientMaxBufferSize": {},
"creAcctClientMaxResponseDelay": {},
"creAcctClientTimeouts": {},
"creAcctClientTotalPacketsWithResponses": {},
"creAcctClientTotalPacketsWithoutResponses": {},
"creAcctClientTotalResponses": {},
"creAcctClientUnknownResponses": {},
"creAuthClientAverageResponseDelay": {},
"creAuthClientBadAuthenticators": {},
"creAuthClientBufferAllocFailures": {},
"creAuthClientDupIDs": {},
"creAuthClientLastUsedSourceId": {},
"creAuthClientMalformedResponses": {},
"creAuthClientMaxBufferSize": {},
"creAuthClientMaxResponseDelay": {},
"creAuthClientTimeouts": {},
"creAuthClientTotalPacketsWithResponses": {},
"creAuthClientTotalPacketsWithoutResponses": {},
"creAuthClientTotalResponses": {},
"creAuthClientUnknownResponses": {},
"creClientLastUsedSourceId": {},
"creClientLastUsedSourcePort": {},
"creClientSourcePortRangeEnd": {},
"creClientSourcePortRangeStart": {},
"creClientTotalAccessRejects": {},
"creClientTotalAverageResponseDelay": {},
"creClientTotalMaxDoneQLength": {},
"creClientTotalMaxInQLength": {},
"creClientTotalMaxWaitQLength": {},
"crttMonIPEchoAdminDscp": {},
"crttMonIPEchoAdminFlowLabel": {},
"crttMonIPEchoAdminLSPSelAddrType": {},
"crttMonIPEchoAdminLSPSelAddress": {},
"crttMonIPEchoAdminNameServerAddrType": {},
"crttMonIPEchoAdminNameServerAddress": {},
"crttMonIPEchoAdminSourceAddrType": {},
"crttMonIPEchoAdminSourceAddress": {},
"crttMonIPEchoAdminTargetAddrType": {},
"crttMonIPEchoAdminTargetAddress": {},
"crttMonIPEchoPathAdminHopAddrType": {},
"crttMonIPEchoPathAdminHopAddress": {},
"crttMonIPHistoryCollectionAddrType": {},
"crttMonIPHistoryCollectionAddress": {},
"crttMonIPLatestRttOperAddress": {},
"crttMonIPLatestRttOperAddressType": {},
"crttMonIPLpdGrpStatsTargetPEAddr": {},
"crttMonIPLpdGrpStatsTargetPEAddrType": {},
"crttMonIPStatsCollectAddress": {},
"crttMonIPStatsCollectAddressType": {},
"csNotifications": {"1": {}},
"csbAdjacencyStatusNotifEnabled": {},
"csbBlackListNotifEnabled": {},
"csbCallStatsActiveTranscodeFlows": {},
"csbCallStatsAvailableFlows": {},
"csbCallStatsAvailablePktRate": {},
"csbCallStatsAvailableTranscodeFlows": {},
"csbCallStatsCallsHigh": {},
"csbCallStatsCallsLow": {},
"csbCallStatsInstancePhysicalIndex": {},
"csbCallStatsNoMediaCount": {},
"csbCallStatsPeakFlows": {},
"csbCallStatsPeakSigFlows": {},
"csbCallStatsPeakTranscodeFlows": {},
"csbCallStatsRTPOctetsDiscard": {},
"csbCallStatsRTPOctetsRcvd": {},
"csbCallStatsRTPOctetsSent": {},
"csbCallStatsRTPPktsDiscard": {},
"csbCallStatsRTPPktsRcvd": {},
"csbCallStatsRTPPktsSent": {},
"csbCallStatsRate1Sec": {},
"csbCallStatsRouteErrors": {},
"csbCallStatsSbcName": {},
"csbCallStatsTotalFlows": {},
"csbCallStatsTotalSigFlows": {},
"csbCallStatsTotalTranscodeFlows": {},
"csbCallStatsUnclassifiedPkts": {},
"csbCallStatsUsedFlows": {},
"csbCallStatsUsedSigFlows": {},
"csbCongestionAlarmNotifEnabled": {},
"csbCurrPeriodicIpsecCalls": {},
"csbCurrPeriodicStatsActivatingCalls": {},
"csbCurrPeriodicStatsActiveCallFailure": {},
"csbCurrPeriodicStatsActiveCalls": {},
"csbCurrPeriodicStatsActiveE2EmergencyCalls": {},
"csbCurrPeriodicStatsActiveEmergencyCalls": {},
"csbCurrPeriodicStatsActiveIpv6Calls": {},
"csbCurrPeriodicStatsAudioTranscodedCalls": {},
"csbCurrPeriodicStatsCallMediaFailure": {},
"csbCurrPeriodicStatsCallResourceFailure": {},
"csbCurrPeriodicStatsCallRoutingFailure": {},
"csbCurrPeriodicStatsCallSetupCACBandwidthFailure": {},
"csbCurrPeriodicStatsCallSetupCACCallLimitFailure": {},
"csbCurrPeriodicStatsCallSetupCACMediaLimitFailure": {},
"csbCurrPeriodicStatsCallSetupCACMediaUpdateFailure": {},
"csbCurrPeriodicStatsCallSetupCACPolicyFailure": {},
"csbCurrPeriodicStatsCallSetupCACRateLimitFailure": {},
"csbCurrPeriodicStatsCallSetupNAPolicyFailure": {},
"csbCurrPeriodicStatsCallSetupPolicyFailure": {},
"csbCurrPeriodicStatsCallSetupRoutingPolicyFailure": {},
"csbCurrPeriodicStatsCallSigFailure": {},
"csbCurrPeriodicStatsCongestionFailure": {},
"csbCurrPeriodicStatsCurrentTaps": {},
"csbCurrPeriodicStatsDeactivatingCalls": {},
"csbCurrPeriodicStatsDtmfIw2833Calls": {},
"csbCurrPeriodicStatsDtmfIw2833InbandCalls": {},
"csbCurrPeriodicStatsDtmfIwInbandCalls": {},
"csbCurrPeriodicStatsFailedCallAttempts": {},
"csbCurrPeriodicStatsFaxTranscodedCalls": {},
"csbCurrPeriodicStatsImsRxActiveCalls": {},
"csbCurrPeriodicStatsImsRxCallRenegotiationAttempts": {},
"csbCurrPeriodicStatsImsRxCallRenegotiationFailures": {},
"csbCurrPeriodicStatsImsRxCallSetupFaiures": {},
"csbCurrPeriodicStatsNonSrtpCalls": {},
"csbCurrPeriodicStatsRtpDisallowedFailures": {},
"csbCurrPeriodicStatsSrtpDisallowedFailures": {},
"csbCurrPeriodicStatsSrtpIwCalls": {},
"csbCurrPeriodicStatsSrtpNonIwCalls": {},
"csbCurrPeriodicStatsTimestamp": {},
"csbCurrPeriodicStatsTotalCallAttempts": {},
"csbCurrPeriodicStatsTotalCallUpdateFailure": {},
"csbCurrPeriodicStatsTotalTapsRequested": {},
"csbCurrPeriodicStatsTotalTapsSucceeded": {},
"csbCurrPeriodicStatsTranscodedCalls": {},
"csbCurrPeriodicStatsTransratedCalls": {},
"csbDiameterConnectionStatusNotifEnabled": {},
"csbH248ControllerStatusNotifEnabled": {},
"csbH248StatsEstablishedTime": {},
"csbH248StatsEstablishedTimeRev1": {},
"csbH248StatsLT": {},
"csbH248StatsLTRev1": {},
"csbH248StatsRTT": {},
"csbH248StatsRTTRev1": {},
"csbH248StatsRepliesRcvd": {},
"csbH248StatsRepliesRcvdRev1": {},
"csbH248StatsRepliesRetried": {},
"csbH248StatsRepliesRetriedRev1": {},
"csbH248StatsRepliesSent": {},
"csbH248StatsRepliesSentRev1": {},
"csbH248StatsRequestsFailed": {},
"csbH248StatsRequestsFailedRev1": {},
"csbH248StatsRequestsRcvd": {},
"csbH248StatsRequestsRcvdRev1": {},
"csbH248StatsRequestsRetried": {},
"csbH248StatsRequestsRetriedRev1": {},
"csbH248StatsRequestsSent": {},
"csbH248StatsRequestsSentRev1": {},
"csbH248StatsSegPktsRcvd": {},
"csbH248StatsSegPktsRcvdRev1": {},
"csbH248StatsSegPktsSent": {},
"csbH248StatsSegPktsSentRev1": {},
"csbH248StatsTMaxTimeoutVal": {},
"csbH248StatsTMaxTimeoutValRev1": {},
"csbHistoryStatsActiveCallFailure": {},
"csbHistoryStatsActiveCalls": {},
"csbHistoryStatsActiveE2EmergencyCalls": {},
"csbHistoryStatsActiveEmergencyCalls": {},
"csbHistoryStatsActiveIpv6Calls": {},
"csbHistoryStatsAudioTranscodedCalls": {},
"csbHistoryStatsCallMediaFailure": {},
"csbHistoryStatsCallResourceFailure": {},
"csbHistoryStatsCallRoutingFailure": {},
"csbHistoryStatsCallSetupCACBandwidthFailure": {},
"csbHistoryStatsCallSetupCACCallLimitFailure": {},
"csbHistoryStatsCallSetupCACMediaLimitFailure": {},
"csbHistoryStatsCallSetupCACMediaUpdateFailure": {},
"csbHistoryStatsCallSetupCACPolicyFailure": {},
"csbHistoryStatsCallSetupCACRateLimitFailure": {},
"csbHistoryStatsCallSetupNAPolicyFailure": {},
"csbHistoryStatsCallSetupPolicyFailure": {},
"csbHistoryStatsCallSetupRoutingPolicyFailure": {},
"csbHistoryStatsCongestionFailure": {},
"csbHistoryStatsCurrentTaps": {},
"csbHistoryStatsDtmfIw2833Calls": {},
"csbHistoryStatsDtmfIw2833InbandCalls": {},
"csbHistoryStatsDtmfIwInbandCalls": {},
"csbHistoryStatsFailSigFailure": {},
"csbHistoryStatsFailedCallAttempts": {},
"csbHistoryStatsFaxTranscodedCalls": {},
"csbHistoryStatsImsRxActiveCalls": {},
"csbHistoryStatsImsRxCallRenegotiationAttempts": {},
"csbHistoryStatsImsRxCallRenegotiationFailures": {},
"csbHistoryStatsImsRxCallSetupFailures": {},
"csbHistoryStatsIpsecCalls": {},
"csbHistoryStatsNonSrtpCalls": {},
"csbHistoryStatsRtpDisallowedFailures": {},
"csbHistoryStatsSrtpDisallowedFailures": {},
"csbHistoryStatsSrtpIwCalls": {},
"csbHistoryStatsSrtpNonIwCalls": {},
"csbHistoryStatsTimestamp": {},
"csbHistoryStatsTotalCallAttempts": {},
"csbHistoryStatsTotalCallUpdateFailure": {},
"csbHistoryStatsTotalTapsRequested": {},
"csbHistoryStatsTotalTapsSucceeded": {},
"csbHistroyStatsTranscodedCalls": {},
"csbHistroyStatsTransratedCalls": {},
"csbPerFlowStatsAdrStatus": {},
"csbPerFlowStatsDscpSettings": {},
"csbPerFlowStatsEPJitter": {},
"csbPerFlowStatsFlowType": {},
"csbPerFlowStatsQASettings": {},
"csbPerFlowStatsRTCPPktsLost": {},
"csbPerFlowStatsRTCPPktsRcvd": {},
"csbPerFlowStatsRTCPPktsSent": {},
"csbPerFlowStatsRTPOctetsDiscard": {},
"csbPerFlowStatsRTPOctetsRcvd": {},
"csbPerFlowStatsRTPOctetsSent": {},
"csbPerFlowStatsRTPPktsDiscard": {},
"csbPerFlowStatsRTPPktsLost": {},
"csbPerFlowStatsRTPPktsRcvd": {},
"csbPerFlowStatsRTPPktsSent": {},
"csbPerFlowStatsTmanPerMbs": {},
"csbPerFlowStatsTmanPerSdr": {},
"csbRadiusConnectionStatusNotifEnabled": {},
"csbRadiusStatsAcsAccpts": {},
"csbRadiusStatsAcsChalls": {},
"csbRadiusStatsAcsRejects": {},
"csbRadiusStatsAcsReqs": {},
"csbRadiusStatsAcsRtrns": {},
"csbRadiusStatsActReqs": {},
"csbRadiusStatsActRetrans": {},
"csbRadiusStatsActRsps": {},
"csbRadiusStatsBadAuths": {},
"csbRadiusStatsClientName": {},
"csbRadiusStatsClientType": {},
"csbRadiusStatsDropped": {},
"csbRadiusStatsMalformedRsps": {},
"csbRadiusStatsPending": {},
"csbRadiusStatsSrvrName": {},
"csbRadiusStatsTimeouts": {},
"csbRadiusStatsUnknownType": {},
"csbRfBillRealmStatsFailEventAcrs": {},
"csbRfBillRealmStatsFailInterimAcrs": {},
"csbRfBillRealmStatsFailStartAcrs": {},
"csbRfBillRealmStatsFailStopAcrs": {},
"csbRfBillRealmStatsRealmName": {},
"csbRfBillRealmStatsSuccEventAcrs": {},
"csbRfBillRealmStatsSuccInterimAcrs": {},
"csbRfBillRealmStatsSuccStartAcrs": {},
"csbRfBillRealmStatsSuccStopAcrs": {},
"csbRfBillRealmStatsTotalEventAcrs": {},
"csbRfBillRealmStatsTotalInterimAcrs": {},
"csbRfBillRealmStatsTotalStartAcrs": {},
"csbRfBillRealmStatsTotalStopAcrs": {},
"csbSIPMthdCurrentStatsAdjName": {},
"csbSIPMthdCurrentStatsMethodName": {},
"csbSIPMthdCurrentStatsReqIn": {},
"csbSIPMthdCurrentStatsReqOut": {},
"csbSIPMthdCurrentStatsResp1xxIn": {},
"csbSIPMthdCurrentStatsResp1xxOut": {},
"csbSIPMthdCurrentStatsResp2xxIn": {},
"csbSIPMthdCurrentStatsResp2xxOut": {},
"csbSIPMthdCurrentStatsResp3xxIn": {},
"csbSIPMthdCurrentStatsResp3xxOut": {},
"csbSIPMthdCurrentStatsResp4xxIn": {},
"csbSIPMthdCurrentStatsResp4xxOut": {},
"csbSIPMthdCurrentStatsResp5xxIn": {},
"csbSIPMthdCurrentStatsResp5xxOut": {},
"csbSIPMthdCurrentStatsResp6xxIn": {},
"csbSIPMthdCurrentStatsResp6xxOut": {},
"csbSIPMthdHistoryStatsAdjName": {},
"csbSIPMthdHistoryStatsMethodName": {},
"csbSIPMthdHistoryStatsReqIn": {},
"csbSIPMthdHistoryStatsReqOut": {},
"csbSIPMthdHistoryStatsResp1xxIn": {},
"csbSIPMthdHistoryStatsResp1xxOut": {},
"csbSIPMthdHistoryStatsResp2xxIn": {},
"csbSIPMthdHistoryStatsResp2xxOut": {},
"csbSIPMthdHistoryStatsResp3xxIn": {},
"csbSIPMthdHistoryStatsResp3xxOut": {},
"csbSIPMthdHistoryStatsResp4xxIn": {},
"csbSIPMthdHistoryStatsResp4xxOut": {},
"csbSIPMthdHistoryStatsResp5xxIn": {},
"csbSIPMthdHistoryStatsResp5xxOut": {},
"csbSIPMthdHistoryStatsResp6xxIn": {},
"csbSIPMthdHistoryStatsResp6xxOut": {},
"csbSIPMthdRCCurrentStatsAdjName": {},
"csbSIPMthdRCCurrentStatsMethodName": {},
"csbSIPMthdRCCurrentStatsRespIn": {},
"csbSIPMthdRCCurrentStatsRespOut": {},
"csbSIPMthdRCHistoryStatsAdjName": {},
"csbSIPMthdRCHistoryStatsMethodName": {},
"csbSIPMthdRCHistoryStatsRespIn": {},
"csbSIPMthdRCHistoryStatsRespOut": {},
"csbSLAViolationNotifEnabled": {},
"csbSLAViolationNotifEnabledRev1": {},
"csbServiceStateNotifEnabled": {},
"csbSourceAlertNotifEnabled": {},
"cslFarEndTotalEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"cslTotalEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"cspFarEndTotalEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"cspTotalEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"cssTotalEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"csubAggStatsAuthSessions": {},
"csubAggStatsAvgSessionRPH": {},
"csubAggStatsAvgSessionRPM": {},
"csubAggStatsAvgSessionUptime": {},
"csubAggStatsCurrAuthSessions": {},
"csubAggStatsCurrCreatedSessions": {},
"csubAggStatsCurrDiscSessions": {},
"csubAggStatsCurrFailedSessions": {},
"csubAggStatsCurrFlowsUp": {},
"csubAggStatsCurrInvalidIntervals": {},
"csubAggStatsCurrTimeElapsed": {},
"csubAggStatsCurrUpSessions": {},
"csubAggStatsCurrValidIntervals": {},
"csubAggStatsDayAuthSessions": {},
"csubAggStatsDayCreatedSessions": {},
"csubAggStatsDayDiscSessions": {},
"csubAggStatsDayFailedSessions": {},
"csubAggStatsDayUpSessions": {},
"csubAggStatsDiscontinuityTime": {},
"csubAggStatsHighUpSessions": {},
"csubAggStatsIntAuthSessions": {},
"csubAggStatsIntCreatedSessions": {},
"csubAggStatsIntDiscSessions": {},
"csubAggStatsIntFailedSessions": {},
"csubAggStatsIntUpSessions": {},
"csubAggStatsIntValid": {},
"csubAggStatsLightWeightSessions": {},
"csubAggStatsPendingSessions": {},
"csubAggStatsRedSessions": {},
"csubAggStatsThrottleEngagements": {},
"csubAggStatsTotalAuthSessions": {},
"csubAggStatsTotalCreatedSessions": {},
"csubAggStatsTotalDiscSessions": {},
"csubAggStatsTotalFailedSessions": {},
"csubAggStatsTotalFlowsUp": {},
"csubAggStatsTotalLightWeightSessions": {},
"csubAggStatsTotalUpSessions": {},
"csubAggStatsUnAuthSessions": {},
"csubAggStatsUpSessions": {},
"csubJobControl": {},
"csubJobCount": {},
"csubJobFinishedNotifyEnable": {},
"csubJobFinishedReason": {},
"csubJobFinishedTime": {},
"csubJobIdNext": {},
"csubJobIndexedAttributes": {},
"csubJobMatchAcctSessionId": {},
"csubJobMatchAuthenticated": {},
"csubJobMatchCircuitId": {},
"csubJobMatchDanglingDuration": {},
"csubJobMatchDhcpClass": {},
"csubJobMatchDnis": {},
"csubJobMatchDomain": {},
"csubJobMatchDomainIpAddr": {},
"csubJobMatchDomainIpAddrType": {},
"csubJobMatchDomainIpMask": {},
"csubJobMatchDomainVrf": {},
"csubJobMatchIdentities": {},
"csubJobMatchMacAddress": {},
"csubJobMatchMedia": {},
"csubJobMatchMlpNegotiated": {},
"csubJobMatchNasPort": {},
"csubJobMatchNativeIpAddr": {},
"csubJobMatchNativeIpAddrType": {},
"csubJobMatchNativeIpMask": {},
"csubJobMatchNativeVrf": {},
"csubJobMatchOtherParams": {},
"csubJobMatchPbhk": {},
"csubJobMatchProtocol": {},
"csubJobMatchRedundancyMode": {},
"csubJobMatchRemoteId": {},
"csubJobMatchServiceName": {},
"csubJobMatchState": {},
"csubJobMatchSubscriberLabel": {},
"csubJobMatchTunnelName": {},
"csubJobMatchUsername": {},
"csubJobMaxLife": {},
"csubJobMaxNumber": {},
"csubJobQueryResultingReportSize": {},
"csubJobQuerySortKey1": {},
"csubJobQuerySortKey2": {},
"csubJobQuerySortKey3": {},
"csubJobQueueJobId": {},
"csubJobReportSession": {},
"csubJobStartedTime": {},
"csubJobState": {},
"csubJobStatus": {},
"csubJobStorage": {},
"csubJobType": {},
"csubSessionAcctSessionId": {},
"csubSessionAuthenticated": {},
"csubSessionAvailableIdentities": {},
"csubSessionByType": {},
"csubSessionCircuitId": {},
"csubSessionCreationTime": {},
"csubSessionDerivedCfg": {},
"csubSessionDhcpClass": {},
"csubSessionDnis": {},
"csubSessionDomain": {},
"csubSessionDomainIpAddr": {},
"csubSessionDomainIpAddrType": {},
"csubSessionDomainIpMask": {},
"csubSessionDomainVrf": {},
"csubSessionIfIndex": {},
"csubSessionIpAddrAssignment": {},
"csubSessionLastChanged": {},
"csubSessionLocationIdentifier": {},
"csubSessionMacAddress": {},
"csubSessionMedia": {},
"csubSessionMlpNegotiated": {},
"csubSessionNasPort": {},
"csubSessionNativeIpAddr": {},
"csubSessionNativeIpAddr2": {},
"csubSessionNativeIpAddrType": {},
"csubSessionNativeIpAddrType2": {},
"csubSessionNativeIpMask": {},
"csubSessionNativeIpMask2": {},
"csubSessionNativeVrf": {},
"csubSessionPbhk": {},
"csubSessionProtocol": {},
"csubSessionRedundancyMode": {},
"csubSessionRemoteId": {},
"csubSessionServiceIdentifier": {},
"csubSessionState": {},
"csubSessionSubscriberLabel": {},
"csubSessionTunnelName": {},
"csubSessionType": {},
"csubSessionUsername": {},
"cubeEnabled": {},
"cubeTotalSessionAllowed": {},
"cubeVersion": {},
"cufwAIAlertEnabled": {},
"cufwAIAuditTrailEnabled": {},
"cufwAaicGlobalNumBadPDUSize": {},
"cufwAaicGlobalNumBadPortRange": {},
"cufwAaicGlobalNumBadProtocolOps": {},
"cufwAaicHttpNumBadContent": {},
"cufwAaicHttpNumBadPDUSize": {},
"cufwAaicHttpNumBadProtocolOps": {},
"cufwAaicHttpNumDoubleEncodedPkts": {},
"cufwAaicHttpNumLargeURIs": {},
"cufwAaicHttpNumMismatchContent": {},
"cufwAaicHttpNumTunneledConns": {},
"cufwAppConnNumAborted": {},
"cufwAppConnNumActive": {},
"cufwAppConnNumAttempted": {},
"cufwAppConnNumHalfOpen": {},
"cufwAppConnNumPolicyDeclined": {},
"cufwAppConnNumResDeclined": {},
"cufwAppConnNumSetupsAborted": {},
"cufwAppConnSetupRate1": {},
"cufwAppConnSetupRate5": {},
"cufwCntlL2StaticMacAddressMoved": {},
"cufwCntlUrlfServerStatusChange": {},
"cufwConnGlobalConnSetupRate1": {},
"cufwConnGlobalConnSetupRate5": {},
"cufwConnGlobalNumAborted": {},
"cufwConnGlobalNumActive": {},
"cufwConnGlobalNumAttempted": {},
"cufwConnGlobalNumEmbryonic": {},
"cufwConnGlobalNumExpired": {},
"cufwConnGlobalNumHalfOpen": {},
"cufwConnGlobalNumPolicyDeclined": {},
"cufwConnGlobalNumRemoteAccess": {},
"cufwConnGlobalNumResDeclined": {},
"cufwConnGlobalNumSetupsAborted": {},
"cufwConnNumAborted": {},
"cufwConnNumActive": {},
"cufwConnNumAttempted": {},
"cufwConnNumHalfOpen": {},
"cufwConnNumPolicyDeclined": {},
"cufwConnNumResDeclined": {},
"cufwConnNumSetupsAborted": {},
"cufwConnReptAppStats": {},
"cufwConnReptAppStatsLastChanged": {},
"cufwConnResActiveConnMemoryUsage": {},
"cufwConnResEmbrConnMemoryUsage": {},
"cufwConnResHOConnMemoryUsage": {},
"cufwConnResMemoryUsage": {},
"cufwConnSetupRate1": {},
"cufwConnSetupRate5": {},
"cufwInspectionStatus": {},
"cufwL2GlobalArpCacheSize": {},
"cufwL2GlobalArpOverflowRate5": {},
"cufwL2GlobalEnableArpInspection": {},
"cufwL2GlobalEnableStealthMode": {},
"cufwL2GlobalNumArpRequests": {},
"cufwL2GlobalNumBadArpResponses": {},
"cufwL2GlobalNumDrops": {},
"cufwL2GlobalNumFloods": {},
"cufwL2GlobalNumIcmpRequests": {},
"cufwL2GlobalNumSpoofedArpResps": {},
"cufwPolAppConnNumAborted": {},
"cufwPolAppConnNumActive": {},
"cufwPolAppConnNumAttempted": {},
"cufwPolAppConnNumHalfOpen": {},
"cufwPolAppConnNumPolicyDeclined": {},
"cufwPolAppConnNumResDeclined": {},
"cufwPolAppConnNumSetupsAborted": {},
"cufwPolConnNumAborted": {},
"cufwPolConnNumActive": {},
"cufwPolConnNumAttempted": {},
"cufwPolConnNumHalfOpen": {},
"cufwPolConnNumPolicyDeclined": {},
"cufwPolConnNumResDeclined": {},
"cufwPolConnNumSetupsAborted": {},
"cufwUrlfAllowModeReqNumAllowed": {},
"cufwUrlfAllowModeReqNumDenied": {},
"cufwUrlfFunctionEnabled": {},
"cufwUrlfNumServerRetries": {},
"cufwUrlfNumServerTimeouts": {},
"cufwUrlfRequestsDeniedRate1": {},
"cufwUrlfRequestsDeniedRate5": {},
"cufwUrlfRequestsNumAllowed": {},
"cufwUrlfRequestsNumCacheAllowed": {},
"cufwUrlfRequestsNumCacheDenied": {},
"cufwUrlfRequestsNumDenied": {},
"cufwUrlfRequestsNumProcessed": {},
"cufwUrlfRequestsNumResDropped": {},
"cufwUrlfRequestsProcRate1": {},
"cufwUrlfRequestsProcRate5": {},
"cufwUrlfRequestsResDropRate1": {},
"cufwUrlfRequestsResDropRate5": {},
"cufwUrlfResTotalRequestCacheSize": {},
"cufwUrlfResTotalRespCacheSize": {},
"cufwUrlfResponsesNumLate": {},
"cufwUrlfServerAvgRespTime1": {},
"cufwUrlfServerAvgRespTime5": {},
"cufwUrlfServerNumRetries": {},
"cufwUrlfServerNumTimeouts": {},
"cufwUrlfServerReqsNumAllowed": {},
"cufwUrlfServerReqsNumDenied": {},
"cufwUrlfServerReqsNumProcessed": {},
"cufwUrlfServerRespsNumLate": {},
"cufwUrlfServerRespsNumReceived": {},
"cufwUrlfServerStatus": {},
"cufwUrlfServerVendor": {},
"cufwUrlfUrlAccRespsNumResDropped": {},
"cvActiveCallStatsAvgVal": {},
"cvActiveCallStatsMaxVal": {},
"cvActiveCallWMValue": {},
"cvActiveCallWMts": {},
"cvBasic": {"1": {}, "2": {}, "3": {}},
"cvCallActiveACOMLevel": {},
"cvCallActiveAccountCode": {},
"cvCallActiveCallId": {},
"cvCallActiveCallerIDBlock": {},
"cvCallActiveCallingName": {},
"cvCallActiveCoderTypeRate": {},
"cvCallActiveConnectionId": {},
"cvCallActiveDS0s": {},
"cvCallActiveDS0sHighNotifyEnable": {},
"cvCallActiveDS0sHighThreshold": {},
"cvCallActiveDS0sLowNotifyEnable": {},
"cvCallActiveDS0sLowThreshold": {},
"cvCallActiveERLLevel": {},
"cvCallActiveERLLevelRev1": {},
"cvCallActiveEcanReflectorLocation": {},
"cvCallActiveFaxTxDuration": {},
"cvCallActiveImgPageCount": {},
"cvCallActiveInSignalLevel": {},
"cvCallActiveNoiseLevel": {},
"cvCallActiveOutSignalLevel": {},
"cvCallActiveSessionTarget": {},
"cvCallActiveTxDuration": {},
"cvCallActiveVoiceTxDuration": {},
"cvCallDurationStatsAvgVal": {},
"cvCallDurationStatsMaxVal": {},
"cvCallDurationStatsThreshold": {},
"cvCallHistoryACOMLevel": {},
"cvCallHistoryAccountCode": {},
"cvCallHistoryCallId": {},
"cvCallHistoryCallerIDBlock": {},
"cvCallHistoryCallingName": {},
"cvCallHistoryCoderTypeRate": {},
"cvCallHistoryConnectionId": {},
"cvCallHistoryFaxTxDuration": {},
"cvCallHistoryImgPageCount": {},
"cvCallHistoryNoiseLevel": {},
"cvCallHistorySessionTarget": {},
"cvCallHistoryTxDuration": {},
"cvCallHistoryVoiceTxDuration": {},
"cvCallLegRateStatsAvgVal": {},
"cvCallLegRateStatsMaxVal": {},
"cvCallLegRateWMValue": {},
"cvCallLegRateWMts": {},
"cvCallRate": {},
"cvCallRateHiWaterMark": {},
"cvCallRateMonitorEnable": {},
"cvCallRateMonitorTime": {},
"cvCallRateStatsAvgVal": {},
"cvCallRateStatsMaxVal": {},
"cvCallRateWMValue": {},
"cvCallRateWMts": {},
"cvCallVolConnActiveConnection": {},
"cvCallVolConnMaxCallConnectionLicenese": {},
"cvCallVolConnTotalActiveConnections": {},
"cvCallVolMediaIncomingCalls": {},
"cvCallVolMediaOutgoingCalls": {},
"cvCallVolPeerIncomingCalls": {},
"cvCallVolPeerOutgoingCalls": {},
"cvCallVolumeWMTableSize": {},
"cvCommonDcCallActiveCallerIDBlock": {},
"cvCommonDcCallActiveCallingName": {},
"cvCommonDcCallActiveCodecBytes": {},
"cvCommonDcCallActiveCoderTypeRate": {},
"cvCommonDcCallActiveConnectionId": {},
"cvCommonDcCallActiveInBandSignaling": {},
"cvCommonDcCallActiveVADEnable": {},
"cvCommonDcCallHistoryCallerIDBlock": {},
"cvCommonDcCallHistoryCallingName": {},
"cvCommonDcCallHistoryCodecBytes": {},
"cvCommonDcCallHistoryCoderTypeRate": {},
"cvCommonDcCallHistoryConnectionId": {},
"cvCommonDcCallHistoryInBandSignaling": {},
"cvCommonDcCallHistoryVADEnable": {},
"cvForwNeighborEntry": {"4": {}, "5": {}, "6": {}, "7": {}, "8": {}, "9": {}},
"cvForwRouteEntry": {
"10": {},
"11": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cvForwarding": {"1": {}, "2": {}, "3": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"cvGeneralDSCPPolicyNotificationEnable": {},
"cvGeneralFallbackNotificationEnable": {},
"cvGeneralMediaPolicyNotificationEnable": {},
"cvGeneralPoorQoVNotificationEnable": {},
"cvIfCfgEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cvIfConfigEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cvIfCountInEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cvIfCountOutEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cvInterfaceVnetTrunkEnabled": {},
"cvInterfaceVnetVrfList": {},
"cvPeerCfgIfIndex": {},
"cvPeerCfgPeerType": {},
"cvPeerCfgRowStatus": {},
"cvPeerCfgType": {},
"cvPeerCommonCfgApplicationName": {},
"cvPeerCommonCfgDnisMappingName": {},
"cvPeerCommonCfgHuntStop": {},
"cvPeerCommonCfgIncomingDnisDigits": {},
"cvPeerCommonCfgMaxConnections": {},
"cvPeerCommonCfgPreference": {},
"cvPeerCommonCfgSourceCarrierId": {},
"cvPeerCommonCfgSourceTrunkGrpLabel": {},
"cvPeerCommonCfgTargetCarrierId": {},
"cvPeerCommonCfgTargetTrunkGrpLabel": {},
"cvSipMsgRateStatsAvgVal": {},
"cvSipMsgRateStatsMaxVal": {},
"cvSipMsgRateWMValue": {},
"cvSipMsgRateWMts": {},
"cvTotal": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"cvVnetTrunkNotifEnable": {},
"cvVoIPCallActiveBitRates": {},
"cvVoIPCallActiveCRC": {},
"cvVoIPCallActiveCallId": {},
"cvVoIPCallActiveCallReferenceId": {},
"cvVoIPCallActiveChannels": {},
"cvVoIPCallActiveCoderMode": {},
"cvVoIPCallActiveCoderTypeRate": {},
"cvVoIPCallActiveConnectionId": {},
"cvVoIPCallActiveEarlyPackets": {},
"cvVoIPCallActiveEncap": {},
"cvVoIPCallActiveEntry": {"46": {}},
"cvVoIPCallActiveGapFillWithInterpolation": {},
"cvVoIPCallActiveGapFillWithPrediction": {},
"cvVoIPCallActiveGapFillWithRedundancy": {},
"cvVoIPCallActiveGapFillWithSilence": {},
"cvVoIPCallActiveHiWaterPlayoutDelay": {},
"cvVoIPCallActiveInterleaving": {},
"cvVoIPCallActiveJBufferNominalDelay": {},
"cvVoIPCallActiveLatePackets": {},
"cvVoIPCallActiveLoWaterPlayoutDelay": {},
"cvVoIPCallActiveLostPackets": {},
"cvVoIPCallActiveMaxPtime": {},
"cvVoIPCallActiveModeChgNeighbor": {},
"cvVoIPCallActiveModeChgPeriod": {},
"cvVoIPCallActiveMosQe": {},
"cvVoIPCallActiveOctetAligned": {},
"cvVoIPCallActiveOnTimeRvPlayout": {},
"cvVoIPCallActiveOutOfOrder": {},
"cvVoIPCallActiveProtocolCallId": {},
"cvVoIPCallActivePtime": {},
"cvVoIPCallActiveReceiveDelay": {},
"cvVoIPCallActiveRemMediaIPAddr": {},
"cvVoIPCallActiveRemMediaIPAddrT": {},
"cvVoIPCallActiveRemMediaPort": {},
"cvVoIPCallActiveRemSigIPAddr": {},
"cvVoIPCallActiveRemSigIPAddrT": {},
"cvVoIPCallActiveRemSigPort": {},
"cvVoIPCallActiveRemoteIPAddress": {},
"cvVoIPCallActiveRemoteUDPPort": {},
"cvVoIPCallActiveReversedDirectionPeerAddress": {},
"cvVoIPCallActiveRobustSorting": {},
"cvVoIPCallActiveRoundTripDelay": {},
"cvVoIPCallActiveSRTPEnable": {},
"cvVoIPCallActiveSelectedQoS": {},
"cvVoIPCallActiveSessionProtocol": {},
"cvVoIPCallActiveSessionTarget": {},
"cvVoIPCallActiveTotalPacketLoss": {},
"cvVoIPCallActiveUsername": {},
"cvVoIPCallActiveVADEnable": {},
"cvVoIPCallHistoryBitRates": {},
"cvVoIPCallHistoryCRC": {},
"cvVoIPCallHistoryCallId": {},
"cvVoIPCallHistoryCallReferenceId": {},
"cvVoIPCallHistoryChannels": {},
"cvVoIPCallHistoryCoderMode": {},
"cvVoIPCallHistoryCoderTypeRate": {},
"cvVoIPCallHistoryConnectionId": {},
"cvVoIPCallHistoryEarlyPackets": {},
"cvVoIPCallHistoryEncap": {},
"cvVoIPCallHistoryEntry": {"48": {}},
"cvVoIPCallHistoryFallbackDelay": {},
"cvVoIPCallHistoryFallbackIcpif": {},
"cvVoIPCallHistoryFallbackLoss": {},
"cvVoIPCallHistoryGapFillWithInterpolation": {},
"cvVoIPCallHistoryGapFillWithPrediction": {},
"cvVoIPCallHistoryGapFillWithRedundancy": {},
"cvVoIPCallHistoryGapFillWithSilence": {},
"cvVoIPCallHistoryHiWaterPlayoutDelay": {},
"cvVoIPCallHistoryIcpif": {},
"cvVoIPCallHistoryInterleaving": {},
"cvVoIPCallHistoryJBufferNominalDelay": {},
"cvVoIPCallHistoryLatePackets": {},
"cvVoIPCallHistoryLoWaterPlayoutDelay": {},
"cvVoIPCallHistoryLostPackets": {},
"cvVoIPCallHistoryMaxPtime": {},
"cvVoIPCallHistoryModeChgNeighbor": {},
"cvVoIPCallHistoryModeChgPeriod": {},
"cvVoIPCallHistoryMosQe": {},
"cvVoIPCallHistoryOctetAligned": {},
"cvVoIPCallHistoryOnTimeRvPlayout": {},
"cvVoIPCallHistoryOutOfOrder": {},
"cvVoIPCallHistoryProtocolCallId": {},
"cvVoIPCallHistoryPtime": {},
"cvVoIPCallHistoryReceiveDelay": {},
"cvVoIPCallHistoryRemMediaIPAddr": {},
"cvVoIPCallHistoryRemMediaIPAddrT": {},
"cvVoIPCallHistoryRemMediaPort": {},
"cvVoIPCallHistoryRemSigIPAddr": {},
"cvVoIPCallHistoryRemSigIPAddrT": {},
"cvVoIPCallHistoryRemSigPort": {},
"cvVoIPCallHistoryRemoteIPAddress": {},
"cvVoIPCallHistoryRemoteUDPPort": {},
"cvVoIPCallHistoryRobustSorting": {},
"cvVoIPCallHistoryRoundTripDelay": {},
"cvVoIPCallHistorySRTPEnable": {},
"cvVoIPCallHistorySelectedQoS": {},
"cvVoIPCallHistorySessionProtocol": {},
"cvVoIPCallHistorySessionTarget": {},
"cvVoIPCallHistoryTotalPacketLoss": {},
"cvVoIPCallHistoryUsername": {},
"cvVoIPCallHistoryVADEnable": {},
"cvVoIPPeerCfgBitRate": {},
"cvVoIPPeerCfgBitRates": {},
"cvVoIPPeerCfgCRC": {},
"cvVoIPPeerCfgCoderBytes": {},
"cvVoIPPeerCfgCoderMode": {},
"cvVoIPPeerCfgCoderRate": {},
"cvVoIPPeerCfgCodingMode": {},
"cvVoIPPeerCfgDSCPPolicyNotificationEnable": {},
"cvVoIPPeerCfgDesiredQoS": {},
"cvVoIPPeerCfgDesiredQoSVideo": {},
"cvVoIPPeerCfgDigitRelay": {},
"cvVoIPPeerCfgExpectFactor": {},
"cvVoIPPeerCfgFaxBytes": {},
"cvVoIPPeerCfgFaxRate": {},
"cvVoIPPeerCfgFrameSize": {},
"cvVoIPPeerCfgIPPrecedence": {},
"cvVoIPPeerCfgIcpif": {},
"cvVoIPPeerCfgInBandSignaling": {},
"cvVoIPPeerCfgMediaPolicyNotificationEnable": {},
"cvVoIPPeerCfgMediaSetting": {},
"cvVoIPPeerCfgMinAcceptableQoS": {},
"cvVoIPPeerCfgMinAcceptableQoSVideo": {},
"cvVoIPPeerCfgOctetAligned": {},
"cvVoIPPeerCfgPoorQoVNotificationEnable": {},
"cvVoIPPeerCfgRedirectip2ip": {},
"cvVoIPPeerCfgSessionProtocol": {},
"cvVoIPPeerCfgSessionTarget": {},
"cvVoIPPeerCfgTechPrefix": {},
"cvVoIPPeerCfgUDPChecksumEnable": {},
"cvVoIPPeerCfgVADEnable": {},
"cvVoicePeerCfgCasGroup": {},
"cvVoicePeerCfgDIDCallEnable": {},
"cvVoicePeerCfgDialDigitsPrefix": {},
"cvVoicePeerCfgEchoCancellerTest": {},
"cvVoicePeerCfgForwardDigits": {},
"cvVoicePeerCfgRegisterE164": {},
"cvVoicePeerCfgSessionTarget": {},
"cvVrfIfNotifEnable": {},
"cvVrfInterfaceRowStatus": {},
"cvVrfInterfaceStorageType": {},
"cvVrfInterfaceType": {},
"cvVrfInterfaceVnetTagOverride": {},
"cvVrfListRowStatus": {},
"cvVrfListStorageType": {},
"cvVrfListVrfIndex": {},
"cvVrfName": {},
"cvVrfOperStatus": {},
"cvVrfRouteDistProt": {},
"cvVrfRowStatus": {},
"cvVrfStorageType": {},
"cvVrfVnetTag": {},
"cvaIfCfgImpedance": {},
"cvaIfCfgIntegratedDSP": {},
"cvaIfEMCfgDialType": {},
"cvaIfEMCfgEntry": {"7": {}},
"cvaIfEMCfgLmrECap": {},
"cvaIfEMCfgLmrMCap": {},
"cvaIfEMCfgOperation": {},
"cvaIfEMCfgSignalType": {},
"cvaIfEMCfgType": {},
"cvaIfEMInSeizureActive": {},
"cvaIfEMOutSeizureActive": {},
"cvaIfEMTimeoutLmrTeardown": {},
"cvaIfEMTimingClearWaitDuration": {},
"cvaIfEMTimingDelayStart": {},
"cvaIfEMTimingDigitDuration": {},
"cvaIfEMTimingEntry": {"13": {}, "14": {}, "15": {}},
"cvaIfEMTimingInterDigitDuration": {},
"cvaIfEMTimingMaxDelayDuration": {},
"cvaIfEMTimingMaxWinkDuration": {},
"cvaIfEMTimingMaxWinkWaitDuration": {},
"cvaIfEMTimingMinDelayPulseWidth": {},
"cvaIfEMTimingPulseInterDigitDuration": {},
"cvaIfEMTimingPulseRate": {},
"cvaIfEMTimingVoiceHangover": {},
"cvaIfFXOCfgDialType": {},
"cvaIfFXOCfgNumberRings": {},
"cvaIfFXOCfgSignalType": {},
"cvaIfFXOCfgSupDisconnect": {},
"cvaIfFXOCfgSupDisconnect2": {},
"cvaIfFXOHookStatus": {},
"cvaIfFXORingDetect": {},
"cvaIfFXORingGround": {},
"cvaIfFXOTimingDigitDuration": {},
"cvaIfFXOTimingInterDigitDuration": {},
"cvaIfFXOTimingPulseInterDigitDuration": {},
"cvaIfFXOTimingPulseRate": {},
"cvaIfFXOTipGround": {},
"cvaIfFXSCfgSignalType": {},
"cvaIfFXSHookStatus": {},
"cvaIfFXSRingActive": {},
"cvaIfFXSRingFrequency": {},
"cvaIfFXSRingGround": {},
"cvaIfFXSTimingDigitDuration": {},
"cvaIfFXSTimingInterDigitDuration": {},
"cvaIfFXSTipGround": {},
"cvaIfMaintenanceMode": {},
"cvaIfStatusInfoType": {},
"cvaIfStatusSignalErrors": {},
"cviRoutedVlanIfIndex": {},
"cvpdnDeniedUsersTotal": {},
"cvpdnSessionATOTimeouts": {},
"cvpdnSessionAdaptiveTimeOut": {},
"cvpdnSessionAttrBytesIn": {},
"cvpdnSessionAttrBytesOut": {},
"cvpdnSessionAttrCallDuration": {},
"cvpdnSessionAttrDS1ChannelIndex": {},
"cvpdnSessionAttrDS1PortIndex": {},
"cvpdnSessionAttrDS1SlotIndex": {},
"cvpdnSessionAttrDeviceCallerId": {},
"cvpdnSessionAttrDevicePhyId": {},
"cvpdnSessionAttrDeviceType": {},
"cvpdnSessionAttrEntry": {"20": {}, "21": {}, "22": {}, "23": {}, "24": {}},
"cvpdnSessionAttrModemCallStartIndex": {},
"cvpdnSessionAttrModemCallStartTime": {},
"cvpdnSessionAttrModemPortIndex": {},
"cvpdnSessionAttrModemSlotIndex": {},
"cvpdnSessionAttrMultilink": {},
"cvpdnSessionAttrPacketsIn": {},
"cvpdnSessionAttrPacketsOut": {},
"cvpdnSessionAttrState": {},
"cvpdnSessionAttrUserName": {},
"cvpdnSessionCalculationType": {},
"cvpdnSessionCurrentWindowSize": {},
"cvpdnSessionInterfaceName": {},
"cvpdnSessionLastChange": {},
"cvpdnSessionLocalWindowSize": {},
"cvpdnSessionMinimumWindowSize": {},
"cvpdnSessionOutGoingQueueSize": {},
"cvpdnSessionOutOfOrderPackets": {},
"cvpdnSessionPktProcessingDelay": {},
"cvpdnSessionRecvRBits": {},
"cvpdnSessionRecvSequence": {},
"cvpdnSessionRecvZLB": {},
"cvpdnSessionRemoteId": {},
"cvpdnSessionRemoteRecvSequence": {},
"cvpdnSessionRemoteSendSequence": {},
"cvpdnSessionRemoteWindowSize": {},
"cvpdnSessionRoundTripTime": {},
"cvpdnSessionSendSequence": {},
"cvpdnSessionSentRBits": {},
"cvpdnSessionSentZLB": {},
"cvpdnSessionSequencing": {},
"cvpdnSessionTotal": {},
"cvpdnSessionZLBTime": {},
"cvpdnSystemDeniedUsersTotal": {},
"cvpdnSystemInfo": {"5": {}, "6": {}},
"cvpdnSystemSessionTotal": {},
"cvpdnSystemTunnelTotal": {},
"cvpdnTunnelActiveSessions": {},
"cvpdnTunnelAttrActiveSessions": {},
"cvpdnTunnelAttrDeniedUsers": {},
"cvpdnTunnelAttrEntry": {
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
},
"cvpdnTunnelAttrLocalInitConnection": {},
"cvpdnTunnelAttrLocalIpAddress": {},
"cvpdnTunnelAttrLocalName": {},
"cvpdnTunnelAttrNetworkServiceType": {},
"cvpdnTunnelAttrOrigCause": {},
"cvpdnTunnelAttrRemoteEndpointName": {},
"cvpdnTunnelAttrRemoteIpAddress": {},
"cvpdnTunnelAttrRemoteName": {},
"cvpdnTunnelAttrRemoteTunnelId": {},
"cvpdnTunnelAttrSoftshut": {},
"cvpdnTunnelAttrSourceIpAddress": {},
"cvpdnTunnelAttrState": {},
"cvpdnTunnelBytesIn": {},
"cvpdnTunnelBytesOut": {},
"cvpdnTunnelDeniedUsers": {},
"cvpdnTunnelExtEntry": {"8": {}, "9": {}},
"cvpdnTunnelLastChange": {},
"cvpdnTunnelLocalInitConnection": {},
"cvpdnTunnelLocalIpAddress": {},
"cvpdnTunnelLocalName": {},
"cvpdnTunnelLocalPort": {},
"cvpdnTunnelNetworkServiceType": {},
"cvpdnTunnelOrigCause": {},
"cvpdnTunnelPacketsIn": {},
"cvpdnTunnelPacketsOut": {},
"cvpdnTunnelRemoteEndpointName": {},
"cvpdnTunnelRemoteIpAddress": {},
"cvpdnTunnelRemoteName": {},
"cvpdnTunnelRemotePort": {},
"cvpdnTunnelRemoteTunnelId": {},
"cvpdnTunnelSessionBytesIn": {},
"cvpdnTunnelSessionBytesOut": {},
"cvpdnTunnelSessionCallDuration": {},
"cvpdnTunnelSessionDS1ChannelIndex": {},
"cvpdnTunnelSessionDS1PortIndex": {},
"cvpdnTunnelSessionDS1SlotIndex": {},
"cvpdnTunnelSessionDeviceCallerId": {},
"cvpdnTunnelSessionDevicePhyId": {},
"cvpdnTunnelSessionDeviceType": {},
"cvpdnTunnelSessionModemCallStartIndex": {},
"cvpdnTunnelSessionModemCallStartTime": {},
"cvpdnTunnelSessionModemPortIndex": {},
"cvpdnTunnelSessionModemSlotIndex": {},
"cvpdnTunnelSessionMultilink": {},
"cvpdnTunnelSessionPacketsIn": {},
"cvpdnTunnelSessionPacketsOut": {},
"cvpdnTunnelSessionState": {},
"cvpdnTunnelSessionUserName": {},
"cvpdnTunnelSoftshut": {},
"cvpdnTunnelSourceIpAddress": {},
"cvpdnTunnelState": {},
"cvpdnTunnelTotal": {},
"cvpdnUnameToFailHistCount": {},
"cvpdnUnameToFailHistDestIp": {},
"cvpdnUnameToFailHistFailReason": {},
"cvpdnUnameToFailHistFailTime": {},
"cvpdnUnameToFailHistFailType": {},
"cvpdnUnameToFailHistLocalInitConn": {},
"cvpdnUnameToFailHistLocalName": {},
"cvpdnUnameToFailHistRemoteName": {},
"cvpdnUnameToFailHistSourceIp": {},
"cvpdnUnameToFailHistUserId": {},
"cvpdnUserToFailHistInfoEntry": {"13": {}, "14": {}, "15": {}, "16": {}},
"ddp": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"demandNbrAcceptCalls": {},
"demandNbrAddress": {},
"demandNbrCallOrigin": {},
"demandNbrClearCode": {},
"demandNbrClearReason": {},
"demandNbrFailCalls": {},
"demandNbrLastAttemptTime": {},
"demandNbrLastDuration": {},
"demandNbrLogIf": {},
"demandNbrMaxDuration": {},
"demandNbrName": {},
"demandNbrPermission": {},
"demandNbrRefuseCalls": {},
"demandNbrStatus": {},
"demandNbrSuccessCalls": {},
"dialCtlAcceptMode": {},
"dialCtlPeerCfgAnswerAddress": {},
"dialCtlPeerCfgCallRetries": {},
"dialCtlPeerCfgCarrierDelay": {},
"dialCtlPeerCfgFailureDelay": {},
"dialCtlPeerCfgIfType": {},
"dialCtlPeerCfgInactivityTimer": {},
"dialCtlPeerCfgInfoType": {},
"dialCtlPeerCfgLowerIf": {},
"dialCtlPeerCfgMaxDuration": {},
"dialCtlPeerCfgMinDuration": {},
"dialCtlPeerCfgOriginateAddress": {},
"dialCtlPeerCfgPermission": {},
"dialCtlPeerCfgRetryDelay": {},
"dialCtlPeerCfgSpeed": {},
"dialCtlPeerCfgStatus": {},
"dialCtlPeerCfgSubAddress": {},
"dialCtlPeerCfgTrapEnable": {},
"dialCtlPeerStatsAcceptCalls": {},
"dialCtlPeerStatsChargedUnits": {},
"dialCtlPeerStatsConnectTime": {},
"dialCtlPeerStatsFailCalls": {},
"dialCtlPeerStatsLastDisconnectCause": {},
"dialCtlPeerStatsLastDisconnectText": {},
"dialCtlPeerStatsLastSetupTime": {},
"dialCtlPeerStatsRefuseCalls": {},
"dialCtlPeerStatsSuccessCalls": {},
"dialCtlTrapEnable": {},
"diffServAction": {"1": {}, "4": {}},
"diffServActionEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"diffServAlgDrop": {"1": {}, "3": {}},
"diffServAlgDropEntry": {
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"diffServClassifier": {"1": {}, "3": {}, "5": {}},
"diffServClfrElementEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"diffServClfrEntry": {"2": {}, "3": {}},
"diffServCountActEntry": {"2": {}, "3": {}, "4": {}, "5": {}},
"diffServDataPathEntry": {"2": {}, "3": {}, "4": {}},
"diffServDscpMarkActEntry": {"1": {}},
"diffServMaxRateEntry": {"3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"diffServMeter": {"1": {}},
"diffServMeterEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"diffServMinRateEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"diffServMultiFieldClfrEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"diffServQEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"diffServQueue": {"1": {}},
"diffServRandomDropEntry": {
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"diffServScheduler": {"1": {}, "3": {}, "5": {}},
"diffServSchedulerEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"diffServTBParam": {"1": {}},
"diffServTBParamEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"dlswCircuitEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"4": {},
"5": {},
"6": {},
"7": {},
},
"dlswCircuitStat": {"1": {}, "2": {}},
"dlswDirLocateMacEntry": {"3": {}},
"dlswDirLocateNBEntry": {"3": {}},
"dlswDirMacEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dlswDirNBEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dlswDirStat": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"dlswIfEntry": {"1": {}, "2": {}, "3": {}},
"dlswNode": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dlswSdlc": {"1": {}},
"dlswSdlcLsEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"dlswTConnConfigEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dlswTConnOperEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dlswTConnStat": {"1": {}, "2": {}, "3": {}},
"dlswTConnTcpConfigEntry": {"1": {}, "2": {}, "3": {}},
"dlswTConnTcpOperEntry": {"1": {}, "2": {}, "3": {}},
"dlswTrapControl": {"1": {}, "2": {}, "3": {}, "4": {}},
"dnAreaTableEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"dnHostTableEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"dnIfTableEntry": {"1": {}},
"dot1agCfmConfigErrorListErrorType": {},
"dot1agCfmDefaultMdDefIdPermission": {},
"dot1agCfmDefaultMdDefLevel": {},
"dot1agCfmDefaultMdDefMhfCreation": {},
"dot1agCfmDefaultMdIdPermission": {},
"dot1agCfmDefaultMdLevel": {},
"dot1agCfmDefaultMdMhfCreation": {},
"dot1agCfmDefaultMdStatus": {},
"dot1agCfmLtrChassisId": {},
"dot1agCfmLtrChassisIdSubtype": {},
"dot1agCfmLtrEgress": {},
"dot1agCfmLtrEgressMac": {},
"dot1agCfmLtrEgressPortId": {},
"dot1agCfmLtrEgressPortIdSubtype": {},
"dot1agCfmLtrForwarded": {},
"dot1agCfmLtrIngress": {},
"dot1agCfmLtrIngressMac": {},
"dot1agCfmLtrIngressPortId": {},
"dot1agCfmLtrIngressPortIdSubtype": {},
"dot1agCfmLtrLastEgressIdentifier": {},
"dot1agCfmLtrManAddress": {},
"dot1agCfmLtrManAddressDomain": {},
"dot1agCfmLtrNextEgressIdentifier": {},
"dot1agCfmLtrOrganizationSpecificTlv": {},
"dot1agCfmLtrRelay": {},
"dot1agCfmLtrTerminalMep": {},
"dot1agCfmLtrTtl": {},
"dot1agCfmMaCompIdPermission": {},
"dot1agCfmMaCompMhfCreation": {},
"dot1agCfmMaCompNumberOfVids": {},
"dot1agCfmMaCompPrimaryVlanId": {},
"dot1agCfmMaCompRowStatus": {},
"dot1agCfmMaMepListRowStatus": {},
"dot1agCfmMaNetCcmInterval": {},
"dot1agCfmMaNetFormat": {},
"dot1agCfmMaNetName": {},
"dot1agCfmMaNetRowStatus": {},
"dot1agCfmMdFormat": {},
"dot1agCfmMdMaNextIndex": {},
"dot1agCfmMdMdLevel": {},
"dot1agCfmMdMhfCreation": {},
"dot1agCfmMdMhfIdPermission": {},
"dot1agCfmMdName": {},
"dot1agCfmMdRowStatus": {},
"dot1agCfmMdTableNextIndex": {},
"dot1agCfmMepActive": {},
"dot1agCfmMepCciEnabled": {},
"dot1agCfmMepCciSentCcms": {},
"dot1agCfmMepCcmLtmPriority": {},
"dot1agCfmMepCcmSequenceErrors": {},
"dot1agCfmMepDbChassisId": {},
"dot1agCfmMepDbChassisIdSubtype": {},
"dot1agCfmMepDbInterfaceStatusTlv": {},
"dot1agCfmMepDbMacAddress": {},
"dot1agCfmMepDbManAddress": {},
"dot1agCfmMepDbManAddressDomain": {},
"dot1agCfmMepDbPortStatusTlv": {},
"dot1agCfmMepDbRMepFailedOkTime": {},
"dot1agCfmMepDbRMepState": {},
"dot1agCfmMepDbRdi": {},
"dot1agCfmMepDefects": {},
"dot1agCfmMepDirection": {},
"dot1agCfmMepErrorCcmLastFailure": {},
"dot1agCfmMepFngAlarmTime": {},
"dot1agCfmMepFngResetTime": {},
"dot1agCfmMepFngState": {},
"dot1agCfmMepHighestPrDefect": {},
"dot1agCfmMepIfIndex": {},
"dot1agCfmMepLbrBadMsdu": {},
"dot1agCfmMepLbrIn": {},
"dot1agCfmMepLbrInOutOfOrder": {},
"dot1agCfmMepLbrOut": {},
"dot1agCfmMepLowPrDef": {},
"dot1agCfmMepLtmNextSeqNumber": {},
"dot1agCfmMepMacAddress": {},
"dot1agCfmMepNextLbmTransId": {},
"dot1agCfmMepPrimaryVid": {},
"dot1agCfmMepRowStatus": {},
"dot1agCfmMepTransmitLbmDataTlv": {},
"dot1agCfmMepTransmitLbmDestIsMepId": {},
"dot1agCfmMepTransmitLbmDestMacAddress": {},
"dot1agCfmMepTransmitLbmDestMepId": {},
"dot1agCfmMepTransmitLbmMessages": {},
"dot1agCfmMepTransmitLbmResultOK": {},
"dot1agCfmMepTransmitLbmSeqNumber": {},
"dot1agCfmMepTransmitLbmStatus": {},
"dot1agCfmMepTransmitLbmVlanDropEnable": {},
"dot1agCfmMepTransmitLbmVlanPriority": {},
"dot1agCfmMepTransmitLtmEgressIdentifier": {},
"dot1agCfmMepTransmitLtmFlags": {},
"dot1agCfmMepTransmitLtmResult": {},
"dot1agCfmMepTransmitLtmSeqNumber": {},
"dot1agCfmMepTransmitLtmStatus": {},
"dot1agCfmMepTransmitLtmTargetIsMepId": {},
"dot1agCfmMepTransmitLtmTargetMacAddress": {},
"dot1agCfmMepTransmitLtmTargetMepId": {},
"dot1agCfmMepTransmitLtmTtl": {},
"dot1agCfmMepUnexpLtrIn": {},
"dot1agCfmMepXconCcmLastFailure": {},
"dot1agCfmStackMaIndex": {},
"dot1agCfmStackMacAddress": {},
"dot1agCfmStackMdIndex": {},
"dot1agCfmStackMepId": {},
"dot1agCfmVlanPrimaryVid": {},
"dot1agCfmVlanRowStatus": {},
"dot1dBase": {"1": {}, "2": {}, "3": {}},
"dot1dBasePortEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"dot1dSrPortEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dot1dStaticEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"dot1dStp": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dot1dStpPortEntry": {
"1": {},
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dot1dTp": {"1": {}, "2": {}},
"dot1dTpFdbEntry": {"1": {}, "2": {}, "3": {}},
"dot1dTpPortEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"dot10.196.1.1": {},
"dot10.196.1.2": {},
"dot10.196.1.3": {},
"dot10.196.1.4": {},
"dot10.196.1.5": {},
"dot10.196.1.6": {},
"dot3CollEntry": {"3": {}},
"dot3ControlEntry": {"1": {}, "2": {}, "3": {}},
"dot3PauseEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"dot3StatsEntry": {
"1": {},
"10": {},
"11": {},
"13": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dot3adAggActorAdminKey": {},
"dot3adAggActorOperKey": {},
"dot3adAggActorSystemID": {},
"dot3adAggActorSystemPriority": {},
"dot3adAggAggregateOrIndividual": {},
"dot3adAggCollectorMaxDelay": {},
"dot3adAggMACAddress": {},
"dot3adAggPartnerOperKey": {},
"dot3adAggPartnerSystemID": {},
"dot3adAggPartnerSystemPriority": {},
"dot3adAggPortActorAdminKey": {},
"dot3adAggPortActorAdminState": {},
"dot3adAggPortActorOperKey": {},
"dot3adAggPortActorOperState": {},
"dot3adAggPortActorPort": {},
"dot3adAggPortActorPortPriority": {},
"dot3adAggPortActorSystemID": {},
"dot3adAggPortActorSystemPriority": {},
"dot3adAggPortAggregateOrIndividual": {},
"dot3adAggPortAttachedAggID": {},
"dot3adAggPortDebugActorChangeCount": {},
"dot3adAggPortDebugActorChurnCount": {},
"dot3adAggPortDebugActorChurnState": {},
"dot3adAggPortDebugActorSyncTransitionCount": {},
"dot3adAggPortDebugLastRxTime": {},
"dot3adAggPortDebugMuxReason": {},
"dot3adAggPortDebugMuxState": {},
"dot3adAggPortDebugPartnerChangeCount": {},
"dot3adAggPortDebugPartnerChurnCount": {},
"dot3adAggPortDebugPartnerChurnState": {},
"dot3adAggPortDebugPartnerSyncTransitionCount": {},
"dot3adAggPortDebugRxState": {},
"dot3adAggPortListPorts": {},
"dot3adAggPortPartnerAdminKey": {},
"dot3adAggPortPartnerAdminPort": {},
"dot3adAggPortPartnerAdminPortPriority": {},
"dot3adAggPortPartnerAdminState": {},
"dot3adAggPortPartnerAdminSystemID": {},
"dot3adAggPortPartnerAdminSystemPriority": {},
"dot3adAggPortPartnerOperKey": {},
"dot3adAggPortPartnerOperPort": {},
"dot3adAggPortPartnerOperPortPriority": {},
"dot3adAggPortPartnerOperState": {},
"dot3adAggPortPartnerOperSystemID": {},
"dot3adAggPortPartnerOperSystemPriority": {},
"dot3adAggPortSelectedAggID": {},
"dot3adAggPortStatsIllegalRx": {},
"dot3adAggPortStatsLACPDUsRx": {},
"dot3adAggPortStatsLACPDUsTx": {},
"dot3adAggPortStatsMarkerPDUsRx": {},
"dot3adAggPortStatsMarkerPDUsTx": {},
"dot3adAggPortStatsMarkerResponsePDUsRx": {},
"dot3adAggPortStatsMarkerResponsePDUsTx": {},
"dot3adAggPortStatsUnknownRx": {},
"dot3adTablesLastChanged": {},
"dot5Entry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dot5StatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ds10.121.1.1": {},
"ds10.121.1.10": {},
"ds10.121.1.11": {},
"ds10.121.1.12": {},
"ds10.121.1.13": {},
"ds10.121.1.2": {},
"ds10.121.1.3": {},
"ds10.121.1.4": {},
"ds10.121.1.5": {},
"ds10.121.1.6": {},
"ds10.121.1.7": {},
"ds10.121.1.8": {},
"ds10.121.1.9": {},
"ds10.144.1.1": {},
"ds10.144.1.10": {},
"ds10.144.1.11": {},
"ds10.144.1.12": {},
"ds10.144.1.2": {},
"ds10.144.1.3": {},
"ds10.144.1.4": {},
"ds10.144.1.5": {},
"ds10.144.1.6": {},
"ds10.144.1.7": {},
"ds10.144.1.8": {},
"ds10.144.1.9": {},
"ds10.169.1.1": {},
"ds10.169.1.10": {},
"ds10.169.1.2": {},
"ds10.169.1.3": {},
"ds10.169.1.4": {},
"ds10.169.1.5": {},
"ds10.169.1.6": {},
"ds10.169.1.7": {},
"ds10.169.1.8": {},
"ds10.169.1.9": {},
"ds10.34.1.1": {},
"ds10.196.1.7": {},
"dspuLuAdminEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"dspuLuOperEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dspuNode": {
"1": {},
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dspuPoolClassEntry": {"2": {}, "3": {}, "4": {}, "5": {}},
"dspuPooledLuEntry": {"1": {}, "2": {}},
"dspuPuAdminEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dspuPuOperEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dspuPuStatsEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dspuSapEntry": {"2": {}, "6": {}, "7": {}},
"dsx1ConfigEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dsx1CurrentEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dsx1FracEntry": {"1": {}, "2": {}, "3": {}},
"dsx1IntervalEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dsx1TotalEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dsx3ConfigEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dsx3CurrentEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dsx3FracEntry": {"1": {}, "2": {}, "3": {}},
"dsx3IntervalEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"dsx3TotalEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"entAliasMappingEntry": {"2": {}},
"entLPMappingEntry": {"1": {}},
"entLastInconsistencyDetectTime": {},
"entLogicalEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"entPhySensorOperStatus": {},
"entPhySensorPrecision": {},
"entPhySensorScale": {},
"entPhySensorType": {},
"entPhySensorUnitsDisplay": {},
"entPhySensorValue": {},
"entPhySensorValueTimeStamp": {},
"entPhySensorValueUpdateRate": {},
"entPhysicalContainsEntry": {"1": {}},
"entPhysicalEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"entSensorMeasuredEntity": {},
"entSensorPrecision": {},
"entSensorScale": {},
"entSensorStatus": {},
"entSensorThresholdEvaluation": {},
"entSensorThresholdNotificationEnable": {},
"entSensorThresholdRelation": {},
"entSensorThresholdSeverity": {},
"entSensorThresholdValue": {},
"entSensorType": {},
"entSensorValue": {},
"entSensorValueTimeStamp": {},
"entSensorValueUpdateRate": {},
"entStateTable.1.1": {},
"entStateTable.1.2": {},
"entStateTable.1.3": {},
"entStateTable.1.4": {},
"entStateTable.1.5": {},
"entStateTable.1.6": {},
"enterprises.310.49.6.10.10.25.1.1": {},
"enterprises.310.49.6.1.10.4.1.2": {},
"enterprises.310.49.6.1.10.4.1.3": {},
"enterprises.310.49.6.1.10.4.1.4": {},
"enterprises.310.49.6.1.10.4.1.5": {},
"enterprises.310.49.6.1.10.4.1.6": {},
"enterprises.310.49.6.1.10.4.1.7": {},
"enterprises.310.49.6.1.10.4.1.8": {},
"enterprises.310.49.6.1.10.4.1.9": {},
"enterprises.310.49.6.1.10.9.1.1": {},
"enterprises.310.49.6.1.10.9.1.10": {},
"enterprises.310.49.6.1.10.9.1.11": {},
"enterprises.310.49.6.1.10.9.1.12": {},
"enterprises.310.49.6.1.10.9.1.13": {},
"enterprises.310.49.6.1.10.9.1.14": {},
"enterprises.310.49.6.1.10.9.1.2": {},
"enterprises.310.49.6.1.10.9.1.3": {},
"enterprises.310.49.6.1.10.9.1.4": {},
"enterprises.310.49.6.1.10.9.1.5": {},
"enterprises.310.49.6.1.10.9.1.6": {},
"enterprises.310.49.6.1.10.9.1.7": {},
"enterprises.310.49.6.1.10.9.1.8": {},
"enterprises.310.49.6.1.10.9.1.9": {},
"enterprises.310.49.6.1.10.16.1.10": {},
"enterprises.310.49.6.1.10.16.1.11": {},
"enterprises.310.49.6.1.10.16.1.12": {},
"enterprises.310.49.6.1.10.16.1.13": {},
"enterprises.310.49.6.1.10.16.1.14": {},
"enterprises.310.49.6.1.10.16.1.3": {},
"enterprises.310.49.6.1.10.16.1.4": {},
"enterprises.310.49.6.1.10.16.1.5": {},
"enterprises.310.49.6.1.10.16.1.6": {},
"enterprises.310.49.6.1.10.16.1.7": {},
"enterprises.310.49.6.1.10.16.1.8": {},
"enterprises.310.49.6.1.10.16.1.9": {},
"entityGeneral": {"1": {}},
"etherWisDeviceRxTestPatternErrors": {},
"etherWisDeviceRxTestPatternMode": {},
"etherWisDeviceTxTestPatternMode": {},
"etherWisFarEndPathCurrentStatus": {},
"etherWisPathCurrentJ1Received": {},
"etherWisPathCurrentJ1Transmitted": {},
"etherWisPathCurrentStatus": {},
"etherWisSectionCurrentJ0Received": {},
"etherWisSectionCurrentJ0Transmitted": {},
"eventEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"faAdmProhibited": {},
"faCOAStatus": {},
"faEncapsulationUnavailable": {},
"faHAAuthenticationFailure": {},
"faHAUnreachable": {},
"faInsufficientResource": {},
"faMNAuthenticationFailure": {},
"faPoorlyFormedReplies": {},
"faPoorlyFormedRequests": {},
"faReasonUnspecified": {},
"faRegLifetimeTooLong": {},
"faRegRepliesRecieved": {},
"faRegRepliesRelayed": {},
"faRegRequestsReceived": {},
"faRegRequestsRelayed": {},
"faVisitorHomeAddress": {},
"faVisitorHomeAgentAddress": {},
"faVisitorIPAddress": {},
"faVisitorRegFlags": {},
"faVisitorRegIDHigh": {},
"faVisitorRegIDLow": {},
"faVisitorRegIsAccepted": {},
"faVisitorTimeGranted": {},
"faVisitorTimeRemaining": {},
"frCircuitEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"frDlcmiEntry": {
"1": {},
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"frTrapState": {},
"frasBanLlc": {},
"frasBanSdlc": {},
"frasBnnLlc": {},
"frasBnnSdlc": {},
"haAdmProhibited": {},
"haDeRegRepliesSent": {},
"haDeRegRequestsReceived": {},
"haFAAuthenticationFailure": {},
"haGratuitiousARPsSent": {},
"haIDMismatch": {},
"haInsufficientResource": {},
"haMNAuthenticationFailure": {},
"haMobilityBindingCOA": {},
"haMobilityBindingMN": {},
"haMobilityBindingRegFlags": {},
"haMobilityBindingRegIDHigh": {},
"haMobilityBindingRegIDLow": {},
"haMobilityBindingSourceAddress": {},
"haMobilityBindingTimeGranted": {},
"haMobilityBindingTimeRemaining": {},
"haMultiBindingUnsupported": {},
"haOverallServiceTime": {},
"haPoorlyFormedRequest": {},
"haProxyARPsSent": {},
"haReasonUnspecified": {},
"haRecentServiceAcceptedTime": {},
"haRecentServiceDeniedCode": {},
"haRecentServiceDeniedTime": {},
"haRegRepliesSent": {},
"haRegRequestsReceived": {},
"haRegistrationAccepted": {},
"haServiceRequestsAccepted": {},
"haServiceRequestsDenied": {},
"haTooManyBindings": {},
"haUnknownHA": {},
"hcAlarmAbsValue": {},
"hcAlarmCapabilities": {},
"hcAlarmFallingEventIndex": {},
"hcAlarmFallingThreshAbsValueHi": {},
"hcAlarmFallingThreshAbsValueLo": {},
"hcAlarmFallingThresholdValStatus": {},
"hcAlarmInterval": {},
"hcAlarmOwner": {},
"hcAlarmRisingEventIndex": {},
"hcAlarmRisingThreshAbsValueHi": {},
"hcAlarmRisingThreshAbsValueLo": {},
"hcAlarmRisingThresholdValStatus": {},
"hcAlarmSampleType": {},
"hcAlarmStartupAlarm": {},
"hcAlarmStatus": {},
"hcAlarmStorageType": {},
"hcAlarmValueFailedAttempts": {},
"hcAlarmValueStatus": {},
"hcAlarmVariable": {},
"icmp": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"icmpMsgStatsEntry": {"3": {}, "4": {}},
"icmpStatsEntry": {"2": {}, "3": {}, "4": {}, "5": {}},
"ieee8021CfmConfigErrorListErrorType": {},
"ieee8021CfmDefaultMdIdPermission": {},
"ieee8021CfmDefaultMdLevel": {},
"ieee8021CfmDefaultMdMhfCreation": {},
"ieee8021CfmDefaultMdStatus": {},
"ieee8021CfmMaCompIdPermission": {},
"ieee8021CfmMaCompMhfCreation": {},
"ieee8021CfmMaCompNumberOfVids": {},
"ieee8021CfmMaCompPrimarySelectorOrNone": {},
"ieee8021CfmMaCompPrimarySelectorType": {},
"ieee8021CfmMaCompRowStatus": {},
"ieee8021CfmStackMaIndex": {},
"ieee8021CfmStackMacAddress": {},
"ieee8021CfmStackMdIndex": {},
"ieee8021CfmStackMepId": {},
"ieee8021CfmVlanPrimarySelector": {},
"ieee8021CfmVlanRowStatus": {},
"ifAdminStatus": {},
"ifAlias": {},
"ifConnectorPresent": {},
"ifCounterDiscontinuityTime": {},
"ifDescr": {},
"ifHCInBroadcastPkts": {},
"ifHCInMulticastPkts": {},
"ifHCInOctets": {},
"ifHCInUcastPkts": {},
"ifHCOutBroadcastPkts": {},
"ifHCOutMulticastPkts": {},
"ifHCOutOctets": {},
"ifHCOutUcastPkts": {},
"ifHighSpeed": {},
"ifInBroadcastPkts": {},
"ifInDiscards": {},
"ifInErrors": {},
"ifInMulticastPkts": {},
"ifInNUcastPkts": {},
"ifInOctets": {},
"ifInUcastPkts": {},
"ifInUnknownProtos": {},
"ifIndex": {},
"ifLastChange": {},
"ifLinkUpDownTrapEnable": {},
"ifMtu": {},
"ifName": {},
"ifNumber": {},
"ifOperStatus": {},
"ifOutBroadcastPkts": {},
"ifOutDiscards": {},
"ifOutErrors": {},
"ifOutMulticastPkts": {},
"ifOutNUcastPkts": {},
"ifOutOctets": {},
"ifOutQLen": {},
"ifOutUcastPkts": {},
"ifPhysAddress": {},
"ifPromiscuousMode": {},
"ifRcvAddressStatus": {},
"ifRcvAddressType": {},
"ifSpecific": {},
"ifSpeed": {},
"ifStackLastChange": {},
"ifStackStatus": {},
"ifTableLastChange": {},
"ifTestCode": {},
"ifTestId": {},
"ifTestOwner": {},
"ifTestResult": {},
"ifTestStatus": {},
"ifTestType": {},
"ifType": {},
"igmpCacheEntry": {"3": {}, "4": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"igmpInterfaceEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"inetCidrRouteEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"7": {},
"8": {},
"9": {},
},
"intSrvFlowEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"intSrvGenObjects": {"1": {}},
"intSrvGuaranteedIfEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"intSrvIfAttribEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"ip": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"23": {},
"25": {},
"26": {},
"27": {},
"29": {},
"3": {},
"33": {},
"38": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipAddrEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"ipAddressEntry": {
"10": {},
"11": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipAddressPrefixEntry": {"5": {}, "6": {}, "7": {}, "8": {}, "9": {}},
"ipCidrRouteEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipDefaultRouterEntry": {"4": {}, "5": {}},
"ipForward": {"3": {}, "6": {}},
"ipIfStatsEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"37": {},
"38": {},
"39": {},
"4": {},
"40": {},
"41": {},
"42": {},
"43": {},
"44": {},
"45": {},
"46": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipMRoute": {"1": {}, "7": {}},
"ipMRouteBoundaryEntry": {"4": {}},
"ipMRouteEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipMRouteInterfaceEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ipMRouteNextHopEntry": {"10": {}, "11": {}, "6": {}, "7": {}, "8": {}, "9": {}},
"ipMRouteScopeNameEntry": {"4": {}, "5": {}, "6": {}},
"ipNetToMediaEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"ipNetToPhysicalEntry": {"4": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"ipSystemStatsEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"37": {},
"38": {},
"39": {},
"4": {},
"40": {},
"41": {},
"42": {},
"43": {},
"44": {},
"45": {},
"46": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipTrafficStats": {"2": {}},
"ipslaEtherJAggMaxSucFrmLoss": {},
"ipslaEtherJAggMeasuredAvgJ": {},
"ipslaEtherJAggMeasuredAvgJDS": {},
"ipslaEtherJAggMeasuredAvgJSD": {},
"ipslaEtherJAggMeasuredAvgLossDenominatorDS": {},
"ipslaEtherJAggMeasuredAvgLossDenominatorSD": {},
"ipslaEtherJAggMeasuredAvgLossNumeratorDS": {},
"ipslaEtherJAggMeasuredAvgLossNumeratorSD": {},
"ipslaEtherJAggMeasuredBusies": {},
"ipslaEtherJAggMeasuredCmpletions": {},
"ipslaEtherJAggMeasuredCumulativeAvgLossDenominatorDS": {},
"ipslaEtherJAggMeasuredCumulativeAvgLossDenominatorSD": {},
"ipslaEtherJAggMeasuredCumulativeAvgLossNumeratorDS": {},
"ipslaEtherJAggMeasuredCumulativeAvgLossNumeratorSD": {},
"ipslaEtherJAggMeasuredCumulativeLossDenominatorDS": {},
"ipslaEtherJAggMeasuredCumulativeLossDenominatorSD": {},
"ipslaEtherJAggMeasuredCumulativeLossNumeratorDS": {},
"ipslaEtherJAggMeasuredCumulativeLossNumeratorSD": {},
"ipslaEtherJAggMeasuredErrors": {},
"ipslaEtherJAggMeasuredFrmLateAs": {},
"ipslaEtherJAggMeasuredFrmLossSDs": {},
"ipslaEtherJAggMeasuredFrmLssDSes": {},
"ipslaEtherJAggMeasuredFrmMIAes": {},
"ipslaEtherJAggMeasuredFrmOutSeqs": {},
"ipslaEtherJAggMeasuredFrmSkippds": {},
"ipslaEtherJAggMeasuredFrmUnPrcds": {},
"ipslaEtherJAggMeasuredIAJIn": {},
"ipslaEtherJAggMeasuredIAJOut": {},
"ipslaEtherJAggMeasuredMaxLossDenominatorDS": {},
"ipslaEtherJAggMeasuredMaxLossDenominatorSD": {},
"ipslaEtherJAggMeasuredMaxLossNumeratorDS": {},
"ipslaEtherJAggMeasuredMaxLossNumeratorSD": {},
"ipslaEtherJAggMeasuredMaxNegDS": {},
"ipslaEtherJAggMeasuredMaxNegSD": {},
"ipslaEtherJAggMeasuredMaxNegTW": {},
"ipslaEtherJAggMeasuredMaxPosDS": {},
"ipslaEtherJAggMeasuredMaxPosSD": {},
"ipslaEtherJAggMeasuredMaxPosTW": {},
"ipslaEtherJAggMeasuredMinLossDenominatorDS": {},
"ipslaEtherJAggMeasuredMinLossDenominatorSD": {},
"ipslaEtherJAggMeasuredMinLossNumeratorDS": {},
"ipslaEtherJAggMeasuredMinLossNumeratorSD": {},
"ipslaEtherJAggMeasuredMinNegDS": {},
"ipslaEtherJAggMeasuredMinNegSD": {},
"ipslaEtherJAggMeasuredMinNegTW": {},
"ipslaEtherJAggMeasuredMinPosDS": {},
"ipslaEtherJAggMeasuredMinPosSD": {},
"ipslaEtherJAggMeasuredMinPosTW": {},
"ipslaEtherJAggMeasuredNumNegDSes": {},
"ipslaEtherJAggMeasuredNumNegSDs": {},
"ipslaEtherJAggMeasuredNumOWs": {},
"ipslaEtherJAggMeasuredNumOverThresh": {},
"ipslaEtherJAggMeasuredNumPosDSes": {},
"ipslaEtherJAggMeasuredNumPosSDs": {},
"ipslaEtherJAggMeasuredNumRTTs": {},
"ipslaEtherJAggMeasuredOWMaxDS": {},
"ipslaEtherJAggMeasuredOWMaxSD": {},
"ipslaEtherJAggMeasuredOWMinDS": {},
"ipslaEtherJAggMeasuredOWMinSD": {},
"ipslaEtherJAggMeasuredOWSum2DSHs": {},
"ipslaEtherJAggMeasuredOWSum2DSLs": {},
"ipslaEtherJAggMeasuredOWSum2SDHs": {},
"ipslaEtherJAggMeasuredOWSum2SDLs": {},
"ipslaEtherJAggMeasuredOWSumDSes": {},
"ipslaEtherJAggMeasuredOWSumSDs": {},
"ipslaEtherJAggMeasuredOvThrshlds": {},
"ipslaEtherJAggMeasuredRTTMax": {},
"ipslaEtherJAggMeasuredRTTMin": {},
"ipslaEtherJAggMeasuredRTTSum2Hs": {},
"ipslaEtherJAggMeasuredRTTSum2Ls": {},
"ipslaEtherJAggMeasuredRTTSums": {},
"ipslaEtherJAggMeasuredRxFrmsDS": {},
"ipslaEtherJAggMeasuredRxFrmsSD": {},
"ipslaEtherJAggMeasuredSum2NDSHs": {},
"ipslaEtherJAggMeasuredSum2NDSLs": {},
"ipslaEtherJAggMeasuredSum2NSDHs": {},
"ipslaEtherJAggMeasuredSum2NSDLs": {},
"ipslaEtherJAggMeasuredSum2PDSHs": {},
"ipslaEtherJAggMeasuredSum2PDSLs": {},
"ipslaEtherJAggMeasuredSum2PSDHs": {},
"ipslaEtherJAggMeasuredSum2PSDLs": {},
"ipslaEtherJAggMeasuredSumNegDSes": {},
"ipslaEtherJAggMeasuredSumNegSDs": {},
"ipslaEtherJAggMeasuredSumPosDSes": {},
"ipslaEtherJAggMeasuredSumPosSDs": {},
"ipslaEtherJAggMeasuredTxFrmsDS": {},
"ipslaEtherJAggMeasuredTxFrmsSD": {},
"ipslaEtherJAggMinSucFrmLoss": {},
"ipslaEtherJLatestFrmUnProcessed": {},
"ipslaEtherJitterLatestAvgDSJ": {},
"ipslaEtherJitterLatestAvgJitter": {},
"ipslaEtherJitterLatestAvgSDJ": {},
"ipslaEtherJitterLatestFrmLateA": {},
"ipslaEtherJitterLatestFrmLossDS": {},
"ipslaEtherJitterLatestFrmLossSD": {},
"ipslaEtherJitterLatestFrmMIA": {},
"ipslaEtherJitterLatestFrmOutSeq": {},
"ipslaEtherJitterLatestFrmSkipped": {},
"ipslaEtherJitterLatestIAJIn": {},
"ipslaEtherJitterLatestIAJOut": {},
"ipslaEtherJitterLatestMaxNegDS": {},
"ipslaEtherJitterLatestMaxNegSD": {},
"ipslaEtherJitterLatestMaxPosDS": {},
"ipslaEtherJitterLatestMaxPosSD": {},
"ipslaEtherJitterLatestMaxSucFrmL": {},
"ipslaEtherJitterLatestMinNegDS": {},
"ipslaEtherJitterLatestMinNegSD": {},
"ipslaEtherJitterLatestMinPosDS": {},
"ipslaEtherJitterLatestMinPosSD": {},
"ipslaEtherJitterLatestMinSucFrmL": {},
"ipslaEtherJitterLatestNumNegDS": {},
"ipslaEtherJitterLatestNumNegSD": {},
"ipslaEtherJitterLatestNumOW": {},
"ipslaEtherJitterLatestNumOverThresh": {},
"ipslaEtherJitterLatestNumPosDS": {},
"ipslaEtherJitterLatestNumPosSD": {},
"ipslaEtherJitterLatestNumRTT": {},
"ipslaEtherJitterLatestOWAvgDS": {},
"ipslaEtherJitterLatestOWAvgSD": {},
"ipslaEtherJitterLatestOWMaxDS": {},
"ipslaEtherJitterLatestOWMaxSD": {},
"ipslaEtherJitterLatestOWMinDS": {},
"ipslaEtherJitterLatestOWMinSD": {},
"ipslaEtherJitterLatestOWSum2DS": {},
"ipslaEtherJitterLatestOWSum2SD": {},
"ipslaEtherJitterLatestOWSumDS": {},
"ipslaEtherJitterLatestOWSumSD": {},
"ipslaEtherJitterLatestRTTMax": {},
"ipslaEtherJitterLatestRTTMin": {},
"ipslaEtherJitterLatestRTTSum": {},
"ipslaEtherJitterLatestRTTSum2": {},
"ipslaEtherJitterLatestSense": {},
"ipslaEtherJitterLatestSum2NegDS": {},
"ipslaEtherJitterLatestSum2NegSD": {},
"ipslaEtherJitterLatestSum2PosDS": {},
"ipslaEtherJitterLatestSum2PosSD": {},
"ipslaEtherJitterLatestSumNegDS": {},
"ipslaEtherJitterLatestSumNegSD": {},
"ipslaEtherJitterLatestSumPosDS": {},
"ipslaEtherJitterLatestSumPosSD": {},
"ipslaEthernetGrpCtrlCOS": {},
"ipslaEthernetGrpCtrlDomainName": {},
"ipslaEthernetGrpCtrlDomainNameType": {},
"ipslaEthernetGrpCtrlEntry": {"21": {}, "22": {}},
"ipslaEthernetGrpCtrlInterval": {},
"ipslaEthernetGrpCtrlMPIDExLst": {},
"ipslaEthernetGrpCtrlNumFrames": {},
"ipslaEthernetGrpCtrlOwner": {},
"ipslaEthernetGrpCtrlProbeList": {},
"ipslaEthernetGrpCtrlReqDataSize": {},
"ipslaEthernetGrpCtrlRttType": {},
"ipslaEthernetGrpCtrlStatus": {},
"ipslaEthernetGrpCtrlStorageType": {},
"ipslaEthernetGrpCtrlTag": {},
"ipslaEthernetGrpCtrlThreshold": {},
"ipslaEthernetGrpCtrlTimeout": {},
"ipslaEthernetGrpCtrlVLAN": {},
"ipslaEthernetGrpReactActionType": {},
"ipslaEthernetGrpReactStatus": {},
"ipslaEthernetGrpReactStorageType": {},
"ipslaEthernetGrpReactThresholdCountX": {},
"ipslaEthernetGrpReactThresholdCountY": {},
"ipslaEthernetGrpReactThresholdFalling": {},
"ipslaEthernetGrpReactThresholdRising": {},
"ipslaEthernetGrpReactThresholdType": {},
"ipslaEthernetGrpReactVar": {},
"ipslaEthernetGrpScheduleFrequency": {},
"ipslaEthernetGrpSchedulePeriod": {},
"ipslaEthernetGrpScheduleRttStartTime": {},
"ipv4InterfaceEntry": {"2": {}, "3": {}, "4": {}},
"ipv6InterfaceEntry": {"2": {}, "3": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"ipv6RouterAdvertEntry": {
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipv6ScopeZoneIndexEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipxAdvSysEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipxBasicSysEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipxCircEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ipxDestEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ipxDestServEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ipxServEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ipxStaticRouteEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"ipxStaticServEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"isdnBasicRateEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"isdnBearerEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"isdnDirectoryEntry": {"2": {}, "3": {}, "4": {}},
"isdnEndpointEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"isdnEndpointGetIndex": {},
"isdnMib.10.16.4.1.1": {},
"isdnMib.10.16.4.1.2": {},
"isdnMib.10.16.4.1.3": {},
"isdnMib.10.16.4.1.4": {},
"isdnSignalingEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"isdnSignalingGetIndex": {},
"isdnSignalingStatsEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"lapbAdmnEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"lapbFlowEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"lapbOperEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"lapbXidEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"lifEntry": {
"1": {},
"10": {},
"100": {},
"101": {},
"102": {},
"103": {},
"104": {},
"105": {},
"106": {},
"107": {},
"108": {},
"109": {},
"11": {},
"110": {},
"111": {},
"112": {},
"113": {},
"114": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"3": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"37": {},
"38": {},
"39": {},
"4": {},
"40": {},
"41": {},
"42": {},
"43": {},
"44": {},
"45": {},
"46": {},
"47": {},
"48": {},
"49": {},
"5": {},
"50": {},
"51": {},
"52": {},
"53": {},
"54": {},
"55": {},
"56": {},
"57": {},
"58": {},
"59": {},
"6": {},
"60": {},
"61": {},
"62": {},
"63": {},
"64": {},
"65": {},
"66": {},
"67": {},
"68": {},
"69": {},
"7": {},
"70": {},
"71": {},
"72": {},
"73": {},
"74": {},
"75": {},
"76": {},
"77": {},
"78": {},
"79": {},
"8": {},
"80": {},
"81": {},
"82": {},
"83": {},
"84": {},
"85": {},
"86": {},
"87": {},
"88": {},
"89": {},
"9": {},
"90": {},
"91": {},
"92": {},
"93": {},
"94": {},
"95": {},
"96": {},
"97": {},
"98": {},
"99": {},
},
"lip": {"10": {}, "11": {}, "12": {}, "4": {}, "5": {}, "6": {}, "8": {}},
"lipAccountEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"lipAddrEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"lipCkAccountEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"lipRouteEntry": {"1": {}, "2": {}, "3": {}},
"lipxAccountingEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"lipxCkAccountingEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"lispConfiguredLocatorRlocLocal": {},
"lispConfiguredLocatorRlocState": {},
"lispConfiguredLocatorRlocTimeStamp": {},
"lispEidRegistrationAuthenticationErrors": {},
"lispEidRegistrationEtrLastTimeStamp": {},
"lispEidRegistrationEtrProxyReply": {},
"lispEidRegistrationEtrTtl": {},
"lispEidRegistrationEtrWantsMapNotify": {},
"lispEidRegistrationFirstTimeStamp": {},
"lispEidRegistrationIsRegistered": {},
"lispEidRegistrationLastRegisterSender": {},
"lispEidRegistrationLastRegisterSenderLength": {},
"lispEidRegistrationLastTimeStamp": {},
"lispEidRegistrationLocatorIsLocal": {},
"lispEidRegistrationLocatorMPriority": {},
"lispEidRegistrationLocatorMWeight": {},
"lispEidRegistrationLocatorPriority": {},
"lispEidRegistrationLocatorRlocState": {},
"lispEidRegistrationLocatorWeight": {},
"lispEidRegistrationRlocsMismatch": {},
"lispEidRegistrationSiteDescription": {},
"lispEidRegistrationSiteName": {},
"lispFeaturesEtrAcceptMapDataEnabled": {},
"lispFeaturesEtrAcceptMapDataVerifyEnabled": {},
"lispFeaturesEtrEnabled": {},
"lispFeaturesEtrMapCacheTtl": {},
"lispFeaturesItrEnabled": {},
"lispFeaturesMapCacheLimit": {},
"lispFeaturesMapCacheSize": {},
"lispFeaturesMapResolverEnabled": {},
"lispFeaturesMapServerEnabled": {},
"lispFeaturesProxyEtrEnabled": {},
"lispFeaturesProxyItrEnabled": {},
"lispFeaturesRlocProbeEnabled": {},
"lispFeaturesRouterTimeStamp": {},
"lispGlobalStatsMapRegistersIn": {},
"lispGlobalStatsMapRegistersOut": {},
"lispGlobalStatsMapRepliesIn": {},
"lispGlobalStatsMapRepliesOut": {},
"lispGlobalStatsMapRequestsIn": {},
"lispGlobalStatsMapRequestsOut": {},
"lispIidToVrfName": {},
"lispMapCacheEidAuthoritative": {},
"lispMapCacheEidEncapOctets": {},
"lispMapCacheEidEncapPackets": {},
"lispMapCacheEidExpiryTime": {},
"lispMapCacheEidState": {},
"lispMapCacheEidTimeStamp": {},
"lispMapCacheLocatorRlocLastMPriorityChange": {},
"lispMapCacheLocatorRlocLastMWeightChange": {},
"lispMapCacheLocatorRlocLastPriorityChange": {},
"lispMapCacheLocatorRlocLastStateChange": {},
"lispMapCacheLocatorRlocLastWeightChange": {},
"lispMapCacheLocatorRlocMPriority": {},
"lispMapCacheLocatorRlocMWeight": {},
"lispMapCacheLocatorRlocPriority": {},
"lispMapCacheLocatorRlocRtt": {},
"lispMapCacheLocatorRlocState": {},
"lispMapCacheLocatorRlocTimeStamp": {},
"lispMapCacheLocatorRlocWeight": {},
"lispMappingDatabaseEidPartitioned": {},
"lispMappingDatabaseLocatorRlocLocal": {},
"lispMappingDatabaseLocatorRlocMPriority": {},
"lispMappingDatabaseLocatorRlocMWeight": {},
"lispMappingDatabaseLocatorRlocPriority": {},
"lispMappingDatabaseLocatorRlocState": {},
"lispMappingDatabaseLocatorRlocTimeStamp": {},
"lispMappingDatabaseLocatorRlocWeight": {},
"lispMappingDatabaseLsb": {},
"lispMappingDatabaseTimeStamp": {},
"lispUseMapResolverState": {},
"lispUseMapServerState": {},
"lispUseProxyEtrMPriority": {},
"lispUseProxyEtrMWeight": {},
"lispUseProxyEtrPriority": {},
"lispUseProxyEtrState": {},
"lispUseProxyEtrWeight": {},
"lldpLocManAddrEntry": {"3": {}, "4": {}, "5": {}, "6": {}},
"lldpLocPortEntry": {"2": {}, "3": {}, "4": {}},
"lldpLocalSystemData": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"lldpRemEntry": {
"10": {},
"11": {},
"12": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"lldpRemManAddrEntry": {"3": {}, "4": {}, "5": {}},
"lldpRemOrgDefInfoEntry": {"4": {}},
"lldpRemUnknownTLVEntry": {"2": {}},
"logEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"lsystem": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"37": {},
"38": {},
"39": {},
"4": {},
"40": {},
"41": {},
"42": {},
"43": {},
"44": {},
"45": {},
"46": {},
"47": {},
"48": {},
"49": {},
"5": {},
"50": {},
"51": {},
"52": {},
"53": {},
"54": {},
"55": {},
"56": {},
"57": {},
"58": {},
"59": {},
"6": {},
"60": {},
"61": {},
"62": {},
"63": {},
"64": {},
"65": {},
"66": {},
"67": {},
"68": {},
"69": {},
"70": {},
"71": {},
"72": {},
"73": {},
"74": {},
"75": {},
"76": {},
"8": {},
"9": {},
},
"ltcpConnEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"lts": {"1": {}, "10": {}, "4": {}, "5": {}, "6": {}, "7": {}, "8": {}, "9": {}},
"ltsLineEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ltsLineSessionEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"maAdvAddress": {},
"maAdvMaxAdvLifetime": {},
"maAdvMaxInterval": {},
"maAdvMaxRegLifetime": {},
"maAdvMinInterval": {},
"maAdvPrefixLengthInclusion": {},
"maAdvResponseSolicitationOnly": {},
"maAdvStatus": {},
"maAdvertisementsSent": {},
"maAdvsSentForSolicitation": {},
"maSolicitationsReceived": {},
"mfrBundleActivationClass": {},
"mfrBundleBandwidth": {},
"mfrBundleCountMaxRetry": {},
"mfrBundleFarEndName": {},
"mfrBundleFragmentation": {},
"mfrBundleIfIndex": {},
"mfrBundleIfIndexMappingIndex": {},
"mfrBundleLinkConfigBundleIndex": {},
"mfrBundleLinkDelay": {},
"mfrBundleLinkFarEndBundleName": {},
"mfrBundleLinkFarEndName": {},
"mfrBundleLinkFramesControlInvalid": {},
"mfrBundleLinkFramesControlRx": {},
"mfrBundleLinkFramesControlTx": {},
"mfrBundleLinkLoopbackSuspected": {},
"mfrBundleLinkMismatch": {},
"mfrBundleLinkNearEndName": {},
"mfrBundleLinkRowStatus": {},
"mfrBundleLinkState": {},
"mfrBundleLinkTimerExpiredCount": {},
"mfrBundleLinkUnexpectedSequence": {},
"mfrBundleLinksActive": {},
"mfrBundleLinksConfigured": {},
"mfrBundleMaxBundleLinks": {},
"mfrBundleMaxDiffDelay": {},
"mfrBundleMaxFragSize": {},
"mfrBundleMaxNumBundles": {},
"mfrBundleNearEndName": {},
"mfrBundleNextIndex": {},
"mfrBundleResequencingErrors": {},
"mfrBundleRowStatus": {},
"mfrBundleSeqNumSize": {},
"mfrBundleThreshold": {},
"mfrBundleTimerAck": {},
"mfrBundleTimerHello": {},
"mgmdHostCacheLastReporter": {},
"mgmdHostCacheSourceFilterMode": {},
"mgmdHostCacheUpTime": {},
"mgmdHostInterfaceQuerier": {},
"mgmdHostInterfaceStatus": {},
"mgmdHostInterfaceVersion": {},
"mgmdHostInterfaceVersion1QuerierTimer": {},
"mgmdHostInterfaceVersion2QuerierTimer": {},
"mgmdHostInterfaceVersion3Robustness": {},
"mgmdHostSrcListExpire": {},
"mgmdInverseHostCacheAddress": {},
"mgmdInverseRouterCacheAddress": {},
"mgmdRouterCacheExcludeModeExpiryTimer": {},
"mgmdRouterCacheExpiryTime": {},
"mgmdRouterCacheLastReporter": {},
"mgmdRouterCacheSourceFilterMode": {},
"mgmdRouterCacheUpTime": {},
"mgmdRouterCacheVersion1HostTimer": {},
"mgmdRouterCacheVersion2HostTimer": {},
"mgmdRouterInterfaceGroups": {},
"mgmdRouterInterfaceJoins": {},
"mgmdRouterInterfaceLastMemberQueryCount": {},
"mgmdRouterInterfaceLastMemberQueryInterval": {},
"mgmdRouterInterfaceProxyIfIndex": {},
"mgmdRouterInterfaceQuerier": {},
"mgmdRouterInterfaceQuerierExpiryTime": {},
"mgmdRouterInterfaceQuerierUpTime": {},
"mgmdRouterInterfaceQueryInterval": {},
"mgmdRouterInterfaceQueryMaxResponseTime": {},
"mgmdRouterInterfaceRobustness": {},
"mgmdRouterInterfaceStartupQueryCount": {},
"mgmdRouterInterfaceStartupQueryInterval": {},
"mgmdRouterInterfaceStatus": {},
"mgmdRouterInterfaceVersion": {},
"mgmdRouterInterfaceWrongVersionQueries": {},
"mgmdRouterSrcListExpire": {},
"mib-10.49.1.1.1": {},
"mib-10.49.1.1.2": {},
"mib-10.49.1.1.3": {},
"mib-10.49.1.1.4": {},
"mib-10.49.1.1.5": {},
"mib-10.49.1.2.1.1.3": {},
"mib-10.49.1.2.1.1.4": {},
"mib-10.49.1.2.1.1.5": {},
"mib-10.49.1.2.1.1.6": {},
"mib-10.49.1.2.1.1.7": {},
"mib-10.49.1.2.1.1.8": {},
"mib-10.49.1.2.1.1.9": {},
"mib-10.49.1.2.2.1.1": {},
"mib-10.49.1.2.2.1.2": {},
"mib-10.49.1.2.2.1.3": {},
"mib-10.49.1.2.2.1.4": {},
"mib-10.49.1.2.3.1.10": {},
"mib-10.49.1.2.3.1.2": {},
"mib-10.49.1.2.3.1.3": {},
"mib-10.49.1.2.3.1.4": {},
"mib-10.49.1.2.3.1.5": {},
"mib-10.49.1.2.3.1.6": {},
"mib-10.49.1.2.3.1.7": {},
"mib-10.49.1.2.3.1.8": {},
"mib-10.49.1.2.3.1.9": {},
"mib-10.49.1.3.1.1.2": {},
"mib-10.49.1.3.1.1.3": {},
"mib-10.49.1.3.1.1.4": {},
"mib-10.49.1.3.1.1.5": {},
"mib-10.49.1.3.1.1.6": {},
"mib-10.49.1.3.1.1.7": {},
"mib-10.49.1.3.1.1.8": {},
"mib-10.49.1.3.1.1.9": {},
"mipEnable": {},
"mipEncapsulationSupported": {},
"mipEntities": {},
"mipSecAlgorithmMode": {},
"mipSecAlgorithmType": {},
"mipSecKey": {},
"mipSecRecentViolationIDHigh": {},
"mipSecRecentViolationIDLow": {},
"mipSecRecentViolationReason": {},
"mipSecRecentViolationSPI": {},
"mipSecRecentViolationTime": {},
"mipSecReplayMethod": {},
"mipSecTotalViolations": {},
"mipSecViolationCounter": {},
"mipSecViolatorAddress": {},
"mnAdvFlags": {},
"mnAdvMaxAdvLifetime": {},
"mnAdvMaxRegLifetime": {},
"mnAdvSequence": {},
"mnAdvSourceAddress": {},
"mnAdvTimeReceived": {},
"mnAdvertisementsReceived": {},
"mnAdvsDroppedInvalidExtension": {},
"mnAdvsIgnoredUnknownExtension": {},
"mnAgentRebootsDectected": {},
"mnCOA": {},
"mnCOAIsLocal": {},
"mnCurrentHA": {},
"mnDeRegRepliesRecieved": {},
"mnDeRegRequestsSent": {},
"mnFAAddress": {},
"mnGratuitousARPsSend": {},
"mnHAStatus": {},
"mnHomeAddress": {},
"mnMoveFromFAToFA": {},
"mnMoveFromFAToHA": {},
"mnMoveFromHAToFA": {},
"mnRegAgentAddress": {},
"mnRegCOA": {},
"mnRegFlags": {},
"mnRegIDHigh": {},
"mnRegIDLow": {},
"mnRegIsAccepted": {},
"mnRegRepliesRecieved": {},
"mnRegRequestsAccepted": {},
"mnRegRequestsDeniedByFA": {},
"mnRegRequestsDeniedByHA": {},
"mnRegRequestsDeniedByHADueToID": {},
"mnRegRequestsSent": {},
"mnRegTimeRemaining": {},
"mnRegTimeRequested": {},
"mnRegTimeSent": {},
"mnRepliesDroppedInvalidExtension": {},
"mnRepliesFAAuthenticationFailure": {},
"mnRepliesHAAuthenticationFailure": {},
"mnRepliesIgnoredUnknownExtension": {},
"mnRepliesInvalidHomeAddress": {},
"mnRepliesInvalidID": {},
"mnRepliesUnknownFA": {},
"mnRepliesUnknownHA": {},
"mnSolicitationsSent": {},
"mnState": {},
"mplsFecAddr": {},
"mplsFecAddrPrefixLength": {},
"mplsFecAddrType": {},
"mplsFecIndexNext": {},
"mplsFecLastChange": {},
"mplsFecRowStatus": {},
"mplsFecStorageType": {},
"mplsFecType": {},
"mplsInSegmentAddrFamily": {},
"mplsInSegmentIndexNext": {},
"mplsInSegmentInterface": {},
"mplsInSegmentLabel": {},
"mplsInSegmentLabelPtr": {},
"mplsInSegmentLdpLspLabelType": {},
"mplsInSegmentLdpLspType": {},
"mplsInSegmentMapIndex": {},
"mplsInSegmentNPop": {},
"mplsInSegmentOwner": {},
"mplsInSegmentPerfDiscards": {},
"mplsInSegmentPerfDiscontinuityTime": {},
"mplsInSegmentPerfErrors": {},
"mplsInSegmentPerfHCOctets": {},
"mplsInSegmentPerfOctets": {},
"mplsInSegmentPerfPackets": {},
"mplsInSegmentRowStatus": {},
"mplsInSegmentStorageType": {},
"mplsInSegmentTrafficParamPtr": {},
"mplsInSegmentXCIndex": {},
"mplsInterfaceAvailableBandwidth": {},
"mplsInterfaceLabelMaxIn": {},
"mplsInterfaceLabelMaxOut": {},
"mplsInterfaceLabelMinIn": {},
"mplsInterfaceLabelMinOut": {},
"mplsInterfaceLabelParticipationType": {},
"mplsInterfacePerfInLabelLookupFailures": {},
"mplsInterfacePerfInLabelsInUse": {},
"mplsInterfacePerfOutFragmentedPkts": {},
"mplsInterfacePerfOutLabelsInUse": {},
"mplsInterfaceTotalBandwidth": {},
"mplsL3VpnIfConfEntry": {"2": {}, "3": {}, "4": {}},
"mplsL3VpnIfConfRowStatus": {},
"mplsL3VpnMIB.1.1.1": {},
"mplsL3VpnMIB.1.1.2": {},
"mplsL3VpnMIB.1.1.3": {},
"mplsL3VpnMIB.1.1.4": {},
"mplsL3VpnMIB.1.1.5": {},
"mplsL3VpnMIB.1.1.6": {},
"mplsL3VpnMIB.1.1.7": {},
"mplsL3VpnVrfConfHighRteThresh": {},
"mplsL3VpnVrfConfMidRteThresh": {},
"mplsL3VpnVrfEntry": {
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"2": {},
"3": {},
"4": {},
"5": {},
"7": {},
"8": {},
},
"mplsL3VpnVrfOperStatus": {},
"mplsL3VpnVrfPerfCurrNumRoutes": {},
"mplsL3VpnVrfPerfEntry": {"1": {}, "2": {}, "4": {}, "5": {}},
"mplsL3VpnVrfRTEntry": {"4": {}, "5": {}, "6": {}, "7": {}},
"mplsL3VpnVrfRteEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"7": {},
"8": {},
"9": {},
},
"mplsL3VpnVrfSecEntry": {"2": {}},
"mplsL3VpnVrfSecIllegalLblVltns": {},
"mplsLabelStackIndexNext": {},
"mplsLabelStackLabel": {},
"mplsLabelStackLabelPtr": {},
"mplsLabelStackRowStatus": {},
"mplsLabelStackStorageType": {},
"mplsLdpEntityAdminStatus": {},
"mplsLdpEntityAtmDefaultControlVci": {},
"mplsLdpEntityAtmDefaultControlVpi": {},
"mplsLdpEntityAtmIfIndexOrZero": {},
"mplsLdpEntityAtmLRComponents": {},
"mplsLdpEntityAtmLRMaxVci": {},
"mplsLdpEntityAtmLRMaxVpi": {},
"mplsLdpEntityAtmLRRowStatus": {},
"mplsLdpEntityAtmLRStorageType": {},
"mplsLdpEntityAtmLsrConnectivity": {},
"mplsLdpEntityAtmMergeCap": {},
"mplsLdpEntityAtmRowStatus": {},
"mplsLdpEntityAtmStorageType": {},
"mplsLdpEntityAtmUnlabTrafVci": {},
"mplsLdpEntityAtmUnlabTrafVpi": {},
"mplsLdpEntityAtmVcDirectionality": {},
"mplsLdpEntityDiscontinuityTime": {},
"mplsLdpEntityGenericIfIndexOrZero": {},
"mplsLdpEntityGenericLRRowStatus": {},
"mplsLdpEntityGenericLRStorageType": {},
"mplsLdpEntityGenericLabelSpace": {},
"mplsLdpEntityHelloHoldTimer": {},
"mplsLdpEntityHopCountLimit": {},
"mplsLdpEntityIndexNext": {},
"mplsLdpEntityInitSessionThreshold": {},
"mplsLdpEntityKeepAliveHoldTimer": {},
"mplsLdpEntityLabelDistMethod": {},
"mplsLdpEntityLabelRetentionMode": {},
"mplsLdpEntityLabelType": {},
"mplsLdpEntityLastChange": {},
"mplsLdpEntityMaxPduLength": {},
"mplsLdpEntityOperStatus": {},
"mplsLdpEntityPathVectorLimit": {},
"mplsLdpEntityProtocolVersion": {},
"mplsLdpEntityRowStatus": {},
"mplsLdpEntityStatsBadLdpIdentifierErrors": {},
"mplsLdpEntityStatsBadMessageLengthErrors": {},
"mplsLdpEntityStatsBadPduLengthErrors": {},
"mplsLdpEntityStatsBadTlvLengthErrors": {},
"mplsLdpEntityStatsKeepAliveTimerExpErrors": {},
"mplsLdpEntityStatsMalformedTlvValueErrors": {},
"mplsLdpEntityStatsSessionAttempts": {},
"mplsLdpEntityStatsSessionRejectedAdErrors": {},
"mplsLdpEntityStatsSessionRejectedLRErrors": {},
"mplsLdpEntityStatsSessionRejectedMaxPduErrors": {},
"mplsLdpEntityStatsSessionRejectedNoHelloErrors": {},
"mplsLdpEntityStatsShutdownReceivedNotifications": {},
"mplsLdpEntityStatsShutdownSentNotifications": {},
"mplsLdpEntityStorageType": {},
"mplsLdpEntityTargetPeer": {},
"mplsLdpEntityTargetPeerAddr": {},
"mplsLdpEntityTargetPeerAddrType": {},
"mplsLdpEntityTcpPort": {},
"mplsLdpEntityTransportAddrKind": {},
"mplsLdpEntityUdpDscPort": {},
"mplsLdpHelloAdjacencyHoldTime": {},
"mplsLdpHelloAdjacencyHoldTimeRem": {},
"mplsLdpHelloAdjacencyType": {},
"mplsLdpLspFecLastChange": {},
"mplsLdpLspFecRowStatus": {},
"mplsLdpLspFecStorageType": {},
"mplsLdpLsrId": {},
"mplsLdpLsrLoopDetectionCapable": {},
"mplsLdpPeerLabelDistMethod": {},
"mplsLdpPeerLastChange": {},
"mplsLdpPeerPathVectorLimit": {},
"mplsLdpPeerTransportAddr": {},
"mplsLdpPeerTransportAddrType": {},
"mplsLdpSessionAtmLRUpperBoundVci": {},
"mplsLdpSessionAtmLRUpperBoundVpi": {},
"mplsLdpSessionDiscontinuityTime": {},
"mplsLdpSessionKeepAliveHoldTimeRem": {},
"mplsLdpSessionKeepAliveTime": {},
"mplsLdpSessionMaxPduLength": {},
"mplsLdpSessionPeerNextHopAddr": {},
"mplsLdpSessionPeerNextHopAddrType": {},
"mplsLdpSessionProtocolVersion": {},
"mplsLdpSessionRole": {},
"mplsLdpSessionState": {},
"mplsLdpSessionStateLastChange": {},
"mplsLdpSessionStatsUnknownMesTypeErrors": {},
"mplsLdpSessionStatsUnknownTlvErrors": {},
"mplsLsrMIB.1.10": {},
"mplsLsrMIB.1.11": {},
"mplsLsrMIB.1.13": {},
"mplsLsrMIB.1.15": {},
"mplsLsrMIB.1.16": {},
"mplsLsrMIB.1.17": {},
"mplsLsrMIB.1.5": {},
"mplsLsrMIB.1.8": {},
"mplsMaxLabelStackDepth": {},
"mplsOutSegmentIndexNext": {},
"mplsOutSegmentInterface": {},
"mplsOutSegmentLdpLspLabelType": {},
"mplsOutSegmentLdpLspType": {},
"mplsOutSegmentNextHopAddr": {},
"mplsOutSegmentNextHopAddrType": {},
"mplsOutSegmentOwner": {},
"mplsOutSegmentPerfDiscards": {},
"mplsOutSegmentPerfDiscontinuityTime": {},
"mplsOutSegmentPerfErrors": {},
"mplsOutSegmentPerfHCOctets": {},
"mplsOutSegmentPerfOctets": {},
"mplsOutSegmentPerfPackets": {},
"mplsOutSegmentPushTopLabel": {},
"mplsOutSegmentRowStatus": {},
"mplsOutSegmentStorageType": {},
"mplsOutSegmentTopLabel": {},
"mplsOutSegmentTopLabelPtr": {},
"mplsOutSegmentTrafficParamPtr": {},
"mplsOutSegmentXCIndex": {},
"mplsTeMIB.1.1": {},
"mplsTeMIB.1.2": {},
"mplsTeMIB.1.3": {},
"mplsTeMIB.1.4": {},
"mplsTeMIB.2.1": {},
"mplsTeMIB.2.10": {},
"mplsTeMIB.2.3": {},
"mplsTeMIB.10.36.1.10": {},
"mplsTeMIB.10.36.1.11": {},
"mplsTeMIB.10.36.1.12": {},
"mplsTeMIB.10.36.1.13": {},
"mplsTeMIB.10.36.1.4": {},
"mplsTeMIB.10.36.1.5": {},
"mplsTeMIB.10.36.1.6": {},
"mplsTeMIB.10.36.1.7": {},
"mplsTeMIB.10.36.1.8": {},
"mplsTeMIB.10.36.1.9": {},
"mplsTeMIB.2.5": {},
"mplsTeObjects.10.1.1": {},
"mplsTeObjects.10.1.2": {},
"mplsTeObjects.10.1.3": {},
"mplsTeObjects.10.1.4": {},
"mplsTeObjects.10.1.5": {},
"mplsTeObjects.10.1.6": {},
"mplsTeObjects.10.1.7": {},
"mplsTunnelARHopEntry": {"3": {}, "4": {}, "5": {}, "6": {}},
"mplsTunnelActive": {},
"mplsTunnelAdminStatus": {},
"mplsTunnelCHopEntry": {
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"mplsTunnelConfigured": {},
"mplsTunnelEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"30": {},
"31": {},
"32": {},
"33": {},
"36": {},
"37": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"mplsTunnelHopEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"mplsTunnelHopListIndexNext": {},
"mplsTunnelIndexNext": {},
"mplsTunnelMaxHops": {},
"mplsTunnelNotificationEnable": {},
"mplsTunnelNotificationMaxRate": {},
"mplsTunnelOperStatus": {},
"mplsTunnelPerfEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"mplsTunnelResourceEntry": {
"10": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"mplsTunnelResourceIndexNext": {},
"mplsTunnelResourceMaxRate": {},
"mplsTunnelTEDistProto": {},
"mplsVpnInterfaceConfEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"mplsVpnMIB.1.1.1": {},
"mplsVpnMIB.1.1.2": {},
"mplsVpnMIB.1.1.3": {},
"mplsVpnMIB.1.1.4": {},
"mplsVpnMIB.1.1.5": {},
"mplsVpnVrfBgpNbrAddrEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"mplsVpnVrfBgpNbrPrefixEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"mplsVpnVrfConfHighRouteThreshold": {},
"mplsVpnVrfEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"mplsVpnVrfPerfCurrNumRoutes": {},
"mplsVpnVrfPerfEntry": {"1": {}, "2": {}},
"mplsVpnVrfRouteEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"mplsVpnVrfRouteTargetEntry": {"4": {}, "5": {}, "6": {}},
"mplsVpnVrfSecEntry": {"2": {}},
"mplsVpnVrfSecIllegalLabelViolations": {},
"mplsXCAdminStatus": {},
"mplsXCIndexNext": {},
"mplsXCLabelStackIndex": {},
"mplsXCLspId": {},
"mplsXCNotificationsEnable": {},
"mplsXCOperStatus": {},
"mplsXCOwner": {},
"mplsXCRowStatus": {},
"mplsXCStorageType": {},
"msdp": {"1": {}, "2": {}, "3": {}, "9": {}},
"msdpPeerEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"3": {},
"30": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"msdpSACacheEntry": {
"10": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"mteEventActions": {},
"mteEventComment": {},
"mteEventEnabled": {},
"mteEventEntryStatus": {},
"mteEventFailures": {},
"mteEventNotification": {},
"mteEventNotificationObjects": {},
"mteEventNotificationObjectsOwner": {},
"mteEventSetContextName": {},
"mteEventSetContextNameWildcard": {},
"mteEventSetObject": {},
"mteEventSetObjectWildcard": {},
"mteEventSetTargetTag": {},
"mteEventSetValue": {},
"mteFailedReason": {},
"mteHotContextName": {},
"mteHotOID": {},
"mteHotTargetName": {},
"mteHotTrigger": {},
"mteHotValue": {},
"mteObjectsEntryStatus": {},
"mteObjectsID": {},
"mteObjectsIDWildcard": {},
"mteResourceSampleInstanceLacks": {},
"mteResourceSampleInstanceMaximum": {},
"mteResourceSampleInstances": {},
"mteResourceSampleInstancesHigh": {},
"mteResourceSampleMinimum": {},
"mteTriggerBooleanComparison": {},
"mteTriggerBooleanEvent": {},
"mteTriggerBooleanEventOwner": {},
"mteTriggerBooleanObjects": {},
"mteTriggerBooleanObjectsOwner": {},
"mteTriggerBooleanStartup": {},
"mteTriggerBooleanValue": {},
"mteTriggerComment": {},
"mteTriggerContextName": {},
"mteTriggerContextNameWildcard": {},
"mteTriggerDeltaDiscontinuityID": {},
"mteTriggerDeltaDiscontinuityIDType": {},
"mteTriggerDeltaDiscontinuityIDWildcard": {},
"mteTriggerEnabled": {},
"mteTriggerEntryStatus": {},
"mteTriggerExistenceEvent": {},
"mteTriggerExistenceEventOwner": {},
"mteTriggerExistenceObjects": {},
"mteTriggerExistenceObjectsOwner": {},
"mteTriggerExistenceStartup": {},
"mteTriggerExistenceTest": {},
"mteTriggerFailures": {},
"mteTriggerFrequency": {},
"mteTriggerObjects": {},
"mteTriggerObjectsOwner": {},
"mteTriggerSampleType": {},
"mteTriggerTargetTag": {},
"mteTriggerTest": {},
"mteTriggerThresholdDeltaFalling": {},
"mteTriggerThresholdDeltaFallingEvent": {},
"mteTriggerThresholdDeltaFallingEventOwner": {},
"mteTriggerThresholdDeltaRising": {},
"mteTriggerThresholdDeltaRisingEvent": {},
"mteTriggerThresholdDeltaRisingEventOwner": {},
"mteTriggerThresholdFalling": {},
"mteTriggerThresholdFallingEvent": {},
"mteTriggerThresholdFallingEventOwner": {},
"mteTriggerThresholdObjects": {},
"mteTriggerThresholdObjectsOwner": {},
"mteTriggerThresholdRising": {},
"mteTriggerThresholdRisingEvent": {},
"mteTriggerThresholdRisingEventOwner": {},
"mteTriggerThresholdStartup": {},
"mteTriggerValueID": {},
"mteTriggerValueIDWildcard": {},
"natAddrBindCurrentIdleTime": {},
"natAddrBindGlobalAddr": {},
"natAddrBindGlobalAddrType": {},
"natAddrBindId": {},
"natAddrBindInTranslates": {},
"natAddrBindMapIndex": {},
"natAddrBindMaxIdleTime": {},
"natAddrBindNumberOfEntries": {},
"natAddrBindOutTranslates": {},
"natAddrBindSessions": {},
"natAddrBindTranslationEntity": {},
"natAddrBindType": {},
"natAddrPortBindNumberOfEntries": {},
"natBindDefIdleTimeout": {},
"natIcmpDefIdleTimeout": {},
"natInterfaceDiscards": {},
"natInterfaceInTranslates": {},
"natInterfaceOutTranslates": {},
"natInterfaceRealm": {},
"natInterfaceRowStatus": {},
"natInterfaceServiceType": {},
"natInterfaceStorageType": {},
"natMIBObjects.10.169.1.1": {},
"natMIBObjects.10.169.1.2": {},
"natMIBObjects.10.169.1.3": {},
"natMIBObjects.10.169.1.4": {},
"natMIBObjects.10.169.1.5": {},
"natMIBObjects.10.169.1.6": {},
"natMIBObjects.10.169.1.7": {},
"natMIBObjects.10.169.1.8": {},
"natMIBObjects.10.196.1.2": {},
"natMIBObjects.10.196.1.3": {},
"natMIBObjects.10.196.1.4": {},
"natMIBObjects.10.196.1.5": {},
"natMIBObjects.10.196.1.6": {},
"natMIBObjects.10.196.1.7": {},
"natOtherDefIdleTimeout": {},
"natPoolPortMax": {},
"natPoolPortMin": {},
"natPoolRangeAllocations": {},
"natPoolRangeBegin": {},
"natPoolRangeDeallocations": {},
"natPoolRangeEnd": {},
"natPoolRangeType": {},
"natPoolRealm": {},
"natPoolWatermarkHigh": {},
"natPoolWatermarkLow": {},
"natTcpDefIdleTimeout": {},
"natTcpDefNegTimeout": {},
"natUdpDefIdleTimeout": {},
"nbpEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"nhrpCacheHoldingTime": {},
"nhrpCacheHoldingTimeValid": {},
"nhrpCacheNbmaAddr": {},
"nhrpCacheNbmaAddrType": {},
"nhrpCacheNbmaSubaddr": {},
"nhrpCacheNegotiatedMtu": {},
"nhrpCacheNextHopInternetworkAddr": {},
"nhrpCachePreference": {},
"nhrpCachePrefixLength": {},
"nhrpCacheRowStatus": {},
"nhrpCacheState": {},
"nhrpCacheStorageType": {},
"nhrpCacheType": {},
"nhrpClientDefaultMtu": {},
"nhrpClientHoldTime": {},
"nhrpClientInitialRequestTimeout": {},
"nhrpClientInternetworkAddr": {},
"nhrpClientInternetworkAddrType": {},
"nhrpClientNbmaAddr": {},
"nhrpClientNbmaAddrType": {},
"nhrpClientNbmaSubaddr": {},
"nhrpClientNhsInUse": {},
"nhrpClientNhsInternetworkAddr": {},
"nhrpClientNhsInternetworkAddrType": {},
"nhrpClientNhsNbmaAddr": {},
"nhrpClientNhsNbmaAddrType": {},
"nhrpClientNhsNbmaSubaddr": {},
"nhrpClientNhsRowStatus": {},
"nhrpClientPurgeRequestRetries": {},
"nhrpClientRegRowStatus": {},
"nhrpClientRegState": {},
"nhrpClientRegUniqueness": {},
"nhrpClientRegistrationRequestRetries": {},
"nhrpClientRequestID": {},
"nhrpClientResolutionRequestRetries": {},
"nhrpClientRowStatus": {},
"nhrpClientStatDiscontinuityTime": {},
"nhrpClientStatRxErrAuthenticationFailure": {},
"nhrpClientStatRxErrHopCountExceeded": {},
"nhrpClientStatRxErrInvalidExtension": {},
"nhrpClientStatRxErrLoopDetected": {},
"nhrpClientStatRxErrProtoAddrUnreachable": {},
"nhrpClientStatRxErrProtoError": {},
"nhrpClientStatRxErrSduSizeExceeded": {},
"nhrpClientStatRxErrUnrecognizedExtension": {},
"nhrpClientStatRxPurgeReply": {},
"nhrpClientStatRxPurgeReq": {},
"nhrpClientStatRxRegisterAck": {},
"nhrpClientStatRxRegisterNakAlreadyReg": {},
"nhrpClientStatRxRegisterNakInsufResources": {},
"nhrpClientStatRxRegisterNakProhibited": {},
"nhrpClientStatRxResolveReplyAck": {},
"nhrpClientStatRxResolveReplyNakInsufResources": {},
"nhrpClientStatRxResolveReplyNakNoBinding": {},
"nhrpClientStatRxResolveReplyNakNotUnique": {},
"nhrpClientStatRxResolveReplyNakProhibited": {},
"nhrpClientStatTxErrorIndication": {},
"nhrpClientStatTxPurgeReply": {},
"nhrpClientStatTxPurgeReq": {},
"nhrpClientStatTxRegisterReq": {},
"nhrpClientStatTxResolveReq": {},
"nhrpClientStorageType": {},
"nhrpNextIndex": {},
"nhrpPurgeCacheIdentifier": {},
"nhrpPurgePrefixLength": {},
"nhrpPurgeReplyExpected": {},
"nhrpPurgeRequestID": {},
"nhrpPurgeRowStatus": {},
"nhrpServerCacheAuthoritative": {},
"nhrpServerCacheUniqueness": {},
"nhrpServerInternetworkAddr": {},
"nhrpServerInternetworkAddrType": {},
"nhrpServerNbmaAddr": {},
"nhrpServerNbmaAddrType": {},
"nhrpServerNbmaSubaddr": {},
"nhrpServerNhcInUse": {},
"nhrpServerNhcInternetworkAddr": {},
"nhrpServerNhcInternetworkAddrType": {},
"nhrpServerNhcNbmaAddr": {},
"nhrpServerNhcNbmaAddrType": {},
"nhrpServerNhcNbmaSubaddr": {},
"nhrpServerNhcPrefixLength": {},
"nhrpServerNhcRowStatus": {},
"nhrpServerRowStatus": {},
"nhrpServerStatDiscontinuityTime": {},
"nhrpServerStatFwErrorIndication": {},
"nhrpServerStatFwPurgeReply": {},
"nhrpServerStatFwPurgeReq": {},
"nhrpServerStatFwRegisterReply": {},
"nhrpServerStatFwRegisterReq": {},
"nhrpServerStatFwResolveReply": {},
"nhrpServerStatFwResolveReq": {},
"nhrpServerStatRxErrAuthenticationFailure": {},
"nhrpServerStatRxErrHopCountExceeded": {},
"nhrpServerStatRxErrInvalidExtension": {},
"nhrpServerStatRxErrInvalidResReplyReceived": {},
"nhrpServerStatRxErrLoopDetected": {},
"nhrpServerStatRxErrProtoAddrUnreachable": {},
"nhrpServerStatRxErrProtoError": {},
"nhrpServerStatRxErrSduSizeExceeded": {},
"nhrpServerStatRxErrUnrecognizedExtension": {},
"nhrpServerStatRxPurgeReply": {},
"nhrpServerStatRxPurgeReq": {},
"nhrpServerStatRxRegisterReq": {},
"nhrpServerStatRxResolveReq": {},
"nhrpServerStatTxErrAuthenticationFailure": {},
"nhrpServerStatTxErrHopCountExceeded": {},
"nhrpServerStatTxErrInvalidExtension": {},
"nhrpServerStatTxErrLoopDetected": {},
"nhrpServerStatTxErrProtoAddrUnreachable": {},
"nhrpServerStatTxErrProtoError": {},
"nhrpServerStatTxErrSduSizeExceeded": {},
"nhrpServerStatTxErrUnrecognizedExtension": {},
"nhrpServerStatTxPurgeReply": {},
"nhrpServerStatTxPurgeReq": {},
"nhrpServerStatTxRegisterAck": {},
"nhrpServerStatTxRegisterNakAlreadyReg": {},
"nhrpServerStatTxRegisterNakInsufResources": {},
"nhrpServerStatTxRegisterNakProhibited": {},
"nhrpServerStatTxResolveReplyAck": {},
"nhrpServerStatTxResolveReplyNakInsufResources": {},
"nhrpServerStatTxResolveReplyNakNoBinding": {},
"nhrpServerStatTxResolveReplyNakNotUnique": {},
"nhrpServerStatTxResolveReplyNakProhibited": {},
"nhrpServerStorageType": {},
"nlmConfig": {"1": {}, "2": {}},
"nlmConfigLogEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"nlmLogEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"nlmLogVariableEntry": {
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"nlmStats": {"1": {}, "2": {}},
"nlmStatsLogEntry": {"1": {}, "2": {}},
"ntpAssocAddress": {},
"ntpAssocAddressType": {},
"ntpAssocName": {},
"ntpAssocOffset": {},
"ntpAssocRefId": {},
"ntpAssocStatInPkts": {},
"ntpAssocStatOutPkts": {},
"ntpAssocStatProtocolError": {},
"ntpAssocStatusDelay": {},
"ntpAssocStatusDispersion": {},
"ntpAssocStatusJitter": {},
"ntpAssocStratum": {},
"ntpEntInfo": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"ntpEntStatus": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ntpEntStatus.17.1.2": {},
"ntpEntStatus.17.1.3": {},
"ntpSnmpMIBObjects.4.1": {},
"ntpSnmpMIBObjects.4.2": {},
"optIfOChCurrentStatus": {},
"optIfOChDirectionality": {},
"optIfOChSinkCurDayHighInputPower": {},
"optIfOChSinkCurDayLowInputPower": {},
"optIfOChSinkCurDaySuspectedFlag": {},
"optIfOChSinkCurrentHighInputPower": {},
"optIfOChSinkCurrentInputPower": {},
"optIfOChSinkCurrentLowInputPower": {},
"optIfOChSinkCurrentLowerInputPowerThreshold": {},
"optIfOChSinkCurrentSuspectedFlag": {},
"optIfOChSinkCurrentUpperInputPowerThreshold": {},
"optIfOChSinkIntervalHighInputPower": {},
"optIfOChSinkIntervalLastInputPower": {},
"optIfOChSinkIntervalLowInputPower": {},
"optIfOChSinkIntervalSuspectedFlag": {},
"optIfOChSinkPrevDayHighInputPower": {},
"optIfOChSinkPrevDayLastInputPower": {},
"optIfOChSinkPrevDayLowInputPower": {},
"optIfOChSinkPrevDaySuspectedFlag": {},
"optIfOChSrcCurDayHighOutputPower": {},
"optIfOChSrcCurDayLowOutputPower": {},
"optIfOChSrcCurDaySuspectedFlag": {},
"optIfOChSrcCurrentHighOutputPower": {},
"optIfOChSrcCurrentLowOutputPower": {},
"optIfOChSrcCurrentLowerOutputPowerThreshold": {},
"optIfOChSrcCurrentOutputPower": {},
"optIfOChSrcCurrentSuspectedFlag": {},
"optIfOChSrcCurrentUpperOutputPowerThreshold": {},
"optIfOChSrcIntervalHighOutputPower": {},
"optIfOChSrcIntervalLastOutputPower": {},
"optIfOChSrcIntervalLowOutputPower": {},
"optIfOChSrcIntervalSuspectedFlag": {},
"optIfOChSrcPrevDayHighOutputPower": {},
"optIfOChSrcPrevDayLastOutputPower": {},
"optIfOChSrcPrevDayLowOutputPower": {},
"optIfOChSrcPrevDaySuspectedFlag": {},
"optIfODUkTtpCurrentStatus": {},
"optIfODUkTtpDAPIExpected": {},
"optIfODUkTtpDEGM": {},
"optIfODUkTtpDEGThr": {},
"optIfODUkTtpSAPIExpected": {},
"optIfODUkTtpTIMActEnabled": {},
"optIfODUkTtpTIMDetMode": {},
"optIfODUkTtpTraceIdentifierAccepted": {},
"optIfODUkTtpTraceIdentifierTransmitted": {},
"optIfOTUk.2.1.2": {},
"optIfOTUk.2.1.3": {},
"optIfOTUkBitRateK": {},
"optIfOTUkCurrentStatus": {},
"optIfOTUkDAPIExpected": {},
"optIfOTUkDEGM": {},
"optIfOTUkDEGThr": {},
"optIfOTUkDirectionality": {},
"optIfOTUkSAPIExpected": {},
"optIfOTUkSinkAdaptActive": {},
"optIfOTUkSinkFECEnabled": {},
"optIfOTUkSourceAdaptActive": {},
"optIfOTUkTIMActEnabled": {},
"optIfOTUkTIMDetMode": {},
"optIfOTUkTraceIdentifierAccepted": {},
"optIfOTUkTraceIdentifierTransmitted": {},
"optIfObjects.10.4.1.1": {},
"optIfObjects.10.4.1.2": {},
"optIfObjects.10.4.1.3": {},
"optIfObjects.10.4.1.4": {},
"optIfObjects.10.4.1.5": {},
"optIfObjects.10.4.1.6": {},
"optIfObjects.10.9.1.1": {},
"optIfObjects.10.9.1.2": {},
"optIfObjects.10.9.1.3": {},
"optIfObjects.10.9.1.4": {},
"optIfObjects.10.16.1.1": {},
"optIfObjects.10.16.1.10": {},
"optIfObjects.10.16.1.2": {},
"optIfObjects.10.16.1.3": {},
"optIfObjects.10.16.1.4": {},
"optIfObjects.10.16.1.5": {},
"optIfObjects.10.16.1.6": {},
"optIfObjects.10.16.1.7": {},
"optIfObjects.10.16.1.8": {},
"optIfObjects.10.16.1.9": {},
"optIfObjects.10.25.1.1": {},
"optIfObjects.10.25.1.10": {},
"optIfObjects.10.25.1.11": {},
"optIfObjects.10.25.1.2": {},
"optIfObjects.10.25.1.3": {},
"optIfObjects.10.25.1.4": {},
"optIfObjects.10.25.1.5": {},
"optIfObjects.10.25.1.6": {},
"optIfObjects.10.25.1.7": {},
"optIfObjects.10.25.1.8": {},
"optIfObjects.10.25.1.9": {},
"optIfObjects.10.36.1.2": {},
"optIfObjects.10.36.1.3": {},
"optIfObjects.10.36.1.4": {},
"optIfObjects.10.36.1.5": {},
"optIfObjects.10.36.1.6": {},
"optIfObjects.10.36.1.7": {},
"optIfObjects.10.36.1.8": {},
"optIfObjects.10.49.1.1": {},
"optIfObjects.10.49.1.2": {},
"optIfObjects.10.49.1.3": {},
"optIfObjects.10.49.1.4": {},
"optIfObjects.10.49.1.5": {},
"optIfObjects.10.64.1.1": {},
"optIfObjects.10.64.1.2": {},
"optIfObjects.10.64.1.3": {},
"optIfObjects.10.64.1.4": {},
"optIfObjects.10.64.1.5": {},
"optIfObjects.10.64.1.6": {},
"optIfObjects.10.64.1.7": {},
"optIfObjects.10.81.1.1": {},
"optIfObjects.10.81.1.10": {},
"optIfObjects.10.81.1.11": {},
"optIfObjects.10.81.1.2": {},
"optIfObjects.10.81.1.3": {},
"optIfObjects.10.81.1.4": {},
"optIfObjects.10.81.1.5": {},
"optIfObjects.10.81.1.6": {},
"optIfObjects.10.81.1.7": {},
"optIfObjects.10.81.1.8": {},
"optIfObjects.10.81.1.9": {},
"optIfObjects.10.100.1.2": {},
"optIfObjects.10.100.1.3": {},
"optIfObjects.10.100.1.4": {},
"optIfObjects.10.100.1.5": {},
"optIfObjects.10.100.1.6": {},
"optIfObjects.10.100.1.7": {},
"optIfObjects.10.100.1.8": {},
"optIfObjects.10.121.1.1": {},
"optIfObjects.10.121.1.2": {},
"optIfObjects.10.121.1.3": {},
"optIfObjects.10.121.1.4": {},
"optIfObjects.10.121.1.5": {},
"optIfObjects.10.144.1.1": {},
"optIfObjects.10.144.1.2": {},
"optIfObjects.10.144.1.3": {},
"optIfObjects.10.144.1.4": {},
"optIfObjects.10.144.1.5": {},
"optIfObjects.10.144.1.6": {},
"optIfObjects.10.144.1.7": {},
"optIfObjects.10.36.1.1": {},
"optIfObjects.10.36.1.10": {},
"optIfObjects.10.36.1.11": {},
"optIfObjects.10.36.1.9": {},
"optIfObjects.10.49.1.6": {},
"optIfObjects.10.49.1.7": {},
"optIfObjects.10.49.1.8": {},
"optIfObjects.10.100.1.1": {},
"optIfObjects.10.100.1.10": {},
"optIfObjects.10.100.1.11": {},
"optIfObjects.10.100.1.9": {},
"optIfObjects.10.121.1.6": {},
"optIfObjects.10.121.1.7": {},
"optIfObjects.10.121.1.8": {},
"optIfObjects.10.169.1.1": {},
"optIfObjects.10.169.1.2": {},
"optIfObjects.10.169.1.3": {},
"optIfObjects.10.169.1.4": {},
"optIfObjects.10.169.1.5": {},
"optIfObjects.10.169.1.6": {},
"optIfObjects.10.169.1.7": {},
"optIfObjects.10.49.1.10": {},
"optIfObjects.10.49.1.11": {},
"optIfObjects.10.49.1.9": {},
"optIfObjects.10.64.1.8": {},
"optIfObjects.10.121.1.10": {},
"optIfObjects.10.121.1.11": {},
"optIfObjects.10.121.1.9": {},
"optIfObjects.10.144.1.8": {},
"optIfObjects.10.196.1.1": {},
"optIfObjects.10.196.1.2": {},
"optIfObjects.10.196.1.3": {},
"optIfObjects.10.196.1.4": {},
"optIfObjects.10.196.1.5": {},
"optIfObjects.10.196.1.6": {},
"optIfObjects.10.196.1.7": {},
"optIfObjects.10.144.1.10": {},
"optIfObjects.10.144.1.9": {},
"optIfObjects.10.100.1.12": {},
"optIfObjects.10.100.1.13": {},
"optIfObjects.10.100.1.14": {},
"optIfObjects.10.100.1.15": {},
"ospfAreaAggregateEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"ospfAreaEntry": {
"1": {},
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ospfAreaRangeEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"ospfExtLsdbEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"ospfGeneralGroup": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ospfHostEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"ospfIfEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ospfIfMetricEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"ospfLsdbEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ospfNbrEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ospfStubAreaEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"ospfTrap.1.1": {},
"ospfTrap.1.2": {},
"ospfTrap.1.3": {},
"ospfTrap.1.4": {},
"ospfVirtIfEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ospfVirtNbrEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"ospfv3AreaAggregateEntry": {"6": {}, "7": {}, "8": {}},
"ospfv3AreaEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ospfv3AreaLsdbEntry": {"5": {}, "6": {}, "7": {}, "8": {}, "9": {}},
"ospfv3AsLsdbEntry": {"4": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"ospfv3CfgNbrEntry": {"5": {}, "6": {}},
"ospfv3GeneralGroup": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ospfv3HostEntry": {"3": {}, "4": {}, "5": {}},
"ospfv3IfEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ospfv3LinkLsdbEntry": {"10": {}, "6": {}, "7": {}, "8": {}, "9": {}},
"ospfv3NbrEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ospfv3VirtIfEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ospfv3VirtLinkLsdbEntry": {"10": {}, "6": {}, "7": {}, "8": {}, "9": {}},
"ospfv3VirtNbrEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"pim": {"1": {}},
"pimAnycastRPSetLocalRouter": {},
"pimAnycastRPSetRowStatus": {},
"pimBidirDFElectionState": {},
"pimBidirDFElectionStateTimer": {},
"pimBidirDFElectionWinnerAddress": {},
"pimBidirDFElectionWinnerAddressType": {},
"pimBidirDFElectionWinnerMetric": {},
"pimBidirDFElectionWinnerMetricPref": {},
"pimBidirDFElectionWinnerUpTime": {},
"pimCandidateRPEntry": {"3": {}, "4": {}},
"pimComponentEntry": {"2": {}, "3": {}, "4": {}, "5": {}},
"pimGroupMappingPimMode": {},
"pimGroupMappingPrecedence": {},
"pimInAsserts": {},
"pimInterfaceAddress": {},
"pimInterfaceAddressType": {},
"pimInterfaceBidirCapable": {},
"pimInterfaceDFElectionRobustness": {},
"pimInterfaceDR": {},
"pimInterfaceDRPriority": {},
"pimInterfaceDRPriorityEnabled": {},
"pimInterfaceDomainBorder": {},
"pimInterfaceEffectOverrideIvl": {},
"pimInterfaceEffectPropagDelay": {},
"pimInterfaceElectionNotificationPeriod": {},
"pimInterfaceElectionWinCount": {},
"pimInterfaceEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"pimInterfaceGenerationIDValue": {},
"pimInterfaceGraftRetryInterval": {},
"pimInterfaceHelloHoldtime": {},
"pimInterfaceHelloInterval": {},
"pimInterfaceJoinPruneHoldtime": {},
"pimInterfaceJoinPruneInterval": {},
"pimInterfaceLanDelayEnabled": {},
"pimInterfaceOverrideInterval": {},
"pimInterfacePropagationDelay": {},
"pimInterfacePruneLimitInterval": {},
"pimInterfaceSRPriorityEnabled": {},
"pimInterfaceStatus": {},
"pimInterfaceStubInterface": {},
"pimInterfaceSuppressionEnabled": {},
"pimInterfaceTrigHelloInterval": {},
"pimInvalidJoinPruneAddressType": {},
"pimInvalidJoinPruneGroup": {},
"pimInvalidJoinPruneMsgsRcvd": {},
"pimInvalidJoinPruneNotificationPeriod": {},
"pimInvalidJoinPruneOrigin": {},
"pimInvalidJoinPruneRp": {},
"pimInvalidRegisterAddressType": {},
"pimInvalidRegisterGroup": {},
"pimInvalidRegisterMsgsRcvd": {},
"pimInvalidRegisterNotificationPeriod": {},
"pimInvalidRegisterOrigin": {},
"pimInvalidRegisterRp": {},
"pimIpMRouteEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"pimIpMRouteNextHopEntry": {"2": {}},
"pimKeepalivePeriod": {},
"pimLastAssertGroupAddress": {},
"pimLastAssertGroupAddressType": {},
"pimLastAssertInterface": {},
"pimLastAssertSourceAddress": {},
"pimLastAssertSourceAddressType": {},
"pimNbrSecAddress": {},
"pimNeighborBidirCapable": {},
"pimNeighborDRPriority": {},
"pimNeighborDRPriorityPresent": {},
"pimNeighborEntry": {"2": {}, "3": {}, "4": {}, "5": {}},
"pimNeighborExpiryTime": {},
"pimNeighborGenerationIDPresent": {},
"pimNeighborGenerationIDValue": {},
"pimNeighborLanPruneDelayPresent": {},
"pimNeighborLossCount": {},
"pimNeighborLossNotificationPeriod": {},
"pimNeighborOverrideInterval": {},
"pimNeighborPropagationDelay": {},
"pimNeighborSRCapable": {},
"pimNeighborTBit": {},
"pimNeighborUpTime": {},
"pimOutAsserts": {},
"pimRPEntry": {"3": {}, "4": {}, "5": {}, "6": {}},
"pimRPMappingChangeCount": {},
"pimRPMappingNotificationPeriod": {},
"pimRPSetEntry": {"4": {}, "5": {}},
"pimRegisterSuppressionTime": {},
"pimSGDRRegisterState": {},
"pimSGDRRegisterStopTimer": {},
"pimSGEntries": {},
"pimSGIAssertState": {},
"pimSGIAssertTimer": {},
"pimSGIAssertWinnerAddress": {},
"pimSGIAssertWinnerAddressType": {},
"pimSGIAssertWinnerMetric": {},
"pimSGIAssertWinnerMetricPref": {},
"pimSGIEntries": {},
"pimSGIJoinExpiryTimer": {},
"pimSGIJoinPruneState": {},
"pimSGILocalMembership": {},
"pimSGIPrunePendingTimer": {},
"pimSGIUpTime": {},
"pimSGKeepaliveTimer": {},
"pimSGOriginatorState": {},
"pimSGPimMode": {},
"pimSGRPFIfIndex": {},
"pimSGRPFNextHop": {},
"pimSGRPFNextHopType": {},
"pimSGRPFRouteAddress": {},
"pimSGRPFRouteMetric": {},
"pimSGRPFRouteMetricPref": {},
"pimSGRPFRoutePrefixLength": {},
"pimSGRPFRouteProtocol": {},
"pimSGRPRegisterPMBRAddress": {},
"pimSGRPRegisterPMBRAddressType": {},
"pimSGRptEntries": {},
"pimSGRptIEntries": {},
"pimSGRptIJoinPruneState": {},
"pimSGRptILocalMembership": {},
"pimSGRptIPruneExpiryTimer": {},
"pimSGRptIPrunePendingTimer": {},
"pimSGRptIUpTime": {},
"pimSGRptUpTime": {},
"pimSGRptUpstreamOverrideTimer": {},
"pimSGRptUpstreamPruneState": {},
"pimSGSPTBit": {},
"pimSGSourceActiveTimer": {},
"pimSGStateRefreshTimer": {},
"pimSGUpTime": {},
"pimSGUpstreamJoinState": {},
"pimSGUpstreamJoinTimer": {},
"pimSGUpstreamNeighbor": {},
"pimSGUpstreamPruneLimitTimer": {},
"pimSGUpstreamPruneState": {},
"pimStarGEntries": {},
"pimStarGIAssertState": {},
"pimStarGIAssertTimer": {},
"pimStarGIAssertWinnerAddress": {},
"pimStarGIAssertWinnerAddressType": {},
"pimStarGIAssertWinnerMetric": {},
"pimStarGIAssertWinnerMetricPref": {},
"pimStarGIEntries": {},
"pimStarGIJoinExpiryTimer": {},
"pimStarGIJoinPruneState": {},
"pimStarGILocalMembership": {},
"pimStarGIPrunePendingTimer": {},
"pimStarGIUpTime": {},
"pimStarGPimMode": {},
"pimStarGPimModeOrigin": {},
"pimStarGRPAddress": {},
"pimStarGRPAddressType": {},
"pimStarGRPFIfIndex": {},
"pimStarGRPFNextHop": {},
"pimStarGRPFNextHopType": {},
"pimStarGRPFRouteAddress": {},
"pimStarGRPFRouteMetric": {},
"pimStarGRPFRouteMetricPref": {},
"pimStarGRPFRoutePrefixLength": {},
"pimStarGRPFRouteProtocol": {},
"pimStarGRPIsLocal": {},
"pimStarGUpTime": {},
"pimStarGUpstreamJoinState": {},
"pimStarGUpstreamJoinTimer": {},
"pimStarGUpstreamNeighbor": {},
"pimStarGUpstreamNeighborType": {},
"pimStaticRPOverrideDynamic": {},
"pimStaticRPPimMode": {},
"pimStaticRPPrecedence": {},
"pimStaticRPRPAddress": {},
"pimStaticRPRowStatus": {},
"qllcLSAdminEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"qllcLSOperEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"qllcLSStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ripCircEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"ripSysEntry": {"1": {}, "2": {}, "3": {}},
"rmon.10.106.1.2": {},
"rmon.10.106.1.3": {},
"rmon.10.106.1.4": {},
"rmon.10.106.1.5": {},
"rmon.10.106.1.6": {},
"rmon.10.106.1.7": {},
"rmon.10.145.1.2": {},
"rmon.10.145.1.3": {},
"rmon.10.186.1.2": {},
"rmon.10.186.1.3": {},
"rmon.10.186.1.4": {},
"rmon.10.186.1.5": {},
"rmon.10.229.1.1": {},
"rmon.10.229.1.2": {},
"rmon.19.1": {},
"rmon.10.76.1.1": {},
"rmon.10.76.1.2": {},
"rmon.10.76.1.3": {},
"rmon.10.76.1.4": {},
"rmon.10.76.1.5": {},
"rmon.10.76.1.6": {},
"rmon.10.76.1.7": {},
"rmon.10.76.1.8": {},
"rmon.10.76.1.9": {},
"rmon.10.135.1.1": {},
"rmon.10.135.1.2": {},
"rmon.10.135.1.3": {},
"rmon.19.12": {},
"rmon.10.4.1.2": {},
"rmon.10.4.1.3": {},
"rmon.10.4.1.4": {},
"rmon.10.4.1.5": {},
"rmon.10.4.1.6": {},
"rmon.10.69.1.2": {},
"rmon.10.69.1.3": {},
"rmon.10.69.1.4": {},
"rmon.10.69.1.5": {},
"rmon.10.69.1.6": {},
"rmon.10.69.1.7": {},
"rmon.10.69.1.8": {},
"rmon.10.69.1.9": {},
"rmon.19.15": {},
"rmon.19.16": {},
"rmon.19.2": {},
"rmon.19.3": {},
"rmon.19.4": {},
"rmon.19.5": {},
"rmon.19.6": {},
"rmon.19.7": {},
"rmon.19.8": {},
"rmon.19.9": {},
"rs232": {"1": {}},
"rs232AsyncPortEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"rs232InSigEntry": {"1": {}, "2": {}, "3": {}},
"rs232OutSigEntry": {"1": {}, "2": {}, "3": {}},
"rs232PortEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"rs232SyncPortEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"rsrbRemotePeerEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"rsrbRingEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"rsrbVirtRingEntry": {"2": {}, "3": {}},
"rsvp.2.1": {},
"rsvp.2.2": {},
"rsvp.2.3": {},
"rsvp.2.4": {},
"rsvp.2.5": {},
"rsvpIfEntry": {
"1": {},
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"rsvpNbrEntry": {"2": {}, "3": {}},
"rsvpResvEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"rsvpResvFwdEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"rsvpSenderEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"37": {},
"38": {},
"39": {},
"4": {},
"40": {},
"41": {},
"42": {},
"43": {},
"44": {},
"45": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"rsvpSenderOutInterfaceStatus": {},
"rsvpSessionEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"rtmpEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"rttMonApplAuthKeyChain": {},
"rttMonApplAuthKeyString1": {},
"rttMonApplAuthKeyString2": {},
"rttMonApplAuthKeyString3": {},
"rttMonApplAuthKeyString4": {},
"rttMonApplAuthKeyString5": {},
"rttMonApplAuthStatus": {},
"rttMonApplFreeMemLowWaterMark": {},
"rttMonApplLatestSetError": {},
"rttMonApplLpdGrpStatsReset": {},
"rttMonApplMaxPacketDataSize": {},
"rttMonApplNumCtrlAdminEntry": {},
"rttMonApplPreConfigedReset": {},
"rttMonApplPreConfigedValid": {},
"rttMonApplProbeCapacity": {},
"rttMonApplReset": {},
"rttMonApplResponder": {},
"rttMonApplSupportedProtocolsValid": {},
"rttMonApplSupportedRttTypesValid": {},
"rttMonApplTimeOfLastSet": {},
"rttMonApplVersion": {},
"rttMonControlEnableErrors": {},
"rttMonCtrlAdminFrequency": {},
"rttMonCtrlAdminGroupName": {},
"rttMonCtrlAdminLongTag": {},
"rttMonCtrlAdminNvgen": {},
"rttMonCtrlAdminOwner": {},
"rttMonCtrlAdminRttType": {},
"rttMonCtrlAdminStatus": {},
"rttMonCtrlAdminTag": {},
"rttMonCtrlAdminThreshold": {},
"rttMonCtrlAdminTimeout": {},
"rttMonCtrlAdminVerifyData": {},
"rttMonCtrlOperConnectionLostOccurred": {},
"rttMonCtrlOperDiagText": {},
"rttMonCtrlOperModificationTime": {},
"rttMonCtrlOperNumRtts": {},
"rttMonCtrlOperOctetsInUse": {},
"rttMonCtrlOperOverThresholdOccurred": {},
"rttMonCtrlOperResetTime": {},
"rttMonCtrlOperRttLife": {},
"rttMonCtrlOperState": {},
"rttMonCtrlOperTimeoutOccurred": {},
"rttMonCtrlOperVerifyErrorOccurred": {},
"rttMonEchoAdminAggBurstCycles": {},
"rttMonEchoAdminAvailNumFrames": {},
"rttMonEchoAdminCache": {},
"rttMonEchoAdminCallDuration": {},
"rttMonEchoAdminCalledNumber": {},
"rttMonEchoAdminCodecInterval": {},
"rttMonEchoAdminCodecNumPackets": {},
"rttMonEchoAdminCodecPayload": {},
"rttMonEchoAdminCodecType": {},
"rttMonEchoAdminControlEnable": {},
"rttMonEchoAdminControlRetry": {},
"rttMonEchoAdminControlTimeout": {},
"rttMonEchoAdminDetectPoint": {},
"rttMonEchoAdminDscp": {},
"rttMonEchoAdminEmulateSourceAddress": {},
"rttMonEchoAdminEmulateSourcePort": {},
"rttMonEchoAdminEmulateTargetAddress": {},
"rttMonEchoAdminEmulateTargetPort": {},
"rttMonEchoAdminEnableBurst": {},
"rttMonEchoAdminEndPointListName": {},
"rttMonEchoAdminEntry": {"77": {}, "78": {}, "79": {}},
"rttMonEchoAdminEthernetCOS": {},
"rttMonEchoAdminGKRegistration": {},
"rttMonEchoAdminHTTPVersion": {},
"rttMonEchoAdminICPIFAdvFactor": {},
"rttMonEchoAdminIgmpTreeInit": {},
"rttMonEchoAdminInputInterface": {},
"rttMonEchoAdminInterval": {},
"rttMonEchoAdminLSPExp": {},
"rttMonEchoAdminLSPFECType": {},
"rttMonEchoAdminLSPNullShim": {},
"rttMonEchoAdminLSPReplyDscp": {},
"rttMonEchoAdminLSPReplyMode": {},
"rttMonEchoAdminLSPSelector": {},
"rttMonEchoAdminLSPTTL": {},
"rttMonEchoAdminLSPVccvID": {},
"rttMonEchoAdminLSREnable": {},
"rttMonEchoAdminLossRatioNumFrames": {},
"rttMonEchoAdminMode": {},
"rttMonEchoAdminNameServer": {},
"rttMonEchoAdminNumPackets": {},
"rttMonEchoAdminOWNTPSyncTolAbs": {},
"rttMonEchoAdminOWNTPSyncTolPct": {},
"rttMonEchoAdminOWNTPSyncTolType": {},
"rttMonEchoAdminOperation": {},
"rttMonEchoAdminPktDataRequestSize": {},
"rttMonEchoAdminPktDataResponseSize": {},
"rttMonEchoAdminPrecision": {},
"rttMonEchoAdminProbePakPriority": {},
"rttMonEchoAdminProtocol": {},
"rttMonEchoAdminProxy": {},
"rttMonEchoAdminReserveDsp": {},
"rttMonEchoAdminSSM": {},
"rttMonEchoAdminSourceAddress": {},
"rttMonEchoAdminSourceMPID": {},
"rttMonEchoAdminSourceMacAddress": {},
"rttMonEchoAdminSourcePort": {},
"rttMonEchoAdminSourceVoicePort": {},
"rttMonEchoAdminString1": {},
"rttMonEchoAdminString2": {},
"rttMonEchoAdminString3": {},
"rttMonEchoAdminString4": {},
"rttMonEchoAdminString5": {},
"rttMonEchoAdminTOS": {},
"rttMonEchoAdminTargetAddress": {},
"rttMonEchoAdminTargetAddressString": {},
"rttMonEchoAdminTargetDomainName": {},
"rttMonEchoAdminTargetEVC": {},
"rttMonEchoAdminTargetMEPPort": {},
"rttMonEchoAdminTargetMPID": {},
"rttMonEchoAdminTargetMacAddress": {},
"rttMonEchoAdminTargetPort": {},
"rttMonEchoAdminTargetVLAN": {},
"rttMonEchoAdminTstampOptimization": {},
"rttMonEchoAdminURL": {},
"rttMonEchoAdminVideoTrafficProfile": {},
"rttMonEchoAdminVrfName": {},
"rttMonEchoPathAdminHopAddress": {},
"rttMonFileIOAdminAction": {},
"rttMonFileIOAdminFilePath": {},
"rttMonFileIOAdminSize": {},
"rttMonGeneratedOperCtrlAdminIndex": {},
"rttMonGrpScheduleAdminAdd": {},
"rttMonGrpScheduleAdminAgeout": {},
"rttMonGrpScheduleAdminDelete": {},
"rttMonGrpScheduleAdminFreqMax": {},
"rttMonGrpScheduleAdminFreqMin": {},
"rttMonGrpScheduleAdminFrequency": {},
"rttMonGrpScheduleAdminLife": {},
"rttMonGrpScheduleAdminPeriod": {},
"rttMonGrpScheduleAdminProbes": {},
"rttMonGrpScheduleAdminReset": {},
"rttMonGrpScheduleAdminStartDelay": {},
"rttMonGrpScheduleAdminStartTime": {},
"rttMonGrpScheduleAdminStartType": {},
"rttMonGrpScheduleAdminStatus": {},
"rttMonHTTPStatsBusies": {},
"rttMonHTTPStatsCompletions": {},
"rttMonHTTPStatsDNSQueryError": {},
"rttMonHTTPStatsDNSRTTSum": {},
"rttMonHTTPStatsDNSServerTimeout": {},
"rttMonHTTPStatsError": {},
"rttMonHTTPStatsHTTPError": {},
"rttMonHTTPStatsMessageBodyOctetsSum": {},
"rttMonHTTPStatsOverThresholds": {},
"rttMonHTTPStatsRTTMax": {},
"rttMonHTTPStatsRTTMin": {},
"rttMonHTTPStatsRTTSum": {},
"rttMonHTTPStatsRTTSum2High": {},
"rttMonHTTPStatsRTTSum2Low": {},
"rttMonHTTPStatsTCPConnectRTTSum": {},
"rttMonHTTPStatsTCPConnectTimeout": {},
"rttMonHTTPStatsTransactionRTTSum": {},
"rttMonHTTPStatsTransactionTimeout": {},
"rttMonHistoryAdminFilter": {},
"rttMonHistoryAdminNumBuckets": {},
"rttMonHistoryAdminNumLives": {},
"rttMonHistoryAdminNumSamples": {},
"rttMonHistoryCollectionAddress": {},
"rttMonHistoryCollectionApplSpecificSense": {},
"rttMonHistoryCollectionCompletionTime": {},
"rttMonHistoryCollectionSampleTime": {},
"rttMonHistoryCollectionSense": {},
"rttMonHistoryCollectionSenseDescription": {},
"rttMonIcmpJStatsOWSum2DSHighs": {},
"rttMonIcmpJStatsOWSum2DSLows": {},
"rttMonIcmpJStatsOWSum2SDHighs": {},
"rttMonIcmpJStatsOWSum2SDLows": {},
"rttMonIcmpJStatsOverThresholds": {},
"rttMonIcmpJStatsPktOutSeqBoth": {},
"rttMonIcmpJStatsPktOutSeqDSes": {},
"rttMonIcmpJStatsPktOutSeqSDs": {},
"rttMonIcmpJStatsRTTSum2Highs": {},
"rttMonIcmpJStatsRTTSum2Lows": {},
"rttMonIcmpJStatsSum2NegDSHighs": {},
"rttMonIcmpJStatsSum2NegDSLows": {},
"rttMonIcmpJStatsSum2NegSDHighs": {},
"rttMonIcmpJStatsSum2NegSDLows": {},
"rttMonIcmpJStatsSum2PosDSHighs": {},
"rttMonIcmpJStatsSum2PosDSLows": {},
"rttMonIcmpJStatsSum2PosSDHighs": {},
"rttMonIcmpJStatsSum2PosSDLows": {},
"rttMonIcmpJitterMaxSucPktLoss": {},
"rttMonIcmpJitterMinSucPktLoss": {},
"rttMonIcmpJitterStatsAvgJ": {},
"rttMonIcmpJitterStatsAvgJDS": {},
"rttMonIcmpJitterStatsAvgJSD": {},
"rttMonIcmpJitterStatsBusies": {},
"rttMonIcmpJitterStatsCompletions": {},
"rttMonIcmpJitterStatsErrors": {},
"rttMonIcmpJitterStatsIAJIn": {},
"rttMonIcmpJitterStatsIAJOut": {},
"rttMonIcmpJitterStatsMaxNegDS": {},
"rttMonIcmpJitterStatsMaxNegSD": {},
"rttMonIcmpJitterStatsMaxPosDS": {},
"rttMonIcmpJitterStatsMaxPosSD": {},
"rttMonIcmpJitterStatsMinNegDS": {},
"rttMonIcmpJitterStatsMinNegSD": {},
"rttMonIcmpJitterStatsMinPosDS": {},
"rttMonIcmpJitterStatsMinPosSD": {},
"rttMonIcmpJitterStatsNumNegDSes": {},
"rttMonIcmpJitterStatsNumNegSDs": {},
"rttMonIcmpJitterStatsNumOWs": {},
"rttMonIcmpJitterStatsNumOverThresh": {},
"rttMonIcmpJitterStatsNumPosDSes": {},
"rttMonIcmpJitterStatsNumPosSDs": {},
"rttMonIcmpJitterStatsNumRTTs": {},
"rttMonIcmpJitterStatsOWMaxDS": {},
"rttMonIcmpJitterStatsOWMaxSD": {},
"rttMonIcmpJitterStatsOWMinDS": {},
"rttMonIcmpJitterStatsOWMinSD": {},
"rttMonIcmpJitterStatsOWSumDSes": {},
"rttMonIcmpJitterStatsOWSumSDs": {},
"rttMonIcmpJitterStatsPktLateAs": {},
"rttMonIcmpJitterStatsPktLosses": {},
"rttMonIcmpJitterStatsPktSkippeds": {},
"rttMonIcmpJitterStatsRTTMax": {},
"rttMonIcmpJitterStatsRTTMin": {},
"rttMonIcmpJitterStatsRTTSums": {},
"rttMonIcmpJitterStatsSumNegDSes": {},
"rttMonIcmpJitterStatsSumNegSDs": {},
"rttMonIcmpJitterStatsSumPosDSes": {},
"rttMonIcmpJitterStatsSumPosSDs": {},
"rttMonJitterStatsAvgJitter": {},
"rttMonJitterStatsAvgJitterDS": {},
"rttMonJitterStatsAvgJitterSD": {},
"rttMonJitterStatsBusies": {},
"rttMonJitterStatsCompletions": {},
"rttMonJitterStatsError": {},
"rttMonJitterStatsIAJIn": {},
"rttMonJitterStatsIAJOut": {},
"rttMonJitterStatsMaxOfICPIF": {},
"rttMonJitterStatsMaxOfMOS": {},
"rttMonJitterStatsMaxOfNegativesDS": {},
"rttMonJitterStatsMaxOfNegativesSD": {},
"rttMonJitterStatsMaxOfPositivesDS": {},
"rttMonJitterStatsMaxOfPositivesSD": {},
"rttMonJitterStatsMinOfICPIF": {},
"rttMonJitterStatsMinOfMOS": {},
"rttMonJitterStatsMinOfNegativesDS": {},
"rttMonJitterStatsMinOfNegativesSD": {},
"rttMonJitterStatsMinOfPositivesDS": {},
"rttMonJitterStatsMinOfPositivesSD": {},
"rttMonJitterStatsNumOfNegativesDS": {},
"rttMonJitterStatsNumOfNegativesSD": {},
"rttMonJitterStatsNumOfOW": {},
"rttMonJitterStatsNumOfPositivesDS": {},
"rttMonJitterStatsNumOfPositivesSD": {},
"rttMonJitterStatsNumOfRTT": {},
"rttMonJitterStatsNumOverThresh": {},
"rttMonJitterStatsOWMaxDS": {},
"rttMonJitterStatsOWMaxDSNew": {},
"rttMonJitterStatsOWMaxSD": {},
"rttMonJitterStatsOWMaxSDNew": {},
"rttMonJitterStatsOWMinDS": {},
"rttMonJitterStatsOWMinDSNew": {},
"rttMonJitterStatsOWMinSD": {},
"rttMonJitterStatsOWMinSDNew": {},
"rttMonJitterStatsOWSum2DSHigh": {},
"rttMonJitterStatsOWSum2DSLow": {},
"rttMonJitterStatsOWSum2SDHigh": {},
"rttMonJitterStatsOWSum2SDLow": {},
"rttMonJitterStatsOWSumDS": {},
"rttMonJitterStatsOWSumDSHigh": {},
"rttMonJitterStatsOWSumSD": {},
"rttMonJitterStatsOWSumSDHigh": {},
"rttMonJitterStatsOverThresholds": {},
"rttMonJitterStatsPacketLateArrival": {},
"rttMonJitterStatsPacketLossDS": {},
"rttMonJitterStatsPacketLossSD": {},
"rttMonJitterStatsPacketMIA": {},
"rttMonJitterStatsPacketOutOfSequence": {},
"rttMonJitterStatsRTTMax": {},
"rttMonJitterStatsRTTMin": {},
"rttMonJitterStatsRTTSum": {},
"rttMonJitterStatsRTTSum2High": {},
"rttMonJitterStatsRTTSum2Low": {},
"rttMonJitterStatsRTTSumHigh": {},
"rttMonJitterStatsSum2NegativesDSHigh": {},
"rttMonJitterStatsSum2NegativesDSLow": {},
"rttMonJitterStatsSum2NegativesSDHigh": {},
"rttMonJitterStatsSum2NegativesSDLow": {},
"rttMonJitterStatsSum2PositivesDSHigh": {},
"rttMonJitterStatsSum2PositivesDSLow": {},
"rttMonJitterStatsSum2PositivesSDHigh": {},
"rttMonJitterStatsSum2PositivesSDLow": {},
"rttMonJitterStatsSumOfNegativesDS": {},
"rttMonJitterStatsSumOfNegativesSD": {},
"rttMonJitterStatsSumOfPositivesDS": {},
"rttMonJitterStatsSumOfPositivesSD": {},
"rttMonJitterStatsUnSyncRTs": {},
"rttMonLatestHTTPErrorSenseDescription": {},
"rttMonLatestHTTPOperDNSRTT": {},
"rttMonLatestHTTPOperMessageBodyOctets": {},
"rttMonLatestHTTPOperRTT": {},
"rttMonLatestHTTPOperSense": {},
"rttMonLatestHTTPOperTCPConnectRTT": {},
"rttMonLatestHTTPOperTransactionRTT": {},
"rttMonLatestIcmpJPktOutSeqBoth": {},
"rttMonLatestIcmpJPktOutSeqDS": {},
"rttMonLatestIcmpJPktOutSeqSD": {},
"rttMonLatestIcmpJitterAvgDSJ": {},
"rttMonLatestIcmpJitterAvgJitter": {},
"rttMonLatestIcmpJitterAvgSDJ": {},
"rttMonLatestIcmpJitterIAJIn": {},
"rttMonLatestIcmpJitterIAJOut": {},
"rttMonLatestIcmpJitterMaxNegDS": {},
"rttMonLatestIcmpJitterMaxNegSD": {},
"rttMonLatestIcmpJitterMaxPosDS": {},
"rttMonLatestIcmpJitterMaxPosSD": {},
"rttMonLatestIcmpJitterMaxSucPktL": {},
"rttMonLatestIcmpJitterMinNegDS": {},
"rttMonLatestIcmpJitterMinNegSD": {},
"rttMonLatestIcmpJitterMinPosDS": {},
"rttMonLatestIcmpJitterMinPosSD": {},
"rttMonLatestIcmpJitterMinSucPktL": {},
"rttMonLatestIcmpJitterNumNegDS": {},
"rttMonLatestIcmpJitterNumNegSD": {},
"rttMonLatestIcmpJitterNumOW": {},
"rttMonLatestIcmpJitterNumOverThresh": {},
"rttMonLatestIcmpJitterNumPosDS": {},
"rttMonLatestIcmpJitterNumPosSD": {},
"rttMonLatestIcmpJitterNumRTT": {},
"rttMonLatestIcmpJitterOWAvgDS": {},
"rttMonLatestIcmpJitterOWAvgSD": {},
"rttMonLatestIcmpJitterOWMaxDS": {},
"rttMonLatestIcmpJitterOWMaxSD": {},
"rttMonLatestIcmpJitterOWMinDS": {},
"rttMonLatestIcmpJitterOWMinSD": {},
"rttMonLatestIcmpJitterOWSum2DS": {},
"rttMonLatestIcmpJitterOWSum2SD": {},
"rttMonLatestIcmpJitterOWSumDS": {},
"rttMonLatestIcmpJitterOWSumSD": {},
"rttMonLatestIcmpJitterPktLateA": {},
"rttMonLatestIcmpJitterPktLoss": {},
"rttMonLatestIcmpJitterPktSkipped": {},
"rttMonLatestIcmpJitterRTTMax": {},
"rttMonLatestIcmpJitterRTTMin": {},
"rttMonLatestIcmpJitterRTTSum": {},
"rttMonLatestIcmpJitterRTTSum2": {},
"rttMonLatestIcmpJitterSense": {},
"rttMonLatestIcmpJitterSum2NegDS": {},
"rttMonLatestIcmpJitterSum2NegSD": {},
"rttMonLatestIcmpJitterSum2PosDS": {},
"rttMonLatestIcmpJitterSum2PosSD": {},
"rttMonLatestIcmpJitterSumNegDS": {},
"rttMonLatestIcmpJitterSumNegSD": {},
"rttMonLatestIcmpJitterSumPosDS": {},
"rttMonLatestIcmpJitterSumPosSD": {},
"rttMonLatestJitterErrorSenseDescription": {},
"rttMonLatestJitterOperAvgDSJ": {},
"rttMonLatestJitterOperAvgJitter": {},
"rttMonLatestJitterOperAvgSDJ": {},
"rttMonLatestJitterOperIAJIn": {},
"rttMonLatestJitterOperIAJOut": {},
"rttMonLatestJitterOperICPIF": {},
"rttMonLatestJitterOperMOS": {},
"rttMonLatestJitterOperMaxOfNegativesDS": {},
"rttMonLatestJitterOperMaxOfNegativesSD": {},
"rttMonLatestJitterOperMaxOfPositivesDS": {},
"rttMonLatestJitterOperMaxOfPositivesSD": {},
"rttMonLatestJitterOperMinOfNegativesDS": {},
"rttMonLatestJitterOperMinOfNegativesSD": {},
"rttMonLatestJitterOperMinOfPositivesDS": {},
"rttMonLatestJitterOperMinOfPositivesSD": {},
"rttMonLatestJitterOperNTPState": {},
"rttMonLatestJitterOperNumOfNegativesDS": {},
"rttMonLatestJitterOperNumOfNegativesSD": {},
"rttMonLatestJitterOperNumOfOW": {},
"rttMonLatestJitterOperNumOfPositivesDS": {},
"rttMonLatestJitterOperNumOfPositivesSD": {},
"rttMonLatestJitterOperNumOfRTT": {},
"rttMonLatestJitterOperNumOverThresh": {},
"rttMonLatestJitterOperOWAvgDS": {},
"rttMonLatestJitterOperOWAvgSD": {},
"rttMonLatestJitterOperOWMaxDS": {},
"rttMonLatestJitterOperOWMaxSD": {},
"rttMonLatestJitterOperOWMinDS": {},
"rttMonLatestJitterOperOWMinSD": {},
"rttMonLatestJitterOperOWSum2DS": {},
"rttMonLatestJitterOperOWSum2DSHigh": {},
"rttMonLatestJitterOperOWSum2SD": {},
"rttMonLatestJitterOperOWSum2SDHigh": {},
"rttMonLatestJitterOperOWSumDS": {},
"rttMonLatestJitterOperOWSumDSHigh": {},
"rttMonLatestJitterOperOWSumSD": {},
"rttMonLatestJitterOperOWSumSDHigh": {},
"rttMonLatestJitterOperPacketLateArrival": {},
"rttMonLatestJitterOperPacketLossDS": {},
"rttMonLatestJitterOperPacketLossSD": {},
"rttMonLatestJitterOperPacketMIA": {},
"rttMonLatestJitterOperPacketOutOfSequence": {},
"rttMonLatestJitterOperRTTMax": {},
"rttMonLatestJitterOperRTTMin": {},
"rttMonLatestJitterOperRTTSum": {},
"rttMonLatestJitterOperRTTSum2": {},
"rttMonLatestJitterOperRTTSum2High": {},
"rttMonLatestJitterOperRTTSumHigh": {},
"rttMonLatestJitterOperSense": {},
"rttMonLatestJitterOperSum2NegativesDS": {},
"rttMonLatestJitterOperSum2NegativesSD": {},
"rttMonLatestJitterOperSum2PositivesDS": {},
"rttMonLatestJitterOperSum2PositivesSD": {},
"rttMonLatestJitterOperSumOfNegativesDS": {},
"rttMonLatestJitterOperSumOfNegativesSD": {},
"rttMonLatestJitterOperSumOfPositivesDS": {},
"rttMonLatestJitterOperSumOfPositivesSD": {},
"rttMonLatestJitterOperUnSyncRTs": {},
"rttMonLatestRtpErrorSenseDescription": {},
"rttMonLatestRtpOperAvgOWDS": {},
"rttMonLatestRtpOperAvgOWSD": {},
"rttMonLatestRtpOperFrameLossDS": {},
"rttMonLatestRtpOperIAJitterDS": {},
"rttMonLatestRtpOperIAJitterSD": {},
"rttMonLatestRtpOperMOSCQDS": {},
"rttMonLatestRtpOperMOSCQSD": {},
"rttMonLatestRtpOperMOSLQDS": {},
"rttMonLatestRtpOperMaxOWDS": {},
"rttMonLatestRtpOperMaxOWSD": {},
"rttMonLatestRtpOperMinOWDS": {},
"rttMonLatestRtpOperMinOWSD": {},
"rttMonLatestRtpOperPacketEarlyDS": {},
"rttMonLatestRtpOperPacketLateDS": {},
"rttMonLatestRtpOperPacketLossDS": {},
"rttMonLatestRtpOperPacketLossSD": {},
"rttMonLatestRtpOperPacketOOSDS": {},
"rttMonLatestRtpOperPacketsMIA": {},
"rttMonLatestRtpOperRFactorDS": {},
"rttMonLatestRtpOperRFactorSD": {},
"rttMonLatestRtpOperRTT": {},
"rttMonLatestRtpOperSense": {},
"rttMonLatestRtpOperTotalPaksDS": {},
"rttMonLatestRtpOperTotalPaksSD": {},
"rttMonLatestRttOperAddress": {},
"rttMonLatestRttOperApplSpecificSense": {},
"rttMonLatestRttOperCompletionTime": {},
"rttMonLatestRttOperSense": {},
"rttMonLatestRttOperSenseDescription": {},
"rttMonLatestRttOperTime": {},
"rttMonLpdGrpStatsAvgRTT": {},
"rttMonLpdGrpStatsGroupProbeIndex": {},
"rttMonLpdGrpStatsGroupStatus": {},
"rttMonLpdGrpStatsLPDCompTime": {},
"rttMonLpdGrpStatsLPDFailCause": {},
"rttMonLpdGrpStatsLPDFailOccurred": {},
"rttMonLpdGrpStatsLPDStartTime": {},
"rttMonLpdGrpStatsMaxNumPaths": {},
"rttMonLpdGrpStatsMaxRTT": {},
"rttMonLpdGrpStatsMinNumPaths": {},
"rttMonLpdGrpStatsMinRTT": {},
"rttMonLpdGrpStatsNumOfFail": {},
"rttMonLpdGrpStatsNumOfPass": {},
"rttMonLpdGrpStatsNumOfTimeout": {},
"rttMonLpdGrpStatsPathIds": {},
"rttMonLpdGrpStatsProbeStatus": {},
"rttMonLpdGrpStatsResetTime": {},
"rttMonLpdGrpStatsTargetPE": {},
"rttMonReactActionType": {},
"rttMonReactAdminActionType": {},
"rttMonReactAdminConnectionEnable": {},
"rttMonReactAdminThresholdCount": {},
"rttMonReactAdminThresholdCount2": {},
"rttMonReactAdminThresholdFalling": {},
"rttMonReactAdminThresholdType": {},
"rttMonReactAdminTimeoutEnable": {},
"rttMonReactAdminVerifyErrorEnable": {},
"rttMonReactOccurred": {},
"rttMonReactStatus": {},
"rttMonReactThresholdCountX": {},
"rttMonReactThresholdCountY": {},
"rttMonReactThresholdFalling": {},
"rttMonReactThresholdRising": {},
"rttMonReactThresholdType": {},
"rttMonReactTriggerAdminStatus": {},
"rttMonReactTriggerOperState": {},
"rttMonReactValue": {},
"rttMonReactVar": {},
"rttMonRtpStatsFrameLossDSAvg": {},
"rttMonRtpStatsFrameLossDSMax": {},
"rttMonRtpStatsFrameLossDSMin": {},
"rttMonRtpStatsIAJitterDSAvg": {},
"rttMonRtpStatsIAJitterDSMax": {},
"rttMonRtpStatsIAJitterDSMin": {},
"rttMonRtpStatsIAJitterSDAvg": {},
"rttMonRtpStatsIAJitterSDMax": {},
"rttMonRtpStatsIAJitterSDMin": {},
"rttMonRtpStatsMOSCQDSAvg": {},
"rttMonRtpStatsMOSCQDSMax": {},
"rttMonRtpStatsMOSCQDSMin": {},
"rttMonRtpStatsMOSCQSDAvg": {},
"rttMonRtpStatsMOSCQSDMax": {},
"rttMonRtpStatsMOSCQSDMin": {},
"rttMonRtpStatsMOSLQDSAvg": {},
"rttMonRtpStatsMOSLQDSMax": {},
"rttMonRtpStatsMOSLQDSMin": {},
"rttMonRtpStatsOperAvgOWDS": {},
"rttMonRtpStatsOperAvgOWSD": {},
"rttMonRtpStatsOperMaxOWDS": {},
"rttMonRtpStatsOperMaxOWSD": {},
"rttMonRtpStatsOperMinOWDS": {},
"rttMonRtpStatsOperMinOWSD": {},
"rttMonRtpStatsPacketEarlyDSAvg": {},
"rttMonRtpStatsPacketLateDSAvg": {},
"rttMonRtpStatsPacketLossDSAvg": {},
"rttMonRtpStatsPacketLossDSMax": {},
"rttMonRtpStatsPacketLossDSMin": {},
"rttMonRtpStatsPacketLossSDAvg": {},
"rttMonRtpStatsPacketLossSDMax": {},
"rttMonRtpStatsPacketLossSDMin": {},
"rttMonRtpStatsPacketOOSDSAvg": {},
"rttMonRtpStatsPacketsMIAAvg": {},
"rttMonRtpStatsRFactorDSAvg": {},
"rttMonRtpStatsRFactorDSMax": {},
"rttMonRtpStatsRFactorDSMin": {},
"rttMonRtpStatsRFactorSDAvg": {},
"rttMonRtpStatsRFactorSDMax": {},
"rttMonRtpStatsRFactorSDMin": {},
"rttMonRtpStatsRTTAvg": {},
"rttMonRtpStatsRTTMax": {},
"rttMonRtpStatsRTTMin": {},
"rttMonRtpStatsTotalPacketsDSAvg": {},
"rttMonRtpStatsTotalPacketsDSMax": {},
"rttMonRtpStatsTotalPacketsDSMin": {},
"rttMonRtpStatsTotalPacketsSDAvg": {},
"rttMonRtpStatsTotalPacketsSDMax": {},
"rttMonRtpStatsTotalPacketsSDMin": {},
"rttMonScheduleAdminConceptRowAgeout": {},
"rttMonScheduleAdminConceptRowAgeoutV2": {},
"rttMonScheduleAdminRttLife": {},
"rttMonScheduleAdminRttRecurring": {},
"rttMonScheduleAdminRttStartTime": {},
"rttMonScheduleAdminStartDelay": {},
"rttMonScheduleAdminStartType": {},
"rttMonScriptAdminCmdLineParams": {},
"rttMonScriptAdminName": {},
"rttMonStatisticsAdminDistInterval": {},
"rttMonStatisticsAdminNumDistBuckets": {},
"rttMonStatisticsAdminNumHops": {},
"rttMonStatisticsAdminNumHourGroups": {},
"rttMonStatisticsAdminNumPaths": {},
"rttMonStatsCaptureCompletionTimeMax": {},
"rttMonStatsCaptureCompletionTimeMin": {},
"rttMonStatsCaptureCompletions": {},
"rttMonStatsCaptureOverThresholds": {},
"rttMonStatsCaptureSumCompletionTime": {},
"rttMonStatsCaptureSumCompletionTime2High": {},
"rttMonStatsCaptureSumCompletionTime2Low": {},
"rttMonStatsCollectAddress": {},
"rttMonStatsCollectBusies": {},
"rttMonStatsCollectCtrlEnErrors": {},
"rttMonStatsCollectDrops": {},
"rttMonStatsCollectNoConnections": {},
"rttMonStatsCollectNumDisconnects": {},
"rttMonStatsCollectRetrieveErrors": {},
"rttMonStatsCollectSequenceErrors": {},
"rttMonStatsCollectTimeouts": {},
"rttMonStatsCollectVerifyErrors": {},
"rttMonStatsRetrieveErrors": {},
"rttMonStatsTotalsElapsedTime": {},
"rttMonStatsTotalsInitiations": {},
"rttMplsVpnMonCtrlDelScanFactor": {},
"rttMplsVpnMonCtrlEXP": {},
"rttMplsVpnMonCtrlLpd": {},
"rttMplsVpnMonCtrlLpdCompTime": {},
"rttMplsVpnMonCtrlLpdGrpList": {},
"rttMplsVpnMonCtrlProbeList": {},
"rttMplsVpnMonCtrlRequestSize": {},
"rttMplsVpnMonCtrlRttType": {},
"rttMplsVpnMonCtrlScanInterval": {},
"rttMplsVpnMonCtrlStatus": {},
"rttMplsVpnMonCtrlStorageType": {},
"rttMplsVpnMonCtrlTag": {},
"rttMplsVpnMonCtrlThreshold": {},
"rttMplsVpnMonCtrlTimeout": {},
"rttMplsVpnMonCtrlVerifyData": {},
"rttMplsVpnMonCtrlVrfName": {},
"rttMplsVpnMonReactActionType": {},
"rttMplsVpnMonReactConnectionEnable": {},
"rttMplsVpnMonReactLpdNotifyType": {},
"rttMplsVpnMonReactLpdRetryCount": {},
"rttMplsVpnMonReactThresholdCount": {},
"rttMplsVpnMonReactThresholdType": {},
"rttMplsVpnMonReactTimeoutEnable": {},
"rttMplsVpnMonScheduleFrequency": {},
"rttMplsVpnMonSchedulePeriod": {},
"rttMplsVpnMonScheduleRttStartTime": {},
"rttMplsVpnMonTypeDestPort": {},
"rttMplsVpnMonTypeInterval": {},
"rttMplsVpnMonTypeLSPReplyDscp": {},
"rttMplsVpnMonTypeLSPReplyMode": {},
"rttMplsVpnMonTypeLSPTTL": {},
"rttMplsVpnMonTypeLpdEchoInterval": {},
"rttMplsVpnMonTypeLpdEchoNullShim": {},
"rttMplsVpnMonTypeLpdEchoTimeout": {},
"rttMplsVpnMonTypeLpdMaxSessions": {},
"rttMplsVpnMonTypeLpdScanPeriod": {},
"rttMplsVpnMonTypeLpdSessTimeout": {},
"rttMplsVpnMonTypeLpdStatHours": {},
"rttMplsVpnMonTypeLspSelector": {},
"rttMplsVpnMonTypeNumPackets": {},
"rttMplsVpnMonTypeSecFreqType": {},
"rttMplsVpnMonTypeSecFreqValue": {},
"sapCircEntry": {
"1": {},
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"sapSysEntry": {"1": {}, "2": {}, "3": {}},
"sdlcLSAdminEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"sdlcLSOperEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"sdlcLSStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"37": {},
"38": {},
"39": {},
"4": {},
"40": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"sdlcPortAdminEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"sdlcPortOperEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"sdlcPortStatsEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"snmp": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"32": {},
"4": {},
"5": {},
"6": {},
"8": {},
"9": {},
},
"snmpCommunityMIB.10.4.1.2": {},
"snmpCommunityMIB.10.4.1.3": {},
"snmpCommunityMIB.10.4.1.4": {},
"snmpCommunityMIB.10.4.1.5": {},
"snmpCommunityMIB.10.4.1.6": {},
"snmpCommunityMIB.10.4.1.7": {},
"snmpCommunityMIB.10.4.1.8": {},
"snmpCommunityMIB.10.9.1.1": {},
"snmpCommunityMIB.10.9.1.2": {},
"snmpFrameworkMIB.2.1.1": {},
"snmpFrameworkMIB.2.1.2": {},
"snmpFrameworkMIB.2.1.3": {},
"snmpFrameworkMIB.2.1.4": {},
"snmpMIB.1.6.1": {},
"snmpMPDMIB.2.1.1": {},
"snmpMPDMIB.2.1.2": {},
"snmpMPDMIB.2.1.3": {},
"snmpNotificationMIB.10.4.1.2": {},
"snmpNotificationMIB.10.4.1.3": {},
"snmpNotificationMIB.10.4.1.4": {},
"snmpNotificationMIB.10.4.1.5": {},
"snmpNotificationMIB.10.9.1.1": {},
"snmpNotificationMIB.10.9.1.2": {},
"snmpNotificationMIB.10.9.1.3": {},
"snmpNotificationMIB.10.16.1.2": {},
"snmpNotificationMIB.10.16.1.3": {},
"snmpNotificationMIB.10.16.1.4": {},
"snmpNotificationMIB.10.16.1.5": {},
"snmpProxyMIB.10.9.1.2": {},
"snmpProxyMIB.10.9.1.3": {},
"snmpProxyMIB.10.9.1.4": {},
"snmpProxyMIB.10.9.1.5": {},
"snmpProxyMIB.10.9.1.6": {},
"snmpProxyMIB.10.9.1.7": {},
"snmpProxyMIB.10.9.1.8": {},
"snmpProxyMIB.10.9.1.9": {},
"snmpTargetMIB.1.1": {},
"snmpTargetMIB.10.9.1.2": {},
"snmpTargetMIB.10.9.1.3": {},
"snmpTargetMIB.10.9.1.4": {},
"snmpTargetMIB.10.9.1.5": {},
"snmpTargetMIB.10.9.1.6": {},
"snmpTargetMIB.10.9.1.7": {},
"snmpTargetMIB.10.9.1.8": {},
"snmpTargetMIB.10.9.1.9": {},
"snmpTargetMIB.10.16.1.2": {},
"snmpTargetMIB.10.16.1.3": {},
"snmpTargetMIB.10.16.1.4": {},
"snmpTargetMIB.10.16.1.5": {},
"snmpTargetMIB.10.16.1.6": {},
"snmpTargetMIB.10.16.1.7": {},
"snmpTargetMIB.1.4": {},
"snmpTargetMIB.1.5": {},
"snmpUsmMIB.1.1.1": {},
"snmpUsmMIB.1.1.2": {},
"snmpUsmMIB.1.1.3": {},
"snmpUsmMIB.1.1.4": {},
"snmpUsmMIB.1.1.5": {},
"snmpUsmMIB.1.1.6": {},
"snmpUsmMIB.1.2.1": {},
"snmpUsmMIB.10.9.2.1.10": {},
"snmpUsmMIB.10.9.2.1.11": {},
"snmpUsmMIB.10.9.2.1.12": {},
"snmpUsmMIB.10.9.2.1.13": {},
"snmpUsmMIB.10.9.2.1.3": {},
"snmpUsmMIB.10.9.2.1.4": {},
"snmpUsmMIB.10.9.2.1.5": {},
"snmpUsmMIB.10.9.2.1.6": {},
"snmpUsmMIB.10.9.2.1.7": {},
"snmpUsmMIB.10.9.2.1.8": {},
"snmpUsmMIB.10.9.2.1.9": {},
"snmpVacmMIB.10.4.1.1": {},
"snmpVacmMIB.10.9.1.3": {},
"snmpVacmMIB.10.9.1.4": {},
"snmpVacmMIB.10.9.1.5": {},
"snmpVacmMIB.10.25.1.4": {},
"snmpVacmMIB.10.25.1.5": {},
"snmpVacmMIB.10.25.1.6": {},
"snmpVacmMIB.10.25.1.7": {},
"snmpVacmMIB.10.25.1.8": {},
"snmpVacmMIB.10.25.1.9": {},
"snmpVacmMIB.1.5.1": {},
"snmpVacmMIB.10.36.2.1.3": {},
"snmpVacmMIB.10.36.2.1.4": {},
"snmpVacmMIB.10.36.2.1.5": {},
"snmpVacmMIB.10.36.2.1.6": {},
"sonetFarEndLineCurrentEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"sonetFarEndLineIntervalEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"sonetFarEndPathCurrentEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"sonetFarEndPathIntervalEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"sonetFarEndVTCurrentEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"sonetFarEndVTIntervalEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"sonetLineCurrentEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"sonetLineIntervalEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"sonetMedium": {"2": {}},
"sonetMediumEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"sonetPathCurrentEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"sonetPathIntervalEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"sonetSectionCurrentEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"sonetSectionIntervalEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"sonetVTCurrentEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"sonetVTIntervalEntry": {"2": {}, "3": {}, "4": {}, "5": {}, "6": {}},
"srpErrCntCurrEntry": {
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"srpErrCntIntEntry": {
"10": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"srpErrorsCountersCurrentEntry": {
"10": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"srpErrorsCountersIntervalEntry": {
"10": {},
"11": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"srpHostCountersCurrentEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"srpHostCountersIntervalEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"srpIfEntry": {
"1": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
},
"srpMACCountersEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"srpMACSideEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"srpRingCountersCurrentEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"srpRingCountersIntervalEntry": {
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"srpRingTopologyMapEntry": {"2": {}, "3": {}, "4": {}},
"stunGlobal": {"1": {}},
"stunGroupEntry": {"2": {}},
"stunPortEntry": {"1": {}, "2": {}, "3": {}, "4": {}},
"stunRouteEntry": {
"10": {},
"11": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"sysOREntry": {"2": {}, "3": {}, "4": {}},
"sysUpTime": {},
"system": {"1": {}, "2": {}, "4": {}, "5": {}, "6": {}, "7": {}, "8": {}},
"tcp": {
"1": {},
"10": {},
"11": {},
"12": {},
"14": {},
"15": {},
"17": {},
"18": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"tcp.19.1.7": {},
"tcp.19.1.8": {},
"tcp.20.1.4": {},
"tcpConnEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
"tmpappletalk": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"4": {},
"5": {},
"7": {},
"8": {},
"9": {},
},
"tmpdecnet": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"tmpnovell": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"22": {},
"24": {},
"25": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"tmpvines": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"tmpxns": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"tunnelConfigIfIndex": {},
"tunnelConfigStatus": {},
"tunnelIfAddressType": {},
"tunnelIfEncapsLimit": {},
"tunnelIfEncapsMethod": {},
"tunnelIfFlowLabel": {},
"tunnelIfHopLimit": {},
"tunnelIfLocalAddress": {},
"tunnelIfLocalInetAddress": {},
"tunnelIfRemoteAddress": {},
"tunnelIfRemoteInetAddress": {},
"tunnelIfSecurity": {},
"tunnelIfTOS": {},
"tunnelInetConfigIfIndex": {},
"tunnelInetConfigStatus": {},
"tunnelInetConfigStorageType": {},
"udp": {"1": {}, "2": {}, "3": {}, "4": {}, "8": {}, "9": {}},
"udp.7.1.8": {},
"udpEntry": {"1": {}, "2": {}},
"vinesIfTableEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"31": {},
"32": {},
"33": {},
"34": {},
"35": {},
"36": {},
"37": {},
"38": {},
"39": {},
"4": {},
"40": {},
"41": {},
"42": {},
"43": {},
"44": {},
"45": {},
"46": {},
"47": {},
"48": {},
"49": {},
"5": {},
"50": {},
"51": {},
"52": {},
"53": {},
"54": {},
"55": {},
"56": {},
"57": {},
"58": {},
"59": {},
"6": {},
"60": {},
"61": {},
"62": {},
"63": {},
"64": {},
"65": {},
"66": {},
"67": {},
"68": {},
"69": {},
"70": {},
"71": {},
"72": {},
"73": {},
"74": {},
"75": {},
"76": {},
"77": {},
"78": {},
"79": {},
"8": {},
"80": {},
"81": {},
"82": {},
"83": {},
"9": {},
},
"vrrpAssoIpAddrRowStatus": {},
"vrrpNodeVersion": {},
"vrrpNotificationCntl": {},
"vrrpOperAdminState": {},
"vrrpOperAdvertisementInterval": {},
"vrrpOperAuthKey": {},
"vrrpOperAuthType": {},
"vrrpOperIpAddrCount": {},
"vrrpOperMasterIpAddr": {},
"vrrpOperPreemptMode": {},
"vrrpOperPrimaryIpAddr": {},
"vrrpOperPriority": {},
"vrrpOperProtocol": {},
"vrrpOperRowStatus": {},
"vrrpOperState": {},
"vrrpOperVirtualMacAddr": {},
"vrrpOperVirtualRouterUpTime": {},
"vrrpRouterChecksumErrors": {},
"vrrpRouterVersionErrors": {},
"vrrpRouterVrIdErrors": {},
"vrrpStatsAddressListErrors": {},
"vrrpStatsAdvertiseIntervalErrors": {},
"vrrpStatsAdvertiseRcvd": {},
"vrrpStatsAuthFailures": {},
"vrrpStatsAuthTypeMismatch": {},
"vrrpStatsBecomeMaster": {},
"vrrpStatsInvalidAuthType": {},
"vrrpStatsInvalidTypePktsRcvd": {},
"vrrpStatsIpTtlErrors": {},
"vrrpStatsPacketLengthErrors": {},
"vrrpStatsPriorityZeroPktsRcvd": {},
"vrrpStatsPriorityZeroPktsSent": {},
"vrrpTrapAuthErrorType": {},
"vrrpTrapPacketSrc": {},
"x25": {"6": {}, "7": {}},
"x25AdmnEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"x25CallParmEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"26": {},
"27": {},
"28": {},
"29": {},
"3": {},
"30": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"x25ChannelEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}, "6": {}, "7": {}},
"x25CircuitEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"x25ClearedCircuitEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"2": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"x25OperEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"x25StatEntry": {
"1": {},
"10": {},
"11": {},
"12": {},
"13": {},
"14": {},
"15": {},
"16": {},
"17": {},
"18": {},
"19": {},
"2": {},
"20": {},
"21": {},
"22": {},
"23": {},
"24": {},
"25": {},
"3": {},
"4": {},
"5": {},
"6": {},
"7": {},
"8": {},
"9": {},
},
"xdsl2ChAlarmConfProfileRowStatus": {},
"xdsl2ChAlarmConfProfileXtucThresh15MinCodingViolations": {},
"xdsl2ChAlarmConfProfileXtucThresh15MinCorrected": {},
"xdsl2ChAlarmConfProfileXturThresh15MinCodingViolations": {},
"xdsl2ChAlarmConfProfileXturThresh15MinCorrected": {},
"xdsl2ChConfProfDsDataRateDs": {},
"xdsl2ChConfProfDsDataRateUs": {},
"xdsl2ChConfProfImaEnabled": {},
"xdsl2ChConfProfInitPolicy": {},
"xdsl2ChConfProfMaxBerDs": {},
"xdsl2ChConfProfMaxBerUs": {},
"xdsl2ChConfProfMaxDataRateDs": {},
"xdsl2ChConfProfMaxDataRateUs": {},
"xdsl2ChConfProfMaxDelayDs": {},
"xdsl2ChConfProfMaxDelayUs": {},
"xdsl2ChConfProfMaxDelayVar": {},
"xdsl2ChConfProfMinDataRateDs": {},
"xdsl2ChConfProfMinDataRateLowPwrDs": {},
"xdsl2ChConfProfMinDataRateLowPwrUs": {},
"xdsl2ChConfProfMinDataRateUs": {},
"xdsl2ChConfProfMinProtection8Ds": {},
"xdsl2ChConfProfMinProtection8Us": {},
"xdsl2ChConfProfMinProtectionDs": {},
"xdsl2ChConfProfMinProtectionUs": {},
"xdsl2ChConfProfMinResDataRateDs": {},
"xdsl2ChConfProfMinResDataRateUs": {},
"xdsl2ChConfProfRowStatus": {},
"xdsl2ChConfProfUsDataRateDs": {},
"xdsl2ChConfProfUsDataRateUs": {},
"xdsl2ChStatusActDataRate": {},
"xdsl2ChStatusActDelay": {},
"xdsl2ChStatusActInp": {},
"xdsl2ChStatusAtmStatus": {},
"xdsl2ChStatusInpReport": {},
"xdsl2ChStatusIntlvBlock": {},
"xdsl2ChStatusIntlvDepth": {},
"xdsl2ChStatusLPath": {},
"xdsl2ChStatusLSymb": {},
"xdsl2ChStatusNFec": {},
"xdsl2ChStatusPrevDataRate": {},
"xdsl2ChStatusPtmStatus": {},
"xdsl2ChStatusRFec": {},
"xdsl2LAlarmConfTempChan1ConfProfile": {},
"xdsl2LAlarmConfTempChan2ConfProfile": {},
"xdsl2LAlarmConfTempChan3ConfProfile": {},
"xdsl2LAlarmConfTempChan4ConfProfile": {},
"xdsl2LAlarmConfTempLineProfile": {},
"xdsl2LAlarmConfTempRowStatus": {},
"xdsl2LConfProfCeFlag": {},
"xdsl2LConfProfClassMask": {},
"xdsl2LConfProfDpboEPsd": {},
"xdsl2LConfProfDpboEsCableModelA": {},
"xdsl2LConfProfDpboEsCableModelB": {},
"xdsl2LConfProfDpboEsCableModelC": {},
"xdsl2LConfProfDpboEsEL": {},
"xdsl2LConfProfDpboFMax": {},
"xdsl2LConfProfDpboFMin": {},
"xdsl2LConfProfDpboMus": {},
"xdsl2LConfProfForceInp": {},
"xdsl2LConfProfL0Time": {},
"xdsl2LConfProfL2Atpr": {},
"xdsl2LConfProfL2Atprt": {},
"xdsl2LConfProfL2Time": {},
"xdsl2LConfProfLimitMask": {},
"xdsl2LConfProfMaxAggRxPwrUs": {},
"xdsl2LConfProfMaxNomAtpDs": {},
"xdsl2LConfProfMaxNomAtpUs": {},
"xdsl2LConfProfMaxNomPsdDs": {},
"xdsl2LConfProfMaxNomPsdUs": {},
"xdsl2LConfProfMaxSnrmDs": {},
"xdsl2LConfProfMaxSnrmUs": {},
"xdsl2LConfProfMinSnrmDs": {},
"xdsl2LConfProfMinSnrmUs": {},
"xdsl2LConfProfModeSpecBandUsRowStatus": {},
"xdsl2LConfProfModeSpecRowStatus": {},
"xdsl2LConfProfMsgMinDs": {},
"xdsl2LConfProfMsgMinUs": {},
"xdsl2LConfProfPmMode": {},
"xdsl2LConfProfProfiles": {},
"xdsl2LConfProfPsdMaskDs": {},
"xdsl2LConfProfPsdMaskSelectUs": {},
"xdsl2LConfProfPsdMaskUs": {},
"xdsl2LConfProfRaDsNrmDs": {},
"xdsl2LConfProfRaDsNrmUs": {},
"xdsl2LConfProfRaDsTimeDs": {},
"xdsl2LConfProfRaDsTimeUs": {},
"xdsl2LConfProfRaModeDs": {},
"xdsl2LConfProfRaModeUs": {},
"xdsl2LConfProfRaUsNrmDs": {},
"xdsl2LConfProfRaUsNrmUs": {},
"xdsl2LConfProfRaUsTimeDs": {},
"xdsl2LConfProfRaUsTimeUs": {},
"xdsl2LConfProfRfiBands": {},
"xdsl2LConfProfRowStatus": {},
"xdsl2LConfProfScMaskDs": {},
"xdsl2LConfProfScMaskUs": {},
"xdsl2LConfProfSnrModeDs": {},
"xdsl2LConfProfSnrModeUs": {},
"xdsl2LConfProfTargetSnrmDs": {},
"xdsl2LConfProfTargetSnrmUs": {},
"xdsl2LConfProfTxRefVnDs": {},
"xdsl2LConfProfTxRefVnUs": {},
"xdsl2LConfProfUpboKL": {},
"xdsl2LConfProfUpboKLF": {},
"xdsl2LConfProfUpboPsdA": {},
"xdsl2LConfProfUpboPsdB": {},
"xdsl2LConfProfUs0Disable": {},
"xdsl2LConfProfUs0Mask": {},
"xdsl2LConfProfVdsl2CarMask": {},
"xdsl2LConfProfXtuTransSysEna": {},
"xdsl2LConfTempChan1ConfProfile": {},
"xdsl2LConfTempChan1RaRatioDs": {},
"xdsl2LConfTempChan1RaRatioUs": {},
"xdsl2LConfTempChan2ConfProfile": {},
"xdsl2LConfTempChan2RaRatioDs": {},
"xdsl2LConfTempChan2RaRatioUs": {},
"xdsl2LConfTempChan3ConfProfile": {},
"xdsl2LConfTempChan3RaRatioDs": {},
"xdsl2LConfTempChan3RaRatioUs": {},
"xdsl2LConfTempChan4ConfProfile": {},
"xdsl2LConfTempChan4RaRatioDs": {},
"xdsl2LConfTempChan4RaRatioUs": {},
"xdsl2LConfTempLineProfile": {},
"xdsl2LConfTempRowStatus": {},
"xdsl2LInvG994VendorId": {},
"xdsl2LInvSelfTestResult": {},
"xdsl2LInvSerialNumber": {},
"xdsl2LInvSystemVendorId": {},
"xdsl2LInvTransmissionCapabilities": {},
"xdsl2LInvVersionNumber": {},
"xdsl2LineAlarmConfProfileRowStatus": {},
"xdsl2LineAlarmConfProfileThresh15MinFailedFullInt": {},
"xdsl2LineAlarmConfProfileThresh15MinFailedShrtInt": {},
"xdsl2LineAlarmConfProfileXtucThresh15MinEs": {},
"xdsl2LineAlarmConfProfileXtucThresh15MinFecs": {},
"xdsl2LineAlarmConfProfileXtucThresh15MinLoss": {},
"xdsl2LineAlarmConfProfileXtucThresh15MinSes": {},
"xdsl2LineAlarmConfProfileXtucThresh15MinUas": {},
"xdsl2LineAlarmConfProfileXturThresh15MinEs": {},
"xdsl2LineAlarmConfProfileXturThresh15MinFecs": {},
"xdsl2LineAlarmConfProfileXturThresh15MinLoss": {},
"xdsl2LineAlarmConfProfileXturThresh15MinSes": {},
"xdsl2LineAlarmConfProfileXturThresh15MinUas": {},
"xdsl2LineAlarmConfTemplate": {},
"xdsl2LineBandStatusLnAtten": {},
"xdsl2LineBandStatusSigAtten": {},
"xdsl2LineBandStatusSnrMargin": {},
"xdsl2LineCmndAutomodeColdStart": {},
"xdsl2LineCmndConfBpsc": {},
"xdsl2LineCmndConfBpscFailReason": {},
"xdsl2LineCmndConfBpscRequests": {},
"xdsl2LineCmndConfLdsf": {},
"xdsl2LineCmndConfLdsfFailReason": {},
"xdsl2LineCmndConfPmsf": {},
"xdsl2LineCmndConfReset": {},
"xdsl2LineConfFallbackTemplate": {},
"xdsl2LineConfTemplate": {},
"xdsl2LineSegmentBitsAlloc": {},
"xdsl2LineSegmentRowStatus": {},
"xdsl2LineStatusActAtpDs": {},
"xdsl2LineStatusActAtpUs": {},
"xdsl2LineStatusActLimitMask": {},
"xdsl2LineStatusActProfile": {},
"xdsl2LineStatusActPsdDs": {},
"xdsl2LineStatusActPsdUs": {},
"xdsl2LineStatusActSnrModeDs": {},
"xdsl2LineStatusActSnrModeUs": {},
"xdsl2LineStatusActTemplate": {},
"xdsl2LineStatusActUs0Mask": {},
"xdsl2LineStatusActualCe": {},
"xdsl2LineStatusAttainableRateDs": {},
"xdsl2LineStatusAttainableRateUs": {},
"xdsl2LineStatusElectricalLength": {},
"xdsl2LineStatusInitResult": {},
"xdsl2LineStatusLastStateDs": {},
"xdsl2LineStatusLastStateUs": {},
"xdsl2LineStatusMrefPsdDs": {},
"xdsl2LineStatusMrefPsdUs": {},
"xdsl2LineStatusPwrMngState": {},
"xdsl2LineStatusTrellisDs": {},
"xdsl2LineStatusTrellisUs": {},
"xdsl2LineStatusTssiDs": {},
"xdsl2LineStatusTssiUs": {},
"xdsl2LineStatusXtuTransSys": {},
"xdsl2LineStatusXtuc": {},
"xdsl2LineStatusXtur": {},
"xdsl2PMChCurr15MCodingViolations": {},
"xdsl2PMChCurr15MCorrectedBlocks": {},
"xdsl2PMChCurr15MInvalidIntervals": {},
"xdsl2PMChCurr15MTimeElapsed": {},
"xdsl2PMChCurr15MValidIntervals": {},
"xdsl2PMChCurr1DayCodingViolations": {},
"xdsl2PMChCurr1DayCorrectedBlocks": {},
"xdsl2PMChCurr1DayInvalidIntervals": {},
"xdsl2PMChCurr1DayTimeElapsed": {},
"xdsl2PMChCurr1DayValidIntervals": {},
"xdsl2PMChHist15MCodingViolations": {},
"xdsl2PMChHist15MCorrectedBlocks": {},
"xdsl2PMChHist15MMonitoredTime": {},
"xdsl2PMChHist15MValidInterval": {},
"xdsl2PMChHist1DCodingViolations": {},
"xdsl2PMChHist1DCorrectedBlocks": {},
"xdsl2PMChHist1DMonitoredTime": {},
"xdsl2PMChHist1DValidInterval": {},
"xdsl2PMLCurr15MEs": {},
"xdsl2PMLCurr15MFecs": {},
"xdsl2PMLCurr15MInvalidIntervals": {},
"xdsl2PMLCurr15MLoss": {},
"xdsl2PMLCurr15MSes": {},
"xdsl2PMLCurr15MTimeElapsed": {},
"xdsl2PMLCurr15MUas": {},
"xdsl2PMLCurr15MValidIntervals": {},
"xdsl2PMLCurr1DayEs": {},
"xdsl2PMLCurr1DayFecs": {},
"xdsl2PMLCurr1DayInvalidIntervals": {},
"xdsl2PMLCurr1DayLoss": {},
"xdsl2PMLCurr1DaySes": {},
"xdsl2PMLCurr1DayTimeElapsed": {},
"xdsl2PMLCurr1DayUas": {},
"xdsl2PMLCurr1DayValidIntervals": {},
"xdsl2PMLHist15MEs": {},
"xdsl2PMLHist15MFecs": {},
"xdsl2PMLHist15MLoss": {},
"xdsl2PMLHist15MMonitoredTime": {},
"xdsl2PMLHist15MSes": {},
"xdsl2PMLHist15MUas": {},
"xdsl2PMLHist15MValidInterval": {},
"xdsl2PMLHist1DEs": {},
"xdsl2PMLHist1DFecs": {},
"xdsl2PMLHist1DLoss": {},
"xdsl2PMLHist1DMonitoredTime": {},
"xdsl2PMLHist1DSes": {},
"xdsl2PMLHist1DUas": {},
"xdsl2PMLHist1DValidInterval": {},
"xdsl2PMLInitCurr15MFailedFullInits": {},
"xdsl2PMLInitCurr15MFailedShortInits": {},
"xdsl2PMLInitCurr15MFullInits": {},
"xdsl2PMLInitCurr15MInvalidIntervals": {},
"xdsl2PMLInitCurr15MShortInits": {},
"xdsl2PMLInitCurr15MTimeElapsed": {},
"xdsl2PMLInitCurr15MValidIntervals": {},
"xdsl2PMLInitCurr1DayFailedFullInits": {},
"xdsl2PMLInitCurr1DayFailedShortInits": {},
"xdsl2PMLInitCurr1DayFullInits": {},
"xdsl2PMLInitCurr1DayInvalidIntervals": {},
"xdsl2PMLInitCurr1DayShortInits": {},
"xdsl2PMLInitCurr1DayTimeElapsed": {},
"xdsl2PMLInitCurr1DayValidIntervals": {},
"xdsl2PMLInitHist15MFailedFullInits": {},
"xdsl2PMLInitHist15MFailedShortInits": {},
"xdsl2PMLInitHist15MFullInits": {},
"xdsl2PMLInitHist15MMonitoredTime": {},
"xdsl2PMLInitHist15MShortInits": {},
"xdsl2PMLInitHist15MValidInterval": {},
"xdsl2PMLInitHist1DFailedFullInits": {},
"xdsl2PMLInitHist1DFailedShortInits": {},
"xdsl2PMLInitHist1DFullInits": {},
"xdsl2PMLInitHist1DMonitoredTime": {},
"xdsl2PMLInitHist1DShortInits": {},
"xdsl2PMLInitHist1DValidInterval": {},
"xdsl2SCStatusAttainableRate": {},
"xdsl2SCStatusBandLnAtten": {},
"xdsl2SCStatusBandSigAtten": {},
"xdsl2SCStatusLinScGroupSize": {},
"xdsl2SCStatusLinScale": {},
"xdsl2SCStatusLogMt": {},
"xdsl2SCStatusLogScGroupSize": {},
"xdsl2SCStatusQlnMt": {},
"xdsl2SCStatusQlnScGroupSize": {},
"xdsl2SCStatusRowStatus": {},
"xdsl2SCStatusSegmentBitsAlloc": {},
"xdsl2SCStatusSegmentGainAlloc": {},
"xdsl2SCStatusSegmentLinImg": {},
"xdsl2SCStatusSegmentLinReal": {},
"xdsl2SCStatusSegmentLog": {},
"xdsl2SCStatusSegmentQln": {},
"xdsl2SCStatusSegmentSnr": {},
"xdsl2SCStatusSnrMtime": {},
"xdsl2SCStatusSnrScGroupSize": {},
"xdsl2ScalarSCAvailInterfaces": {},
"xdsl2ScalarSCMaxInterfaces": {},
"zipEntry": {"1": {}, "2": {}, "3": {}, "4": {}, "5": {}},
}
|
testing/resources/test_pmatrixprint.py
|
timgates42/processing.py
| 1,224 |
54798
|
<filename>testing/resources/test_pmatrixprint.py
a = PMatrix3D()
a.print()
exit()
|
object_detection/serving_script/predict.py
|
qq2016/kubeflow_learning
| 1,165 |
54821
|
""" Script to send prediction request.
Usage:
python predict.py --url=YOUR_KF_HOST/models/coco --input_image=YOUR_LOCAL_IMAGE
--output_image=OUTPUT_IMAGE_NAME.
This will save the prediction result as OUTPUT_IMAGE_NAME.
The output image is the input image with the detected bounding boxes.
"""
import argparse
import json
import requests
import numpy as np
from PIL import Image
import visualization_utils as vis_util
WIDTH = 1024
HEIGHT = 768
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--url", help='The url to send the request')
parser.add_argument("--input_image", default='image1.jpg')
parser.add_argument("--output_image", default='output.jpg')
args = parser.parse_args()
img = Image.open(args.input_image)
img = img.resize((WIDTH, HEIGHT), Image.ANTIALIAS)
img_np = np.array(img)
res = requests.post(
args.url,
data=json.dumps({"instances": [{"inputs": img_np.tolist()}]}))
if res.status_code != 200:
print('Failed: {}'.format(res.text))
return
output_dict = json.loads(res.text).get('predictions')[0]
vis_util.visualize_boxes_and_labels_on_image_array(
img_np,
np.array(output_dict['detection_boxes']),
map(int, output_dict['detection_classes']),
output_dict['detection_scores'],
{},
instance_masks=output_dict.get('detection_masks'),
use_normalized_coordinates=True,
line_thickness=8)
output_image = Image.fromarray(img_np)
output_image.save(args.output_image)
if __name__ == '__main__':
main()
|
src/third_party/swiftshader/third_party/subzero/pydir/gen_test_arith_ll.py
|
rhencke/engine
| 2,151 |
54879
|
<filename>src/third_party/swiftshader/third_party/subzero/pydir/gen_test_arith_ll.py
def mangle(op, op_type, signed):
# suffixMap gives the C++ name-mangling suffixes for a function that takes two
# arguments of the given type. The first entry is for the unsigned version of
# the type, and the second entry is for the signed version.
suffixMap = { 'i1': ['bb', 'bb'],
'i8': ['hh', 'aa'],
'i16': ['tt', 'ss'],
'i32': ['jj', 'ii'],
'i64': ['yy', 'xx'],
'float': ['ff', 'ff'],
'double': ['dd', 'dd'],
'<4 x i32>': ['Dv4_jS_', 'Dv4_iS_'],
'<8 x i16>': ['Dv8_tS_', 'Dv8_sS_'],
'<16 x i8>': ['Dv16_hS_', 'Dv16_aS_'],
'<4 x float>': ['Dv4_fS_', 'Dv4_fS_'],
}
base = 'test' + op.capitalize()
return '_Z' + str(len(base)) + base + suffixMap[op_type][signed]
def arith(Native, Type, Op):
_TEMPLATE_ = """
define internal {{native}} @{{name}}({{native}} %a, {{native}} %b) {{{{
{trunc_a}
{trunc_b}
%result{{trunc}} = {{op}} {{type}} %a{{trunc}}, %b{{trunc}}
{zext}
ret {{native}} %result
}}}}"""
Signed = Op in {'sdiv', 'srem', 'ashr'}
Name = mangle(Op, Type, Signed)
# Most i1 operations are invalid for PNaCl, so map them to i32.
if Type == 'i1' and (Op not in {'and', 'or', 'xor'}):
Type = 'i32'
x = _TEMPLATE_.format(
trunc_a = '%a.trunc = trunc {native} %a to {type}' if
Native != Type else '',
trunc_b = '%b.trunc = trunc {native} %b to {type}' if
Native != Type else '',
zext = '%result = ' + ('sext' if Signed else 'zext') +
' {type} %result.trunc to {native}' if Native != Type else '')
lines = x.format(native=Native, type=Type, op=Op, name=Name,
trunc='.trunc' if Native != Type else '')
# Strip trailing whitespace from each line to keep git happy.
print '\n'.join([line.rstrip() for line in lines.splitlines()])
for op in ['add', 'sub', 'mul', 'sdiv', 'udiv', 'srem', 'urem', 'shl', 'lshr',
'ashr', 'and', 'or', 'xor']:
for op_type in ['i1', 'i8', 'i16', 'i32']:
arith('i32', op_type, op)
for op_type in ['i64', '<4 x i32>', '<8 x i16>', '<16 x i8>']:
arith(op_type, op_type, op)
for op in ['fadd', 'fsub', 'fmul', 'fdiv', 'frem']:
for op_type in ['float', 'double', '<4 x float>']:
arith(op_type, op_type, op)
|
postprocess/cross_cpu_cluster_graph.py
|
Reinazhard/freqbench
| 121 |
54906
|
<gh_stars>100-1000
#!/usr/bin/env python3
import json
import csv
import sys
import matplotlib.pyplot as plt
CPU_LABELS = {
1: "Little",
4: "Big",
6: "Big",
7: "Prime"
}
COL_LABELS = {
"power_mean": "Power (mW)",
"coremark_score": "Performance (iter/s)",
"energy_joules": "Energy (J)",
"energy_millijoules": "Energy (mJ)",
"elapsed_sec": "Time (s)",
"coremarks_per_mhz": "CoreMarks/MHz",
"ulpmark_cm_score": "ULPMark-CM (iter/mJ)",
}
flags = set()
socs = {}
freq_load = "active"
col_name = None
for i, arg in enumerate(sys.argv[1:]):
if ":" in arg:
name, path = arg.split(":")
with open(path, "r") as f:
socs[name] = json.loads(f.read())
elif "+" in arg:
flag = arg[1:]
flags.add(flag)
elif "/" in arg:
freq_load, col_name = arg.split("/")
else:
col_name = arg
col_label = COL_LABELS[col_name] if col_name in COL_LABELS else col_name
plt.ylabel(col_label)
plt.xlabel("Frequency (MHz)")
plt.title(col_label)
for soc_i, (soc, soc_data) in enumerate(socs.items()):
cpus_data = soc_data["cpus"]
for cpu, cpu_data in cpus_data.items():
cpu = int(cpu)
freqs = [int(freq) / 1000 for freq in cpu_data["freqs"].keys()]
raw_values = [freq_data[freq_load][col_name] for freq_data in cpu_data["freqs"].values()]
values = []
for freq, freq_data in cpu_data["freqs"].items():
if "minscl" in flags:
curv = freq_data[freq_load][col_name]
minv = min(raw_values)
values.append(curv - minv)
else:
values.append(freq_data[freq_load][col_name])
cpu_label = CPU_LABELS[cpu] if cpu in CPU_LABELS else f"CPU {cpu}"
val_label = f"{soc} {cpu_label}"
color = f"C{soc_i}"
if "soccolor" in flags:
plt.plot(freqs, values, color, label=val_label)
else:
plt.plot(freqs, values, label=val_label)
plt.legend()
plt.show()
|
fabfile.py
|
fakegit/Lulu
| 922 |
54913
|
<filename>fabfile.py
# coding=utf-8
from fabric.api import (
local,
)
def test(proxy=False):
cmd = 'PYTHONPATH=./ {} coverage run tests/runtests.py'.format(
'proxychains4 -q' if proxy else ''
)
local(cmd)
def test_download(func):
'''
fab test_download:acfun
'''
cmd = (
'PYTHONPATH=./ python tests/test_extractors.py '
'TestExtractors.test_{}'.format(func)
)
local(cmd)
def upload():
local(
'python3 setup.py upload'
)
|
service/util/log.py
|
mutouxia/kamiFaka
| 717 |
54920
|
<reponame>mutouxia/kamiFaka
import time
# 定义日志记录器
# import sys
# def get_cur_info():
# return sys._getframe().f_code.co_filename + ' 第' + str(sys._getframe().f_lineno)+'行'
# 获取具体路径位置
# get_cur_info()
def log(msg):
with open('service.log','a',encoding='utf=8') as f:
f.write('\n' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) +' '+ str(msg))
|
facedancer/devices/keyboard.py
|
mrh1997/Facedancer
| 345 |
54937
|
<gh_stars>100-1000
# pylint: disable=unused-wildcard-import, wildcard-import
#
# This file is part of FaceDancer.
#
import asyncio
from typing import Iterable
from . import default_main
from ..future import *
from ..classes.hid.usage import *
from ..classes.hid.descriptor import *
from ..classes.hid.keyboard import *
# Specifies how many simultaneously keys we want to support.
KEY_ROLLOVER = 8
@use_inner_classes_automatically
class USBKeyboardDevice(USBDevice):
""" Simple USB keyboard device. """
name : str = "USB keyboard device"
product_string : str = "Non-suspicious Keyboard"
class KeyboardConfiguration(USBConfiguration):
""" Primary USB configuration: act as a keyboard. """
class KeyboardInterface(USBInterface):
""" Core HID interface for our keyboard. """
name : str = "USB keyboard interface"
class_number : int = 3
class KeyEventEndpoint(USBEndpoint):
number : int = 3
direction : USBDirection = USBDirection.IN
transfer_type : USBTransferType = USBTransferType.INTERRUPT
interval : int = 10
#
# Raw descriptors -- TODO: build these from their component parts.
#
class USBClassDescriptor(USBClassDescriptor):
number : int = USBDescriptorTypeNumber.HID
raw : bytes = b'\x09\x21\x10\x01\x00\x01\x22\x2b\x00'
class ReportDescriptor(HIDReportDescriptor):
fields : tuple = (
# Identify ourselves as a keyboard.
USAGE_PAGE (HIDUsagePage.GENERIC_DESKTOP),
USAGE (HIDGenericDesktopUsage.KEYBOARD),
COLLECTION (HIDCollection.APPLICATION),
USAGE_PAGE (HIDUsagePage.KEYBOARD),
# Modifier keys.
# These span the full range of modifier key codes (left control to right meta),
# and each has two possible values (0 = unpressed, 1 = pressed).
USAGE_MINIMUM (KeyboardKeys.LEFTCTRL),
USAGE_MAXIMUM (KeyboardKeys.RIGHTMETA),
LOGICAL_MINIMUM (0),
LOGICAL_MAXIMUM (1),
REPORT_SIZE (1),
REPORT_COUNT (KeyboardKeys.RIGHTMETA - KeyboardKeys.LEFTCTRL + 1),
INPUT (variable=True),
# One byte of constant zero-padding.
# This is required for compliance; and Windows will ignore this report
# if the zero byte isn't present.
REPORT_SIZE (8),
REPORT_COUNT (1),
INPUT (constant=True),
# Capture our actual, pressed keyboard keys.
# Support a standard, 101-key keyboard; which has
# keycodes from 0 (NONE) to 101 (COMPOSE).
#
# We provide the capability to press up to eight keys
# simultaneously. Setting the REPORT_COUNT effectively
# sets the key rollover; so 8 reports means we can have
# up to eight keys pressed at once.
USAGE_MINIMUM (KeyboardKeys.NONE),
USAGE_MAXIMUM (KeyboardKeys.COMPOSE),
LOGICAL_MINIMUM (KeyboardKeys.NONE),
LOGICAL_MAXIMUM (KeyboardKeys.COMPOSE),
REPORT_SIZE (8),
REPORT_COUNT (KEY_ROLLOVER),
INPUT (),
# End the report.
END_COLLECTION (),
)
@class_request_handler(number=USBStandardRequests.GET_INTERFACE)
@to_this_interface
def handle_get_interface_request(self, request):
# Silently stall GET_INTERFACE class requests.
request.stall()
def __post_init__(self):
super().__post_init__()
# Keep track of any pressed keys, and any pressed modifiers.
self.active_keys = set()
self.modifiers = 0
def _generate_hid_report(self) -> bytes:
""" Generates a single HID report for the given keyboard state. """
# If we have active keypresses, compose a set of scancodes from them.
scancodes = \
list(self.active_keys)[:KEY_ROLLOVER] + \
[0] * (KEY_ROLLOVER - len(self.active_keys))
return bytes([self.modifiers, 0, *scancodes])
def handle_data_requested(self, endpoint: USBEndpoint):
""" Provide data once per host request. """
report = self._generate_hid_report()
endpoint.send(report)
#
# User-facing API.
#
def key_down(self, code: KeyboardKeys):
""" Marks a given key as pressed; should be a scancode from KeyboardKeys. """
self.active_keys.add(code)
def key_up(self, code: KeyboardKeys):
""" Marks a given key as released; should be a scancode from KeyboardKeys. """
self.active_keys.remove(code)
def modifier_down(self, code: KeyboardModifiers):
""" Marks a given modifier as pressed; should be a flag from KeyboardModifiers. """
if code is not None:
self.modifiers |= code
def modifier_up(self, code: KeyboardModifiers):
""" Marks a given modifier as released; should be a flag from KeyboardModifiers. """
if code is not None:
self.modifiers &= ~code
async def type_scancode(self, code: KeyboardKeys, duration: float = 0.1, modifiers: KeyboardModifiers = None):
""" Presses, and then releases, a single key.
Parameters:
code -- The keyboard key to be pressed's scancode.
duration -- How long the given key should be pressed, in seconds.
modifiers -- Any modifier keys that should be held while typing.
"""
self.modifier_down(modifiers)
self.key_down(code)
await asyncio.sleep(duration)
self.key_up(code)
self.modifier_up(modifiers)
async def type_scancodes(self, *codes: Iterable[KeyboardKeys], duration: float = 0.1):
""" Presses, and then releases, a collection of keys, in order.
Parameters:
*code -- The keyboard keys to be pressed's scancodes.
duration -- How long each key should be pressed, in seconds.
"""
for code in codes:
await self.type_scancode(code, duration=duration)
async def type_letter(self, letter: str, duration: float = 0.1, modifiers: KeyboardModifiers = None):
""" Attempts to type a single letter, based on its ASCII string representation.
Parameters:
letter -- A single-character string literal, to be typed.
duration -- How long each key should be pressed, in seconds.
modifiers -- Any modifier keys that should be held while typing.
"""
shift, code = KeyboardKeys.get_scancode_for_ascii(letter)
modifiers = shift if modifiers is None else modifiers | shift
await self.type_scancode(code, modifiers=modifiers, duration=duration)
async def type_letters(self, *letters: Iterable[str], duration:float = 0.1):
""" Attempts to type a string of letters, based on ASCII string representations.
Parameters:
*letters -- A collection of single-character string literal, to be typed in order.
duration -- How long each key should be pressed, in seconds.
"""
for letter in letters:
await self.type_letter(letter, duration=duration)
async def type_string(self, to_type: str, *, duration:float = 0.1, modifiers: KeyboardModifiers = None):
""" Attempts to type a python string into the remote host.
Parameters:
letter -- A collection of single-character string literal, to be typed in order.
duration -- How long each key should be pressed, in seconds.
modifiers -- Any modifier keys that should be held while typing.
"""
self.modifier_down(modifiers)
for letter in to_type:
await self.type_letter(letter, duration=duration)
self.modifier_up(modifiers)
def all_keys_up(self, *, include_modifiers: bool = True):
""" Releases all keys currently pressed.
Parameters:
include_modifiers -- If set to false, modifiers will be left at their current states.
"""
self.active_keys.clear()
if include_modifiers:
self.all_modifiers_up()
def all_modifiers_up(self):
""" Releases all modifiers currently held. """
self.modifiers = 0
if __name__ == "__main__":
default_main(USBKeyboardDevice)
|
lib/datasets/wider/convert_face_to_coco.py
|
AruniRC/detectron-self-train
| 128 |
54939
|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import argparse
import h5py
import json
import os
import scipy.misc
import sys
import re
import fnmatch
import datetime
from PIL import Image
import numpy as np
'''
srun --mem 10000 python lib/datasets/wider/convert_face_to_coco.py --dataset cs6-train-det
'''
def add_path(path):
if path not in sys.path:
sys.path.insert(0, path)
this_dir = os.path.dirname(__file__)
add_path(this_dir)
# print(this_dir)
add_path(os.path.join(this_dir, '..', '..'))
import utils
import utils.boxes as bboxs_util
import utils.face_utils as face_util
def parse_args():
parser = argparse.ArgumentParser(description='Convert dataset')
parser.add_argument(
'--dataset', help="wider", default='wider', type=str)
parser.add_argument(
'--outdir', help="output dir for json files",
default='', type=str)
parser.add_argument(
'--datadir', help="data dir for annotations to be converted",
default='', type=str)
parser.add_argument(
'--imdir', help="root directory for loading dataset images",
default='', type=str)
parser.add_argument(
'--annotfile', help="directly specify the annotations file",
default='', type=str)
parser.add_argument(
'--thresh', help="specify the confidence threshold on detections",
default=-1, type=float)
# if len(sys.argv) == 1:
# parser.print_help()
# sys.exit(1)
return parser.parse_args()
def convert_wider_annots(data_dir, out_dir, data_set='WIDER', conf_thresh=0.5):
"""Convert from WIDER FDDB-style format to COCO bounding box"""
# http://cocodataset.org/#format-data: [x,w,width,height]
json_name = 'wider_face_train_annot_coco_style.json'
img_id = 0
ann_id = 0
cat_id = 1
print('Starting %s' % data_set)
ann_dict = {}
categories = [{"id": 1, "name": 'face'}]
images = []
annotations = []
ann_file = os.path.join(data_dir, 'wider_face_train_annot.txt')
wider_annot_dict = face_util.parse_wider_gt(ann_file) # [im-file] = [[x,y,w,h], ...]
for filename in wider_annot_dict.keys():
if len(images) % 50 == 0:
print("Processed %s images, %s annotations" % (
len(images), len(annotations)))
image = {}
image['id'] = img_id
img_id += 1
im = Image.open(os.path.join(data_dir, filename))
image['width'] = im.height
image['height'] = im.width
image['file_name'] = filename
images.append(image)
for gt_bbox in wider_annot_dict[filename]:
ann = {}
ann['id'] = ann_id
ann_id += 1
ann['image_id'] = image['id']
ann['segmentation'] = []
ann['category_id'] = cat_id # 1:"face" for WIDER
ann['iscrowd'] = 0
ann['area'] = gt_bbox[2] * gt_bbox[3]
ann['bbox'] = gt_bbox
annotations.append(ann)
ann_dict['images'] = images
ann_dict['categories'] = categories
ann_dict['annotations'] = annotations
print("Num categories: %s" % len(categories))
print("Num images: %s" % len(images))
print("Num annotations: %s" % len(annotations))
with open(os.path.join(out_dir, json_name), 'w', encoding='utf8') as outfile:
outfile.write(json.dumps(ann_dict))
def convert_cs6_annots(ann_file, im_dir, out_dir, data_set='CS6-subset', conf_thresh=0.5):
"""Convert from WIDER FDDB-style format to COCO bounding box"""
# cs6 subsets
if data_set=='CS6-subset':
json_name = 'cs6-subset_face_train_annot_coco_style.json'
elif data_set=='CS6-subset-score':
# include "scores" as soft-labels
json_name = 'cs6-subset_face_train_score-annot_coco_style.json'
elif data_set=='CS6-subset-gt':
json_name = 'cs6-subset-gt_face_train_annot_coco_style.json'
elif data_set=='CS6-train-gt':
# full train set of CS6 (86 videos)
json_name = 'cs6-train-gt.json'
elif data_set=='CS6-train-det-score':
# soft-labels used in distillation
json_name = 'cs6-train-det-score_face_train_annot_coco_style.json'
elif data_set=='CS6-train-det-score-0.5':
# soft-labels used in distillation, keeping dets with score > 0.5
json_name = 'cs6-train-det-score-0.5_face_train_annot_coco_style.json'
conf_thresh = 0.5
elif data_set=='CS6-train-det':
json_name = 'cs6-train-det_face_train_annot_coco_style.json'
elif data_set=='CS6-train-det-0.5':
json_name = 'cs6-train-det-0.5_face_train_annot_coco_style.json'
elif data_set=='CS6-train-easy-hp':
json_name = 'cs6-train-easy-hp.json'
elif data_set=='CS6-train-easy-gt':
json_name = 'cs6-train-easy-gt.json'
elif data_set=='CS6-train-easy-det':
json_name = 'cs6-train-easy-det.json'
elif data_set=='CS6-train-hp':
json_name = 'cs6-train-hp.json'
else:
raise NotImplementedError
img_id = 0
ann_id = 0
cat_id = 1
print('Starting %s' % data_set)
ann_dict = {}
categories = [{"id": 1, "name": 'face'}]
images = []
annotations = []
wider_annot_dict = face_util.parse_wider_gt(ann_file) # [im-file] = [[x,y,w,h], ...]
for filename in wider_annot_dict.keys():
if len(images) % 50 == 0:
print("Processed %s images, %s annotations" % (
len(images), len(annotations)))
if 'score' in data_set:
dets = np.array(wider_annot_dict[filename])
if not any(dets[:,4] > conf_thresh):
continue
image = {}
image['id'] = img_id
img_id += 1
im = Image.open(os.path.join(im_dir, filename))
image['width'] = im.height
image['height'] = im.width
image['file_name'] = filename
images.append(image)
for gt_bbox in wider_annot_dict[filename]:
ann = {}
ann['id'] = ann_id
ann_id += 1
ann['image_id'] = image['id']
ann['segmentation'] = []
ann['category_id'] = cat_id # 1:"face" for WIDER
ann['iscrowd'] = 0
ann['area'] = gt_bbox[2] * gt_bbox[3]
ann['bbox'] = gt_bbox[:4]
ann['dataset'] = data_set
score = gt_bbox[4]
if score < conf_thresh:
continue
if 'hp' in data_set:
ann['score'] = score # for soft-label distillation
ann['source'] = gt_bbox[5] # annot source: {1: detection, 2:tracker}
if data_set=='CS6-train-easy-det':
if gt_bbox[5] != 1:
continue # ignore if annot source is not detection (i.e. skip HP)
annotations.append(ann)
ann_dict['images'] = images
ann_dict['categories'] = categories
ann_dict['annotations'] = annotations
print("Num categories: %s" % len(categories))
print("Num images: %s" % len(images))
print("Num annotations: %s" % len(annotations))
with open(os.path.join(out_dir, json_name), 'w', encoding='utf8') as outfile:
outfile.write(json.dumps(ann_dict, indent=2))
if __name__ == '__main__':
args = parse_args()
if args.dataset == "wider":
convert_wider_annots(args.datadir, args.outdir)
# --------------------------------------------------------------------------
# CS6 Train GT
# --------------------------------------------------------------------------
elif args.dataset == "cs6-subset":
convert_cs6_annots(args.annotfile, args.imdir,
args.outdir, data_set='CS6-subset')
elif args.dataset == "cs6-subset-score":
convert_cs6_annots(args.annotfile, args.imdir,
args.outdir, data_set='CS6-subset-score')
elif args.dataset == "cs6-subset-gt":
convert_cs6_annots(args.annotfile, args.imdir,
args.outdir, data_set='CS6-subset-gt')
elif args.dataset == "cs6-train-gt":
# set defaults if inputs args are empty
if not args.annotfile:
args.annotfile = 'data/CS6_annot/annot-format-GT/cs6_gt_annot_train.txt'
if not args.imdir:
args.imdir = 'data/CS6_annot'
if not args.outdir:
args.outdir = 'data/CS6_annot'
convert_cs6_annots(args.annotfile, args.imdir,
args.outdir, data_set='CS6-train-gt')
# Distillation scores for CS6-Train detections (conf 0.25)
elif args.dataset == "cs6-train-det-score":
# set defaults if inputs args are empty
if not args.annotfile:
args.annotfile = 'data/CS6_annot/annot-format-GT/cs6_det_annot_train_scores.txt'
# --------------------------------------------------------------------------
# CS6 Train unlabeled
# --------------------------------------------------------------------------
# Pseudo-labels from CS6-Train
elif args.dataset == "cs6-train-det":
# set defaults if inputs args are empty
if not args.annotfile:
args.annotfile = 'data/CS6_annot/annot-format-GT/cs6_det_annot_train_conf-0.25.txt'
if not args.imdir:
args.imdir = 'data/CS6_annot'
if not args.outdir:
args.outdir = 'data/CS6_annot'
convert_cs6_annots(args.annotfile, args.imdir,
args.outdir, data_set='CS6-train-det')
elif args.dataset == "cs6-train-det-0.5":
# set defaults if inputs args are empty
if not args.annotfile:
args.annotfile = 'data/CS6_annot/annot-format-GT/cs6_det_annot_train_conf-0.50.txt'
if not args.imdir:
args.imdir = 'data/CS6_annot'
if not args.outdir:
args.outdir = 'data/CS6_annot'
convert_cs6_annots(args.annotfile, args.imdir,
args.outdir, data_set='CS6-train-det-0.5')
# Hard positives from CS6-Train
elif args.dataset == "cs6-train-hp":
# set defaults if inputs args are empty
if not args.annotfile:
args.annotfile = 'Outputs/tracklets/hp-res-cs6/hp_cs6_train.txt'
if not args.imdir:
args.imdir = 'data/CS6_annot'
if not args.outdir:
args.outdir = 'data/CS6_annot'
convert_cs6_annots(args.annotfile, args.imdir,
args.outdir, data_set='CS6-train-hp', conf_thresh=0.5)
# --------------------------------------------------------------------------
# CS6 "EASY" set
# --------------------------------------------------------------------------
elif args.dataset == "cs6-train-easy-hp":
# set defaults if inputs args are empty
if not args.annotfile:
args.annotfile = 'Outputs/tracklets/hp-res-cs6/hp_cs6_easy.txt'
if not args.imdir:
args.imdir = 'data/CS6_annot'
if not args.outdir:
args.outdir = 'data/CS6_annot'
convert_cs6_annots(args.annotfile, args.imdir,
args.outdir, data_set='CS6-train-easy-hp')
elif args.dataset == "cs6-train-easy-gt":
# set defaults if inputs args are empty
if not args.annotfile:
args.annotfile = 'data/CS6_annot/annot-format-GT/cs6_gt_annot_train-easy.txt'
if not args.imdir:
args.imdir = 'data/CS6_annot'
if not args.outdir:
args.outdir = 'data/CS6_annot'
convert_cs6_annots(args.annotfile, args.imdir,
args.outdir, data_set='CS6-train-easy-gt')
elif args.dataset == "cs6-train-easy-det":
# set defaults if inputs args are empty
if not args.annotfile:
args.annotfile = 'Outputs/tracklets/hp-res-cs6/hp_cs6_train_easy.txt'
if not args.imdir:
args.imdir = 'data/CS6_annot'
if not args.outdir:
args.outdir = 'data/CS6_annot'
convert_cs6_annots(args.annotfile, args.imdir,
args.outdir, data_set='CS6-train-easy-det')
else:
print("Dataset not supported: %s" % args.dataset)
|
sched/adaptdl_sched/supervisor.py
|
jessezbj/adaptdl
| 294 |
55002
|
# Copyright 2020 Petuum, Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT 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 kubernetes_asyncio as kubernetes
from aiohttp import web
import logging
from adaptdl.sched_hints import SCHED_HINTS
from adaptdl_sched.config import get_supervisor_port
LOG = logging.getLogger(__name__)
LOG.setLevel(logging.INFO)
class Supervisor:
"""
Supervisor provides a simple REST interface for several functionalities.
Currently, it has two endpoints:
1. /hints for jobs to send scheduling hints.
2. /discover for finding the pod IPs of a job.
"""
def __init__(self, port, host='0.0.0.0'):
self._host = host
self._port = port
self._core_api = kubernetes.client.CoreV1Api()
self._objs_api = kubernetes.client.CustomObjectsApi()
async def _handle_healthz(self, request):
# Health check.
return web.Response()
async def _handle_discover(self, request):
# Long-polling endpoint used for discovering pod IPs for a given job.
namespace = request.match_info["namespace"]
name = request.match_info["name"]
group = request.match_info["group"]
timeout = int(request.query.get("timeout", "30"))
pod_ip_list = None
async with kubernetes.watch.Watch() as w:
stream = w.stream(self._core_api.list_namespaced_pod, namespace,
label_selector="adaptdl/job={}".format(name),
field_selector="status.podIP!=",
timeout_seconds=timeout)
async for event in stream:
pod = event["object"]
replicas = int(pod.metadata.annotations["adaptdl/replicas"])
rank = int(pod.metadata.annotations["adaptdl/rank"])
if pod.metadata.annotations["adaptdl/group"] == group:
if pod_ip_list is None:
pod_ip_list = [None] * replicas
pod_ip_list[rank] = pod.status.pod_ip
if all(pod_ip is not None for pod_ip in pod_ip_list):
return web.json_response(pod_ip_list)
return web.json_response(status=408) # Timeout.
async def _handle_report(self, request):
namespace = request.match_info['namespace']
name = request.match_info['name']
hints = await request.json()
# Drop all unrecognized fields. TODO: validate each client-sent field.
hints = {k: hints[k] for k in SCHED_HINTS if k in hints}
# Patch only the train field to avoid conflicts with controller.
patch = {"status": {"train": hints}}
LOG.info("Patch AdaptDLJob %s/%s: %s", namespace, name, patch)
await self._objs_api.patch_namespaced_custom_object_status(
"adaptdl.petuum.com", "v1", namespace, "adaptdljobs", name, patch)
return web.Response()
def run(self):
self.app = web.Application()
self.app.add_routes([
web.get('/healthz', self._handle_healthz),
web.get('/discover/{namespace}/{name}/{group}',
self._handle_discover),
web.put('/hints/{namespace}/{name}', self._handle_report),
])
LOG.info("%s %s", self._host, self._port)
web.run_app(self.app, host=self._host, port=self._port)
if __name__ == "__main__":
logging.basicConfig()
kubernetes.config.load_incluster_config()
supervisor = Supervisor(get_supervisor_port())
supervisor.run()
|
cvxpy/utilities/eigvals.py
|
QiuWJX/cvxpy
| 556 |
55013
|
<filename>cvxpy/utilities/eigvals.py
import numpy as np
import scipy.sparse as spar
import scipy.sparse.linalg as sparla
def is_psd_within_tol(A, tol):
"""
Return True if we can certify that A is PSD (up to tolerance "tol").
First we check if A is PSD according to the Gershgorin Circle Theorem.
If Gershgorin is inconclusive, then we use an iterative method (from ARPACK,
as called through SciPy) to estimate extremal eigenvalues of certain shifted
versions of A. The shifts are chosen so that the signs of those eigenvalues
tell us the signs of the eigenvalues of A.
If there are numerical issues then it's possible that this function returns
False even when A is PSD. If you know that you're in that situation, then
you should replace A by
A = cvxpy.atoms.affine.wraps.psd_wrap(A).
Parameters
----------
A : Union[np.ndarray, spar.spmatrx]
Symmetric (or Hermitian) NumPy ndarray or SciPy sparse matrix.
tol : float
Nonnegative. Something very small, like 1e-10.
"""
if gershgorin_psd_check(A, tol):
return True
def SA_eigsh(sigma):
return sparla.eigsh(A, k=1, sigma=sigma, which='SA', return_eigenvectors=False)
# Returns the eigenvalue w[i] of A where 1/(w[i] - sigma) is minimized.
#
# If A - sigma*I is PSD, then w[i] should be equal to the largest
# eigenvalue of A.
#
# If A - sigma*I is not PSD, then w[i] should be the largest eigenvalue
# of A where w[i] - sigma < 0.
#
# We should only call this function with sigma < 0. In this case, if
# A - sigma*I is not PSD then A is not PSD, and w[i] < -abs(sigma) is
# a negative eigenvalue of A. If A - sigma*I is PSD, then we obviously
# have that the smallest eigenvalue of A is >= sigma.
ev = np.NaN
try:
ev = SA_eigsh(-tol) # might return np.NaN, or raise exception
finally:
if np.isnan(ev).all():
# will be NaN if A has an eigenvalue which is exactly -tol
# (We might also hit this code block for other reasons.)
temp = tol - np.finfo(A.dtype).eps
ev = SA_eigsh(-temp)
return np.all(ev >= -tol)
def gershgorin_psd_check(A, tol):
"""
Use the Gershgorin Circle Theorem
https://en.wikipedia.org/wiki/Gershgorin_circle_theorem
As a sufficient condition for A being PSD with tolerance "tol".
The computational complexity of this function is O(nnz(A)).
Parameters
----------
A : Union[np.ndarray, spar.spmatrx]
Symmetric (or Hermitian) NumPy ndarray or SciPy sparse matrix.
tol : float
Nonnegative. Something very small, like 1e-10.
Returns
-------
True if A is PSD according to the Gershgorin Circle Theorem.
Otherwise, return False.
"""
if isinstance(A, spar.spmatrix):
diag = A.diagonal()
if np.any(diag < -tol):
return False
A_shift = A - spar.diags(diag)
A_shift = np.abs(A_shift)
radii = np.array(A_shift.sum(axis=0)).ravel()
return np.all(diag - radii >= -tol)
elif isinstance(A, np.ndarray):
diag = np.diag(A)
if np.any(diag < -tol):
return False
A_shift = A - np.diag(diag)
A_shift = np.abs(A_shift)
radii = A_shift.sum(axis=0)
return np.all(diag - radii >= -tol)
else:
raise ValueError()
|
jsuarez/extra/embyr_deprecated/embyr/tests/loaders/test_objloader.py
|
jarbus/neural-mmo
| 1,450 |
55025
|
import unittest
from kivy3.loaders import OBJLoader
class OBJLoaderTest(unittest.TestCase):
pass
if __name__ == '__main__':
unittest.main()
|
AutotestWebD/apps/myadmin/service/TeamPermissionRelationService.py
|
yangjourney/sosotest
| 422 |
55061
|
<filename>AutotestWebD/apps/myadmin/service/TeamPermissionRelationService.py
from all_models.models import TbAdminTeamPermissionRelation
class TeamPermissionRelationService(object):
@staticmethod
def updateTeamPermission(teamPermissionData):
tbModel = TbAdminTeamPermissionRelation.objects.filter(id=teamPermissionData["id"])
tbModel.update(**teamPermissionData)
|
vedadet/criteria/losses/builder.py
|
jie311/vedadet
| 424 |
55110
|
from vedacore.misc import build_from_cfg, registry
def build_loss(cfg):
return build_from_cfg(cfg, registry, 'loss')
|
cli/tests/commands/job/test_run.py
|
gaybro8777/klio
| 705 |
55187
|
<filename>cli/tests/commands/job/test_run.py
# Copyright 2019-2020 Spotify AB
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT 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 pytest
from klio_core import config
from klio_cli import __version__ as klio_cli_version
from klio_cli import cli
from klio_cli.commands.job import run as run_job
@pytest.fixture
def mock_os_environ(mocker):
return mocker.patch.dict(
run_job.base.os.environ, {"USER": "cookiemonster"}
)
@pytest.fixture
def klio_config():
conf = {
"job_name": "test-job",
"version": 1,
"pipeline_options": {
"worker_harness_container_image": "test-image",
"region": "some-region",
"project": "test-project",
},
"job_config": {
"inputs": [
{
"topic": "foo-topic",
"subscription": "foo-sub",
"data_location": "foo-input-location",
}
],
"outputs": [
{
"topic": "foo-topic-output",
"data_location": "foo-output-location",
}
],
},
}
return config.KlioConfig(conf)
@pytest.fixture
def docker_runtime_config():
return cli.DockerRuntimeConfig(
image_tag="foo-123",
force_build=False,
config_file_override="klio-job2.yaml",
)
@pytest.fixture
def run_job_config():
return cli.RunJobConfig(
direct_runner=False, update=False, git_sha="12345678"
)
@pytest.fixture
def mock_docker_client(mocker):
mock_client = mocker.Mock()
mock_container = mocker.Mock()
mock_container.wait.return_value = {"StatusCode": 0}
mock_container.logs.return_value = [b"a log line\n", b"another log line\n"]
mock_client.containers.run.return_value = mock_container
return mock_client
@pytest.fixture
def run_pipeline(
klio_config,
docker_runtime_config,
run_job_config,
mock_docker_client,
mock_os_environ,
monkeypatch,
):
job_dir = "/test/dir/jobs/test_run_job"
pipeline = run_job.RunPipeline(
job_dir=job_dir,
klio_config=klio_config,
docker_runtime_config=docker_runtime_config,
run_job_config=run_job_config,
)
monkeypatch.setattr(pipeline, "_docker_client", mock_docker_client)
return pipeline
@pytest.mark.parametrize(
"direct_runner,db_url",
((True, None), (False, "https://foo"), (False, None)),
)
def test_run_docker_container(
direct_runner,
db_url,
run_pipeline,
run_job_config,
caplog,
mocker,
monkeypatch,
):
run_job_config = run_job_config._replace(direct_runner=direct_runner)
monkeypatch.setattr(run_pipeline, "run_job_config", run_job_config)
mock_sd_utils = mocker.Mock()
mock_sd_utils.get_stackdriver_group_url.return_value = db_url
monkeypatch.setattr(run_job, "sd_utils", mock_sd_utils)
runflags = {"a": "flag"}
run_pipeline._run_docker_container(runflags)
run_pipeline._docker_client.containers.run.assert_called_once_with(
**runflags
)
ret_container = run_pipeline._docker_client.containers.run.return_value
ret_container.logs.assert_called_once_with(stream=True)
if not direct_runner:
mock_sd_utils.get_stackdriver_group_url.assert_called_once_with(
"test-project", "test-job", "some-region"
)
assert 1 == len(caplog.records)
else:
mock_sd_utils.get_stackdriver_group_url.assert_not_called()
assert not len(caplog.records)
def test_failure_in_docker_container_returns_nonzero(
run_pipeline, run_job_config, caplog, mocker, monkeypatch,
):
mock_sd_utils = mocker.Mock()
monkeypatch.setattr(run_job, "sd_utils", mock_sd_utils)
container_run = run_pipeline._docker_client.containers.run
container_run.return_value.wait.return_value = {"StatusCode": 1}
runflags = {"a": "flag"}
assert run_pipeline._run_docker_container(runflags) == 1
container_run.assert_called_once_with(**runflags)
ret_container = run_pipeline._docker_client.containers.run.return_value
ret_container.logs.assert_called_once_with(stream=True)
mock_sd_utils.get_stackdriver_group_url.assert_not_called()
def test_run_docker_container_dashboard_raises(
run_pipeline, caplog, mocker, monkeypatch
):
mock_sd_utils = mocker.Mock()
mock_sd_utils.get_stackdriver_group_url.side_effect = Exception("fuu")
monkeypatch.setattr(run_job, "sd_utils", mock_sd_utils)
runflags = {"a": "flag"}
run_pipeline._run_docker_container(runflags)
run_pipeline._docker_client.containers.run.assert_called_once_with(
**runflags
)
ret_container = run_pipeline._docker_client.containers.run.return_value
ret_container.logs.assert_called_once_with(stream=True)
mock_sd_utils.get_stackdriver_group_url.assert_called_once_with(
"test-project", "test-job", "some-region"
)
assert 1 == len(caplog.records)
def test_get_environment(run_pipeline):
gcreds = "/usr/gcloud/application_default_credentials.json"
exp_envs = {
"PYTHONPATH": "/usr/src/app",
"GOOGLE_APPLICATION_CREDENTIALS": gcreds,
"USER": "cookiemonster",
"GOOGLE_CLOUD_PROJECT": "test-project",
"COMMIT_SHA": "12345678",
"KLIO_CLI_VERSION": klio_cli_version,
}
assert exp_envs == run_pipeline._get_environment()
@pytest.mark.parametrize(
"config_file", (None, "klio-job2.yaml"),
)
@pytest.mark.parametrize(
"image_tag,exp_image_flags",
((None, []), ("foo-123", ["--image-tag", "foo-123"])),
)
@pytest.mark.parametrize(
"update,exp_update_flag",
((True, ["--update"]), (False, ["--no-update"]), (None, [])),
)
@pytest.mark.parametrize(
"direct_runner,exp_runner_flag", ((False, []), (True, ["--direct-runner"]))
)
def test_get_command(
direct_runner,
exp_runner_flag,
update,
exp_update_flag,
image_tag,
exp_image_flags,
config_file,
run_pipeline,
monkeypatch,
):
run_job_config = run_pipeline.run_job_config._replace(
direct_runner=direct_runner, update=update
)
monkeypatch.setattr(run_pipeline, "run_job_config", run_job_config)
runtime_config = run_pipeline.docker_runtime_config._replace(
image_tag=image_tag, config_file_override=config_file
)
monkeypatch.setattr(run_pipeline, "docker_runtime_config", runtime_config)
exp_command = ["run"]
exp_command.extend(exp_update_flag)
exp_command.extend(exp_runner_flag)
exp_command.extend(exp_image_flags)
assert sorted(exp_command) == sorted(run_pipeline._get_command())
@pytest.mark.parametrize("direct_runner", (True, False))
def test_setup_docker_image(
direct_runner, run_pipeline, mock_docker_client, mocker, monkeypatch
):
run_job_config = run_pipeline.run_job_config._replace(
direct_runner=direct_runner
)
monkeypatch.setattr(run_pipeline, "run_job_config", run_job_config)
mock_super = mocker.Mock()
monkeypatch.setattr(
run_job.base.BaseDockerizedPipeline, "_setup_docker_image", mock_super
)
mock_docker_utils = mocker.Mock()
monkeypatch.setattr(run_job, "docker_utils", mock_docker_utils)
run_pipeline._setup_docker_image()
mock_super.assert_called_once_with()
if not direct_runner:
mock_docker_utils.push_image_to_gcr.assert_called_once_with(
"test-image:foo-123", "foo-123", mock_docker_client,
)
else:
mock_docker_utils.push_image_to_gcr.assert_not_called()
|
python/example_code/pinpoint-email/test/test_pinpoint_send_email_message_email_api.py
|
iconara/aws-doc-sdk-examples
| 5,166 |
55211
|
<reponame>iconara/aws-doc-sdk-examples<filename>python/example_code/pinpoint-email/test/test_pinpoint_send_email_message_email_api.py<gh_stars>1000+
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Unit tests for pinpoint_send_email_message_email_api.py.
"""
import boto3
from botocore.exceptions import ClientError
import pytest
import pinpoint_send_email_message_email_api as api
@pytest.mark.parametrize('error_code', [None, 'TestException'])
def test_send_email_message(make_stubber, error_code):
pinpoint_email_client = boto3.client('pinpoint-email')
pinpoint_email_stubber = make_stubber(pinpoint_email_client)
sender = 'test-sender'
to_addresses = ['test-to']
cc_addresses = ['test-cc']
char_set = 'test-charset'
subject = 'test-subject'
html_message = '<p>test html</p>'
text_message = 'test-message'
message_id = 'test-id'
pinpoint_email_stubber.stub_send_email(
sender, to_addresses, cc_addresses, char_set, subject, html_message,
text_message, message_id, error_code=error_code)
if error_code is None:
got_message_id = api.send_email_message(
pinpoint_email_client, sender, to_addresses, cc_addresses, char_set,
subject, html_message, text_message)
assert got_message_id == message_id
else:
with pytest.raises(ClientError) as exc_info:
api.send_email_message(
pinpoint_email_client, sender, to_addresses, cc_addresses, char_set,
subject, html_message, text_message)
assert exc_info.value.response['Error']['Code'] == error_code
|
data_preparation/make_vad_inputs.py
|
dweekly/libri-light
| 246 |
55225
|
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
import os
from pathlib import Path
import torchaudio
import progressbar
import argparse
import torch
import tqdm
def findAllSeqs(dirName,
extension='.flac',
loadCache=False):
r"""
Lists all the sequences with the given extension in the dirName directory.
Output:
outSequences, speakers
outSequence
A list of tuples seq_path, speaker where:
- seq_path is the relative path of each sequence relative to the
parent directory
- speaker is the corresponding speaker index
outSpeakers
The speaker labels (in order)
The speaker labels are organized the following way
\dirName
\speaker_label
\..
...
seqName.extension
"""
cache_path = os.path.join(dirName, '_seqs_cache.txt')
if loadCache:
try:
outSequences, speakers = torch.load(cache_path)
print(f'Loaded from cache {cache_path} successfully')
return outSequences, speakers
except OSError as err:
print(f'Ran in an error while loading {cache_path}: {err}')
print('Could not load cache, rebuilding')
if dirName[-1] != os.sep:
dirName += os.sep
prefixSize = len(dirName)
speakersTarget = {}
outSequences = []
for root, dirs, filenames in tqdm.tqdm(os.walk(dirName)):
filtered_files = [f for f in filenames if f.endswith(extension)]
if len(filtered_files) > 0:
speakerStr = root[prefixSize:].split(os.sep)[0]
if speakerStr not in speakersTarget:
speakersTarget[speakerStr] = len(speakersTarget)
speaker = speakersTarget[speakerStr]
for filename in filtered_files:
full_path = os.path.join(root[prefixSize:], filename)
outSequences.append((speaker, full_path))
outSpeakers = [None for x in speakersTarget]
for key, index in speakersTarget.items():
outSpeakers[index] = key
try:
torch.save((outSequences, outSpeakers), cache_path)
print(f'Saved cache file at {cache_path}')
except OSError as err:
print(f'Ran in an error while saving {cache_path}: {err}')
return outSequences, outSpeakers
def get_file_duration_ms(path_file):
info = torchaudio.info(path_file)[0]
return 1000*(info.length // (info.rate))
def get_lst(path_db, file_list):
bar = progressbar.ProgressBar(maxval=len(file_list))
bar.start()
path_db = Path(path_db)
out = []
for index, file_name in enumerate(file_list):
bar.update(index)
full_path = str(path_db / file_name)
duration = get_file_duration_ms(full_path)
out.append((full_path, full_path, int(duration)))
bar.finish()
return out
def save_lst(data, path_out):
with open(path_out, 'w') as file:
for id, path, val in data:
file.write(' '.join((id, path, str(val))) + '\n')
def reorder_vad(path_vad, lst):
path_vad = Path(path_vad)
for id, full_path_wav, _ in lst:
full_path_vad = (path_vad / id).with_suffix('.vad')
full_path_out = Path(full_path_wav).with_suffix('.vad')
full_path_vad.replace(full_path_out)
full_path_vad.with_suffix('.fwt').unlink(missing_ok=True)
full_path_vad.with_suffix('.tsc').unlink(missing_ok=True)
full_path_vad.with_suffix('.sts').unlink(missing_ok=True)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Build the vad inputs")
parser.add_argument('path_db', type=str,
help="Path to the dataset directory")
parser.add_argument('path_out', type=str)
parser.add_argument('--ignore_cache', action='store_true')
parser.add_argument('--debug', action='store_true')
parser.add_argument('--extension', type=str, default='.wav')
args = parser.parse_args()
seqList, _ = findAllSeqs(args.path_db, extension=args.extension,
loadCache=not args.ignore_cache)
if args.debug:
seqList = seqList[:10]
seqList = [i[1] for i in seqList]
vad_data = get_lst(args.path_db, seqList)
save_lst(vad_data, args.path_out)
|
homeassistant/components/kef/__init__.py
|
domwillcode/home-assistant
| 30,023 |
55237
|
<gh_stars>1000+
"""The KEF Wireless Speakers component."""
|
VA/main/config.py
|
YuJaceKim/Activity-Recognition-with-Combination-of-Deeply-Learned-Visual-Attention-and-Pose-Estimation
| 343 |
55252
|
<filename>VA/main/config.py
import numpy as np
import keras.backend as K
K.set_image_data_format('channels_last')
class DataConfig(object):
"""Input frame configuration and data augmentation setup."""
def __init__(self, crop_resolution=(256, 256), image_channels=(3,),
angles=[0], fixed_angle=0,
scales=[1], fixed_scale=1,
trans_x=[0], fixed_trans_x=0,
trans_y=[0], fixed_trans_y=0,
hflips=[0, 1], fixed_hflip=0,
chpower=0.01*np.array(range(90, 110+1, 2)), fixed_chpower=1,
geoocclusion=None, fixed_geoocclusion=None,
subsampling=[1], fixed_subsampling=1):
self.crop_resolution = crop_resolution
self.image_channels = image_channels
if K.image_data_format() == 'channels_last':
self.input_shape = crop_resolution + image_channels
else:
self.input_shape = image_channels + crop_resolution
self.angles = angles
self.fixed_angle = fixed_angle
self.scales = scales
self.fixed_scale = fixed_scale
self.trans_x = trans_x
self.trans_y = trans_y
self.fixed_trans_x = fixed_trans_x
self.fixed_trans_y = fixed_trans_y
self.hflips = hflips
self.fixed_hflip = fixed_hflip
self.chpower = chpower
self.fixed_chpower = fixed_chpower
self.geoocclusion = geoocclusion
self.fixed_geoocclusion = fixed_geoocclusion
self.subsampling = subsampling
self.fixed_subsampling = fixed_subsampling
def get_fixed_config(self):
return {'angle': self.fixed_angle,
'scale': self.fixed_scale,
'transx': self.fixed_trans_x,
'transy': self.fixed_trans_y,
'hflip': self.fixed_hflip,
'chpower': self.fixed_chpower,
'geoocclusion': self.fixed_geoocclusion,
'subspl': self.fixed_subsampling}
def random_data_generator(self):
angle = DataConfig._getrand(self.angles)
scale = DataConfig._getrand(self.scales)
trans_x = DataConfig._getrand(self.trans_x)
trans_y = DataConfig._getrand(self.trans_y)
hflip = DataConfig._getrand(self.hflips)
chpower = (DataConfig._getrand(self.chpower),
DataConfig._getrand(self.chpower),
DataConfig._getrand(self.chpower))
geoocclusion = self.__get_random_geoocclusion()
subsampling = DataConfig._getrand(self.subsampling)
return {'angle': angle,
'scale': scale,
'transx': trans_x,
'transy': trans_y,
'hflip': hflip,
'chpower': chpower,
'geoocclusion': geoocclusion,
'subspl': subsampling}
def __get_random_geoocclusion(self):
if self.geoocclusion is not None:
w = int(DataConfig._getrand(self.geoocclusion) / 2)
h = int(DataConfig._getrand(self.geoocclusion) / 2)
xmin = w + 1
xmax = self.crop_resolution[0] - xmin
ymin = h + 1
ymax = self.crop_resolution[1] - ymin
x = DataConfig._getrand(range(xmin, xmax, 5))
y = DataConfig._getrand(range(ymin, ymax, 5))
bbox = (x-w, y-h, x+w, y+h)
return bbox
else:
return None
@staticmethod
def _getrand(x):
return x[np.random.randint(0, len(x))]
# Data generation and configuration setup
mpii_sp_dataconf = DataConfig(
crop_resolution=(256, 256),
angles=np.array(range(-40, 40+1, 5)),
scales=np.array([0.7, 1., 1.3]),
)
pennaction_dataconf = DataConfig(
crop_resolution=(256, 256),
angles=np.array(range(-30, 30+1, 5)),
scales=np.array([0.7, 1.0, 1.3]),
trans_x=np.array(range(-40, 40+1, 5)),
trans_y=np.array(range(-10, 10+1, 5)),
subsampling=[4, 6, 8],
fixed_subsampling=6
)
pennaction_pe_dataconf = DataConfig(
crop_resolution=(256, 256),
angles=np.array(range(-40, 40+1, 5)),
scales=np.array([0.7, 1.0, 1.3, 2.0]),
trans_x=np.array(range(-40, 40+1, 5)),
trans_y=np.array(range(-10, 10+1, 5)),
)
human36m_dataconf = DataConfig(
crop_resolution=(256, 256),
angles=np.array(range(-10, 10+1, 5)),
scales=np.array([0.8, 1.0, 1.2]),
trans_x=np.array(range(-20, 20+1, 5)),
trans_y=np.array(range(-4, 4+1, 1)),
geoocclusion=np.array(range(20, 90)),
)
ntu_dataconf = DataConfig(
crop_resolution=(256, 256),
angles=[0],
scales=np.array([0.7, 1.0, 1.3]),
trans_x=range(-40, 40+1, 5),
trans_y=range(-10, 10+1, 5),
subsampling=[3, 4, 5],
fixed_subsampling=4
)
ntu_pe_dataconf = DataConfig(
crop_resolution=(256, 256),
angles=np.array(range(-10, 10+1, 5)),
scales=np.array([0.7, 1.0, 1.3, 2.0]),
trans_x=np.array(range(-40, 40+1, 5)),
trans_y=np.array(range(-10, 10+1, 5)),
)
class ModelConfig(object):
"""Hyperparameters for models."""
def __init__(self, input_shape, poselayout,
num_actions=[],
num_pyramids=8,
action_pyramids=[1, 2], # list of pyramids to perform AR
num_levels=4,
kernel_size=(5, 5),
growth=96,
image_div=8,
predict_rootz=False,
downsampling_type='maxpooling',
pose_replica=False,
num_pose_features=128,
num_visual_features=128,
sam_alpha=1,
dbg_decoupled_pose=False,
dbg_decoupled_h=False):
self.input_shape = input_shape
self.num_joints = poselayout.num_joints
self.dim = poselayout.dim
assert type(num_actions) == list, 'num_actions should be a list'
self.num_actions = num_actions
self.num_pyramids = num_pyramids
self.action_pyramids = action_pyramids
self.num_levels = num_levels
self.kernel_size = kernel_size
self.growth = growth
self.image_div = image_div
self.predict_rootz = predict_rootz
self.downsampling_type = downsampling_type
self.pose_replica = pose_replica
self.num_pose_features = num_pose_features
self.num_visual_features = num_visual_features
self.sam_alpha = sam_alpha
"""Debugging flags."""
self.dbg_decoupled_pose = dbg_decoupled_pose
self.dbg_decoupled_h = dbg_decoupled_h
# Aliases.
mpii_dataconf = mpii_sp_dataconf
|
homeassistant/components/trend/__init__.py
|
MrDelik/core
| 30,023 |
55255
|
"""A sensor that monitors trends in other components."""
from homeassistant.const import Platform
DOMAIN = "trend"
PLATFORMS = [Platform.BINARY_SENSOR]
|
deslib/base.py
|
vishalbelsare/DESlib
| 310 |
55266
|
<reponame>vishalbelsare/DESlib<gh_stars>100-1000
# coding=utf-8
# Author: <NAME> <<EMAIL>>
#
# License: BSD 3 clause
import functools
import math
import warnings
from abc import abstractmethod, ABCMeta
import numpy as np
from scipy.stats import mode
from sklearn.base import BaseEstimator, ClassifierMixin
from sklearn.ensemble import BaseEnsemble, BaggingClassifier
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.utils.validation import (check_X_y, check_is_fitted, check_array,
check_random_state)
from deslib.util import KNNE
from deslib.util import faiss_knn_wrapper
from deslib.util.dfp import frienemy_pruning_preprocessed
from deslib.util.instance_hardness import hardness_region_competence
class BaseDS(BaseEstimator, ClassifierMixin):
"""Base class for a dynamic classifier selection (dcs) and
dynamic ensemble selection (des) methods.
All dcs and des techniques should inherit from this class.
Warning: This class should not be used directly.
Use derived classes instead.
"""
__metaclass__ = ABCMeta
@abstractmethod
def __init__(self, pool_classifiers=None, k=7, DFP=False, with_IH=False,
safe_k=None, IH_rate=0.30, needs_proba=False,
random_state=None, knn_classifier='knn', DSEL_perc=0.5,
knne=False, n_jobs=-1, voting=None):
self.pool_classifiers = pool_classifiers
self.k = k
self.DFP = DFP
self.with_IH = with_IH
self.safe_k = safe_k
self.IH_rate = IH_rate
self.needs_proba = needs_proba
self.random_state = random_state
self.knn_classifier = knn_classifier
self.DSEL_perc = DSEL_perc
self.knne = knne
self.n_jobs = n_jobs
self.voting = voting
# Check optional dependency
if knn_classifier == 'faiss' and not faiss_knn_wrapper.is_available():
raise ImportError(
'Using knn_classifier="faiss" requires that the FAISS library '
'be installed.Please check the Installation Guide.')
def fit(self, X, y):
"""Prepare the DS model by setting the KNN algorithm and
pre-processing the information required to apply the DS
methods
Parameters
----------
X : array of shape (n_samples, n_features)
The input data.
y : array of shape (n_samples)
class labels of each example in X.
Returns
-------
self
"""
self.random_state_ = check_random_state(self.random_state)
X, y = check_X_y(X, y)
# Check if the pool of classifiers is None.
# If yes, use a BaggingClassifier for the pool.
if self.pool_classifiers is None:
X_dsel, y_dsel = self._fit_pool_classifiers(X, y)
else:
self._check_base_classifier_fitted()
self.pool_classifiers_ = self.pool_classifiers
X_dsel = X
y_dsel = y
self.n_classifiers_ = len(self.pool_classifiers_)
# allow base models with feature subspaces.
if hasattr(self.pool_classifiers_, "estimators_features_"):
self.estimator_features_ = \
np.array(self.pool_classifiers_.estimators_features_)
else:
indices = np.arange(X.shape[1])
self.estimator_features_ = np.tile(indices,
(self.n_classifiers_, 1))
# check if the input parameters are correct.
self._setup_label_encoder(y)
y_dsel = self.enc_.transform(y_dsel)
self._set_dsel(X_dsel, y_dsel)
self._set_region_of_competence_algorithm()
self._validate_parameters()
self.roc_algorithm_.fit(X_dsel, y_dsel)
self.BKS_DSEL_ = self._predict_base(self.DSEL_data_)
self.DSEL_processed_ = self.BKS_DSEL_ == y_dsel[:, np.newaxis]
return self
def get_competence_region(self, query, k=None):
"""Compute the region of competence of the query sample
using the data belonging to DSEL.
Parameters
----------
query : array of shape (n_samples, n_features)
The test examples.
k : int (Default = self.k)
The number of neighbors used to in the region of competence.
Returns
-------
dists : array of shape (n_samples, k)
The distances between the query and each sample in the region
of competence. The vector is ordered in an ascending fashion.
idx : array of shape (n_samples, k)
Indices of the instances belonging to the region of competence of
the given query sample.
"""
if k is None:
k = self.k_
dists, idx = self.roc_algorithm_.kneighbors(query,
n_neighbors=k,
return_distance=True)
return np.atleast_2d(dists), np.atleast_2d(idx)
@abstractmethod
def estimate_competence(self, competence_region, distances=None,
predictions=None):
"""estimate the competence of each base classifier :math:`c_{i}`
the classification of the query sample :math:`\\mathbf{x}`.
Returns an array containing the level of competence estimated
for each base classifier. The size of the vector is equals to
the size of the generated_pool of classifiers.
Parameters
----------
competence_region : array of shape (n_samples, n_neighbors)
Indices of the k nearest neighbors according for each
test sample.
distances : array of shape (n_samples, n_neighbors)
Distances of the k nearest neighbors according for each
test sample.
predictions : array of shape (n_samples, n_classifiers)
Predictions of the base classifiers for all test examples
Returns
-------
competences : array (n_classifiers) containing the competence level
estimated for each base classifier
"""
pass
@abstractmethod
def select(self, competences):
"""Select the most competent classifier for
the classification of the query sample x.
The most competent classifier (dcs) or an ensemble
with the most competent classifiers (des) is returned
Parameters
----------
competences : array of shape (n_samples, n_classifiers)
The estimated competence level of each base classifier
for test example
Returns
-------
selected_classifiers : array containing the selected base classifiers
for each test sample
"""
pass
@abstractmethod
def classify_with_ds(self, predictions, probabilities=None,
neighbors=None, distances=None, DFP_mask=None):
"""Predicts the label of the corresponding query sample.
Returns the predicted label.
Parameters
----------
predictions : array of shape (n_samples, n_classifiers)
Predictions of the base classifiers for all test examples
probabilities : array of shape (n_samples, n_classifiers, n_classes)
Probabilities estimates of each base classifier for all test
examples (For methods that always require probabilities from the
base classifiers)
neighbors : array of shape (n_samples, n_neighbors)
Indices of the k nearest neighbors.
distances : array of shape (n_samples, n_neighbors)
Distances from the k nearest neighbors to the query
DFP_mask : array of shape (n_samples, n_classifiers)
Mask containing 1 for the selected base classifier and 0 otherwise.
Returns
-------
predicted_label : array of shape (n_samples)
The predicted label for each query
"""
pass
@abstractmethod
def predict_proba_with_ds(self, predictions, probabilities,
neighbors=None, distances=None, DFP_mask=None):
"""Predicts the posterior probabilities of the corresponding
query sample. Returns the probability estimates of each class.
Parameters
----------
predictions : array of shape (n_samples, n_classifiers)
Predictions of the base classifiers for all test examples
probabilities : array of shape (n_samples, n_classifiers, n_classes)
The predictions of each base classifier for all samples (For
methods that always require probabilities from the base
classifiers).
neighbors : array of shape (n_samples, n_neighbors)
Indices of the k nearest neighbors.
distances : array of shape (n_samples, n_neighbors)
Distances from the k nearest neighbors to the query
DFP_mask : array of shape (n_samples, n_classifiers)
Mask containing 1 for the selected base classifier and 0 otherwise.
Returns
-------
predicted_proba: array of shape (n_samples, n_classes)
Posterior probabilities estimates for each test example.
"""
pass
def predict(self, X):
"""Predict the class label for each sample in X.
Parameters
----------
X : array of shape (n_samples, n_features)
The input data.
Returns
-------
predicted_labels : array of shape (n_samples)
Predicted class label for each sample in X.
"""
X = self._check_predict(X)
preds = np.empty(X.shape[0], dtype=np.intp)
need_proba = self.needs_proba or self.voting == 'soft'
base_preds, base_probas = self._preprocess_predictions(X, need_proba)
# predict all agree
ind_disagreement, ind_all_agree = self._split_agreement(base_preds)
if ind_all_agree.size:
preds[ind_all_agree] = base_preds[ind_all_agree, 0]
# predict with IH
if ind_disagreement.size:
distances, ind_ds_classifier, neighbors = self._IH_prediction(
X, ind_disagreement, preds, is_proba=False
)
# Predict with DS - Check if there are still samples to be labeled.
if ind_ds_classifier.size:
DFP_mask = self._get_DFP_mask(neighbors)
inds, sel_preds, sel_probas = self._prepare_indices_DS(
base_preds, base_probas, ind_disagreement,
ind_ds_classifier)
preds_ds = self.classify_with_ds(sel_preds, sel_probas,
neighbors, distances,
DFP_mask)
preds[inds] = preds_ds
return self.classes_.take(preds)
def _check_predict(self, X):
check_is_fitted(self,
["DSEL_processed_", "DSEL_data_", "DSEL_target_"])
X = check_array(X)
if self.n_features_ != X.shape[1]:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is {0} and "
"input n_features is {1}."
"".format(self.n_features_, X.shape[1]))
return X
def predict_proba(self, X):
"""Estimates the posterior probabilities for sample in X.
Parameters
----------
X : array of shape (n_samples, n_features)
The input data.
Returns
-------
predicted_proba : array of shape (n_samples, n_classes)
Probabilities estimates for each sample in X.
"""
X = self._check_predict(X)
self._check_predict_proba()
probas = np.zeros((X.shape[0], self.n_classes_))
base_preds, base_probas = self._preprocess_predictions(X, True)
# predict all agree
ind_disagreement, ind_all_agree = self._split_agreement(base_preds)
if ind_all_agree.size:
probas[ind_all_agree] = base_probas[ind_all_agree].mean(axis=1)
# predict with IH
if ind_disagreement.size:
distances, ind_ds_classifier, neighbors = self._IH_prediction(
X, ind_disagreement, probas, is_proba=True)
# Predict with DS - Check if there are still samples to be labeled.
if ind_ds_classifier.size:
DFP_mask = self._get_DFP_mask(neighbors)
inds, sel_preds, sel_probas = self._prepare_indices_DS(
base_preds, base_probas, ind_disagreement,
ind_ds_classifier)
probas_ds = self.predict_proba_with_ds(sel_preds,
sel_probas,
neighbors, distances,
DFP_mask)
probas[inds] = probas_ds
return probas
def _preprocess_predictions(self, X, req_proba):
if req_proba:
base_probabilities = self._predict_proba_base(X)
base_predictions = base_probabilities.argmax(axis=2)
else:
base_probabilities = None
base_predictions = self._predict_base(X)
return base_predictions, base_probabilities
def _split_agreement(self, base_predictions):
all_agree_vector = BaseDS._all_classifier_agree(base_predictions)
ind_all_agree = np.where(all_agree_vector)[0]
ind_disagreement = np.where(~all_agree_vector)[0]
return ind_disagreement, ind_all_agree
def _IH_prediction(self, X, ind_disagree, predicted_proba, is_proba=False):
X_DS = X[ind_disagree, :]
distances, region_competence = self.get_competence_region(X_DS)
if self.with_IH:
ind_hard, ind_easy = self._split_easy_samples(region_competence)
distances, region_competence = self._predict_easy_samples(
X_DS, distances, ind_disagree, ind_easy,
region_competence, predicted_proba, is_proba)
else:
# IH was not considered. So all samples go to predict with DS
ind_hard = np.arange(ind_disagree.size)
return distances, ind_hard, region_competence
def _split_easy_samples(self, neighbors):
hardness = hardness_region_competence(neighbors,
self.DSEL_target_,
self.safe_k)
# Get the index associated with the easy and hard samples.
# easy samples are classified by the knn.
easy_samples_mask = hardness < self.IH_rate
ind_knn_classifier = np.where(easy_samples_mask)[0]
ind_ds_classifier = np.where(~easy_samples_mask)[0]
return ind_ds_classifier, ind_knn_classifier
def _predict_easy_samples(self, X_DS, distances, ind_disagreement,
ind_easy, neighbors, predictions, is_proba):
if ind_easy.size:
# Accessing which samples in the original array.
ind_knn_original_matrix = ind_disagreement[ind_easy]
if is_proba:
predictions[ind_knn_original_matrix] = \
self.roc_algorithm_.predict_proba(
X_DS[ind_easy])
else:
y_neighbors = self.DSEL_target_[neighbors[ind_easy,
:self.safe_k]]
predictions_knn, _ = mode(y_neighbors, axis=1)
predictions[ind_knn_original_matrix] = predictions_knn.reshape(
-1, )
neighbors = np.delete(neighbors, ind_easy, axis=0)
distances = np.delete(distances, ind_easy, axis=0)
return distances, neighbors
def _prepare_indices_DS(self, base_predictions, base_probabilities,
ind_disagreement, ind_ds_classifier):
# Get the real indices_ of the samples that will be classified
# using a DS algorithm.
ind_ds_original_matrix = ind_disagreement[ind_ds_classifier]
if base_probabilities is not None:
selected_probas = base_probabilities[
ind_ds_original_matrix]
else:
selected_probas = None
selected_preds = base_predictions[ind_ds_original_matrix]
return ind_ds_original_matrix, selected_preds, selected_probas
def _get_DFP_mask(self, neighbors):
if self.DFP:
DFP_mask = frienemy_pruning_preprocessed(neighbors,
self.DSEL_target_,
self.DSEL_processed_)
else:
DFP_mask = np.ones((neighbors.shape[0], self.n_classifiers_))
return DFP_mask
def _fit_pool_classifiers(self, X, y):
if len(X) < 2:
raise ValueError('More than one sample is needed '
'if the pool of classifiers is not informed.')
# Split the dataset into training (for the base classifier) and
# DSEL (for DS)
X_train, X_dsel, y_train, y_dsel = train_test_split(
X, y, test_size=self.DSEL_perc,
random_state=self.random_state_)
self.pool_classifiers_ = BaggingClassifier(
random_state=self.random_state_, n_jobs=self.n_jobs)
self.pool_classifiers_.fit(X_train, y_train)
return X_dsel, y_dsel
def _check_label_encoder(self):
# Check if base classifiers are not using LabelEncoder (the case for
# scikit-learn's ensembles):
if isinstance(self.pool_classifiers_, BaseEnsemble):
if np.array_equal(self.pool_classifiers_.classes_,
self.pool_classifiers_[0].classes_):
self.base_already_encoded_ = False
else:
self.base_already_encoded_ = True
else:
self.base_already_encoded_ = False
def _compute_highest_possible_IH(self):
highest_IH = (self.safe_k - math.ceil(
self.safe_k / self.n_classes_)) / self.safe_k
return highest_IH
def _validate_ih(self):
highest_IH = self._compute_highest_possible_IH()
if self.IH_rate > highest_IH:
warnings.warn("IH_rate is bigger than the highest possible IH.",
category=RuntimeWarning)
def _validate_k(self):
# validate safe_k
if self.k is None:
self.k_ = self.n_samples_
elif self.k > self.n_samples_:
msg = "k is bigger than DSEL size. Using All DSEL examples " \
"for competence estimation."
warnings.warn(msg, category=RuntimeWarning)
self.k_ = self.n_samples_ - 1
else:
self.k_ = self.k
# Validate safe_k
if self.with_IH and self.safe_k is None:
self.safe_k = self.k
def _setup_label_encoder(self, y):
self._check_label_encoder()
self.enc_ = LabelEncoder()
self.enc_.fit(y)
self.classes_ = self.enc_.classes_
def _encode_base_labels(self, y):
if self.base_already_encoded_:
return y
else:
return self.enc_.transform(y)
def _set_dsel(self, X, y):
"""Pre-Process the input X and y data into the dynamic selection
dataset(DSEL) and get information about the structure of the data
(e.g., n_classes, n_samples, classes)
Parameters
----------
X : array of shape (n_samples, n_features)
The Input data.
y : array of shape (n_samples)
class labels of each sample in X.
"""
self.DSEL_data_ = X
self.DSEL_target_ = y
self.n_classes_ = self.classes_.size
self.n_features_ = X.shape[1]
self.n_samples_ = self.DSEL_target_.size
def _set_region_of_competence_algorithm(self):
if self.knn_classifier is None or self.knn_classifier in ['knn',
'sklearn']:
knn_class = functools.partial(KNeighborsClassifier,
n_jobs=self.n_jobs,
algorithm="auto")
elif self.knn_classifier == 'faiss':
knn_class = functools.partial(
faiss_knn_wrapper.FaissKNNClassifier,
n_jobs=self.n_jobs, algorithm="brute")
elif callable(self.knn_classifier):
knn_class = self.knn_classifier
else:
raise ValueError('"knn_classifier" should be one of the following '
'["knn", "faiss", None] or an estimator class.')
if self.knne:
self.knn_class_ = functools.partial(
KNNE,
knn_classifier=knn_class,
n_jobs=self.n_jobs,
algorithm="auto")
else:
self.knn_class_ = knn_class
self.roc_algorithm_ = self.knn_class_(n_neighbors=self.k)
def _preprocess_dsel(self):
"""Compute the prediction of each base classifier for
all samples in DSEL. Used to speed-up the test phase, by
not requiring to re-classify training samples during test.
Returns
-------
DSEL_processed_ : array of shape (n_samples, n_classifiers).
Each element indicates whether the base classifier
predicted the correct label for the corresponding
sample (True), otherwise (False).
BKS_DSEL_ : array of shape (n_samples, n_classifiers)
Predicted labels of each base classifier for all samples
in DSEL.
"""
BKS_dsel = self._predict_base(self.DSEL_data_)
processed_dsel = BKS_dsel == self.DSEL_target_[:, np.newaxis]
return processed_dsel, BKS_dsel
def _predict_base(self, X):
""" Get the predictions of each base classifier in the pool for all
samples in X.
Parameters
----------
X : array of shape (n_samples, n_features)
The test examples.
Returns
-------
predictions : array of shape (n_samples, n_classifiers)
The predictions of each base classifier for all samples
in X.
"""
predictions = np.zeros((X.shape[0], self.n_classifiers_),
dtype=np.intp)
for index, clf in enumerate(self.pool_classifiers_):
labels = clf.predict(X[:, self.estimator_features_[index]])
predictions[:, index] = self._encode_base_labels(labels)
return predictions
def _predict_proba_base(self, X):
""" Get the predictions (probabilities) of each base classifier in the
pool for all samples in X.
Parameters
----------
X : array of shape (n_samples, n_features)
The test examples.
Returns
-------
probabilities : array of shape (n_samples, n_classifiers, n_classes)
Probabilities estimates of each base classifier for all
test samples.
"""
probas = np.zeros(
(X.shape[0], self.n_classifiers_, self.n_classes_))
for index, clf in enumerate(self.pool_classifiers_):
probas[:, index] = clf.predict_proba(
X[:, self.estimator_features_[index]])
return probas
@staticmethod
def _all_classifier_agree(predictions):
"""Check whether there is a difference in opinion among the classifiers
in the generated_pool.
Parameters
----------
predictions : array of shape (n_samples, n_classifiers)
Predictions of the base classifiers for the test examples
Returns
-------
array of shape (classes)
containing True if all classifiers in the generated_pool agrees
on the same label, otherwise False.
"""
return np.all(predictions == predictions[:, 0].reshape(-1, 1), axis=1)
def _validate_parameters(self):
"""Verify if the input parameters are correct (generated_pool and k)
raises an error if k < 1 or generated_pool is not fitted.
"""
if self.k is not None:
if not isinstance(self.k, int):
raise TypeError("parameter k should be an integer")
if self.k <= 1:
raise ValueError("parameter k must be higher than 1."
"input k is {} ".format(self.k))
if self.safe_k is not None:
if not isinstance(self.safe_k, int):
raise TypeError("parameter safe_k should be an integer")
if self.safe_k <= 1:
raise ValueError("parameter safe_k must be higher than 1."
"input safe_k is {} ".format(self.safe_k))
# safe_k should be equals or lower the neighborhood size k.
if self.safe_k is not None and self.k is not None:
if self.safe_k > self.k:
raise ValueError(
"parameter safe_k must be equal or less than parameter k."
"input safe_k is {} and k is {}".format(self.k,
self.safe_k))
if not isinstance(self.IH_rate, float):
raise TypeError(
"parameter IH_rate should be a float between [0.0, 0.5]")
if self.IH_rate < 0 or self.IH_rate > 0.5:
raise ValueError("Parameter IH_rate should be between [0.0, 0.5]."
"IH_rate = {}".format(self.IH_rate))
self._validate_pool_classifiers()
# validate the value of k
self._validate_k()
# validate the IH
if self.with_IH:
self._validate_ih()
def _validate_pool_classifiers(self):
""" Check the estimator and the n_estimator attribute, set the
`base_estimator_` attribute.
Raises
-------
ValueError
If the pool of classifiers is empty.
"""
if self.n_classifiers_ <= 1:
raise ValueError("n_classifiers must be greater than one, "
"got {}.".format(self.n_classifiers_))
def _check_predict_proba(self):
""" Checks if each base classifier in the pool implements the
predict_proba method.
Raises
-------
ValueError
If the base classifiers do not implements the predict_proba method.
"""
for clf in self.pool_classifiers_:
if "predict_proba" not in dir(clf):
raise ValueError(
"All base classifiers should output probability estimates")
def _check_base_classifier_fitted(self):
""" Checks if each base classifier in the pool is fitted.
Raises
-------
NotFittedError: If any of the base classifiers is not yet fitted.
"""
for clf in self.pool_classifiers:
check_is_fitted(clf, "classes_")
|
DaPy/methods/classifiers/classifier.py
|
huihui7987/DaPy
| 552 |
55273
|
from DaPy.core import Series, SeriesSet
from DaPy.core import is_seq
from copy import copy
def proba2label(seq, labels):
if hasattr(seq, 'shape') is False:
seq = SeriesSet(seq)
if seq.shape[1] > 1:
return clf_multilabel(seq, labels)
return clf_binlabel(seq, labels)
def clf_multilabel(seq, groupby=None):
if is_seq(groupby):
groupby = dict(enumerate(map(str, groupby)))
if not groupby:
groupby = dict()
assert isinstance(groupby, dict), '`labels` must be a list of str or dict object.'
max_ind = seq.argmax(axis=1).T.tolist()[0]
return Series(groupby.get(int(_), _) for _ in max_ind)
def clf_binlabel(seq, labels, cutpoint=0.5):
return Series(labels[0] if _ >= cutpoint else labels[1] for _ in seq)
class BaseClassifier(object):
def __init__(self):
self._labels = []
@property
def labels(self):
return copy(self._labels)
def _calculate_accuracy(self, predict, target):
pred_labels = predict.argmax(axis=1).T.tolist()[0]
targ_labels = target.argmax(axis=1).T.tolist()[0]
return sum(1.0 for p, t in zip(pred_labels, targ_labels) if p == t) / len(predict)
def predict_proba(self, X):
'''
Predict your own data with fitted model
Paremeter
---------
data : matrix
The new data that you expect to predict.
Return
------
Matrix: the predict result of your data.
'''
X = self._engine.mat(X)
return self._forecast(X)
def predict(self, X):
'''
Predict your data with a fitted model and return the label
Parameter
---------
data : matrix
the data that you expect to predict
Return
------
Series : the labels of each record
'''
return proba2label(self.predict_proba(X), self._labels)
|
tests3/issue802.py
|
TmaxTW/pyodbc
| 2,419 |
55307
|
"""
This tests ensures that there is no memory leakage
when params.cpp:ExecuteMulti function does conversion of Unicode to Bytes.
In ExecuteMulti function after DoExecute label
SQLExecute returns
One scenario where SQLParamData function will be used is when there is a varchar(max),
a parameter with an unknown size in the INSERT INTO query.
In this case, a unicode string is being added to a varchar(max) field.
In order to execute the INSERT INTO query, SQLExecute is used. SQLExecute will return
SQL_NEED_DATA (SQL_NEED_DATA = 99). Then SQLParamData will be used to create a SQL
parameter and will return SQL_NEED_DATA too. When PyUnicode_Check(pInfo->cell) is true,
a conversion of Unicode to Bytes is required before it can be used by SQLPutData.
During this conversion a new PyObject, called bytes, is created and assigned to objCell.
This object never gets Py_XDECREF, and the data will stay stuck in the memory without a
reference.
This memory leak is only visible when using varchar(max) because varchar(max) required
additional allocation of memory that correspond to the size of the input while
varchar(100) for example will not case another SQL_NEED_DATA status.
To see how to reproduce the memory leak,
look at https://github.com/mkleehammer/pyodbc/issues/802
"""
import os
import unittest
import psutil
from tests3.testutils import add_to_path, load_setup_connection_string
add_to_path()
import pyodbc
KB = 1024
MB = KB * 1024
CONNECTION_STRING = None
CONNECTION_STRING_ERROR_MESSAGE = (
r"Please create tmp\setup.cfg file or set a valid value to CONNECTION_STRING."
)
process = psutil.Process()
def memory():
return process.memory_info().vms
class SQLPutDataUnicodeToBytesMemoryLeakTestCase(unittest.TestCase):
driver = pyodbc
@classmethod
def setUpClass(cls):
filename = os.path.splitext(os.path.basename(__file__))[0]
cls.connection_string = (
load_setup_connection_string(filename) or CONNECTION_STRING
)
if not cls.connection_string:
return ValueError(CONNECTION_STRING_ERROR_MESSAGE)
def test__varchar_max__inserting_many_rows__same_memory_usage(self):
varchar_limit = "max"
num_rows = 50_000
data = [(i, f"col{i:06}", 3.14159265 * (i + 1)) for i in range(num_rows)]
table_name = "pd_test"
col_names = ["id", "txt_col", "float_col"]
ins_sql = f"INSERT INTO {table_name} ({','.join(col_names)}) VALUES ({','.join('?' * len(col_names))})"
with pyodbc.connect(self.connection_string, autocommit=True) as cnxn:
# First time adds memory, not related to the test.
self.action(cnxn, data, ins_sql, table_name, varchar_limit)
for iteration in range(3):
start_memory = memory()
self.action(cnxn, data, ins_sql, table_name, varchar_limit)
end_memory = memory()
memory_diff = end_memory - start_memory
self.assertLess(memory_diff, 100 * KB)
def action(self, cnxn, data, ins_sql, table_name, varchar_limit):
crsr = cnxn.cursor()
crsr.execute(f"DROP TABLE IF EXISTS {table_name}")
crsr.execute(
f"CREATE TABLE {table_name} (id int, txt_col varchar({varchar_limit}), float_col float(53))"
)
crsr.fast_executemany = True
crsr.executemany(ins_sql, data)
crsr.close()
def main():
unittest.main()
if __name__ == "__main__":
main()
|
sparse_operation_kit/sparse_operation_kit/embeddings/get_embedding_op.py
|
ShaunHeNJU/DeepRec-1
| 292 |
55327
|
"""
Copyright (c) 2021, NVIDIA CORPORATION.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
"""
These APIs are used along with TensorFlow 1.x.
They are similar to tf.get_variable()
"""
from tensorflow.python.framework import ops
import threading
_SparseOperationKitEmbeddingLayerStoreKey = "SparseOperationKitEmbeddingLayerStore"
class _EmbeddingLayerStore(threading.local):
def __init__(self):
super(_EmbeddingLayerStore, self).__init__()
self._embedding_layer_container = dict()
def _create_embedding(self, name, constructor, **kwargs):
if constructor is None:
raise ValueError("embedding_layer: '{}' does not exist and "
"cannot create it with constructor: "
"{}".format(name, constructor))
embedding_layer = constructor(**kwargs)
self._embedding_layer_container[name] = embedding_layer
return embedding_layer
def get_embedding(self, name, constructor=None, **kwargs):
emb = self._embedding_layer_container.get(name, None)
return emb or self._create_embedding(name,
constructor=constructor, **kwargs)
def _get_embedding_store():
emb_store = ops.get_collection(_SparseOperationKitEmbeddingLayerStoreKey)
if not emb_store:
emb_store = _EmbeddingLayerStore()
ops.add_to_collection(_SparseOperationKitEmbeddingLayerStoreKey, emb_store)
else:
emb_store = emb_store[0]
return emb_store
def get_embedding(name, constructor=None, **kwargs):
"""
This method is used to get or create a embedding layer.
Parameters
----------
name: string
unique name used to identify embedding layer.
constructor: SOK.embedding_layer
the construction function used to create a new embedding layer.
When creating a new embedding layer, constructor(**kwargs) will be called.
kwargs: keyword arguments for new embedding layer creation.
Returns
-------
embedding_layer: embedding layer
created by constructor(**kwargs)
Examples
--------
.. code-block:: python
# here to create a new embedding layer.
emb_layer = sok.get_embedding(name="Emb", sok.All2AllDenseEmbedding,
max_vocabulary_size_per_gpu=1024,
embedding_vec_size=16,
slot_num=10,
nnz_per_slot=1,
dynamic_input=False)
outputs = emb_layer(inputs)
...
# here to reuse already created embedding layer.
emb_layer = sok.get_embedding(name="Emb")
outputs_1 = emb_layer(inputs)
...
"""
return _get_embedding_store().get_embedding(name=name,
constructor=constructor, **kwargs)
|
plugins/syntax_dev/completions.py
|
thom1729-forks/PackageDev
| 288 |
55338
|
<gh_stars>100-1000
import re
import sublime
import sublime_plugin
from ..lib.scope_data import COMPILED_HEADS
from ..lib import syntax_paths
from ..lib import inhibit_word_completions
__all__ = (
'SyntaxDefCompletionsListener',
'PackagedevCommitScopeCompletionCommand'
)
# a list of kinds used to denote the different kinds of completions
KIND_HEADER_BASE = (sublime.KIND_ID_NAMESPACE, 'K', 'Header Key')
KIND_HEADER_DICT = (sublime.KIND_ID_NAMESPACE, 'D', 'Header Dict')
KIND_HEADER_LIST = (sublime.KIND_ID_NAMESPACE, 'L', 'Header List')
KIND_BRANCH = (sublime.KIND_ID_NAVIGATION, 'b', 'Branch Point')
KIND_CONTEXT = (sublime.KIND_ID_KEYWORD, 'c', 'Context')
KIND_FUNCTION = (sublime.KIND_ID_FUNCTION, 'f', 'Function')
KIND_FUNCTION_TRUE = (sublime.KIND_ID_FUNCTION, 'f', 'Function')
KIND_FUNCTION_FALSE = (sublime.KIND_ID_FUNCTION, 'f', 'Function')
KIND_CAPTURUE = (sublime.KIND_ID_FUNCTION, 'c', 'Captures')
KIND_SCOPE = (sublime.KIND_ID_NAMESPACE, 's', 'Scope')
KIND_VARIABLE = (sublime.KIND_ID_VARIABLE, 'v', 'Variable')
PACKAGE_NAME = __package__.split('.')[0]
def status(msg, console=False):
msg = "[%s] %s" % (PACKAGE_NAME, msg)
sublime.status_message(msg)
if console:
print(msg)
def format_static_completions(templates):
def format_item(trigger, kind, details):
if kind in (KIND_HEADER_DICT, KIND_CAPTURUE, KIND_CONTEXT):
completion_format = sublime.COMPLETION_FORMAT_SNIPPET
suffix = ":\n "
elif kind is KIND_HEADER_LIST:
completion_format = sublime.COMPLETION_FORMAT_SNIPPET
suffix = ":\n - "
elif kind is KIND_FUNCTION_TRUE:
completion_format = sublime.COMPLETION_FORMAT_SNIPPET
suffix = ": ${1:true}"
elif kind is KIND_FUNCTION_FALSE:
completion_format = sublime.COMPLETION_FORMAT_SNIPPET
suffix = ": ${1:false}"
else:
completion_format = sublime.COMPLETION_FORMAT_TEXT
suffix = ": "
return sublime.CompletionItem(
trigger=trigger,
kind=kind,
details=details,
completion=trigger + suffix,
completion_format=completion_format,
)
return [format_item(*template) for template in templates]
def format_completions(items, annotation="", kind=sublime.KIND_AMBIGUOUS):
format_string = "Defined at line <a href='subl:goto_line {{\"line\": \"{0}\"}}'>{0}</a>"
return [
sublime.CompletionItem(
trigger=trigger,
annotation=annotation,
kind=kind,
details=format_string.format(row) if row is not None else "",
)
for trigger, row in items
]
class SyntaxDefCompletionsListener(sublime_plugin.ViewEventListener):
base_completions_root = format_static_completions(templates=(
# base keys
('name', KIND_HEADER_BASE, "The display name of the syntax."),
('scope', KIND_HEADER_BASE, "The main scope of the syntax."),
('version', KIND_HEADER_BASE, "The sublime-syntax version."),
('extends', KIND_HEADER_BASE, "The syntax which is to be extended."),
('name', KIND_HEADER_BASE, "The display name of the syntax."),
('first_line_match', KIND_HEADER_BASE, "The pattern to identify a file by content."),
# dict keys
('variables', KIND_HEADER_DICT, 'The variables definitions.'),
('contexts', KIND_HEADER_DICT, 'The syntax contexts.'),
# list keys
('file_extensions', KIND_HEADER_LIST, "The list of file extensions."),
('hidden_extensions', KIND_HEADER_LIST, "The list of hidden file extensions.")
))
base_completions_contexts = format_static_completions(templates=(
# meta functions
('meta_append', KIND_FUNCTION_TRUE, "Add rules to the end of the inherit context."),
('meta_content_scope', KIND_FUNCTION, "A scope to apply to the content of a context."),
('meta_include_prototype', KIND_FUNCTION_FALSE, "Flag to in-/exclude `prototype`"),
('meta_prepend', KIND_FUNCTION_TRUE, "Add rules to the beginning of the inherit context."),
('meta_scope', KIND_FUNCTION, "A scope to apply to the full context."),
('clear_scopes', KIND_FUNCTION, "Clear meta scopes."),
# matching tokens
('match', KIND_FUNCTION, "Pattern to match tokens."),
# scoping
('scope', KIND_FUNCTION, "The scope to apply if a token matches"),
('captures', KIND_CAPTURUE, "Assigns scopes to the capture groups."),
# contexts
('push', KIND_FUNCTION, "Push a context onto the stack."),
('set', KIND_FUNCTION, "Set a context onto the stack."),
('pop', KIND_FUNCTION_TRUE, 'Pop context(s) from the stack.'),
('with_prototype', KIND_FUNCTION, "Rules to prepend to each context."),
# branching
('branch_point', KIND_FUNCTION, "Name of the point to rewind to if a branch fails."),
('branch', KIND_FUNCTION, "Push branches onto the stack."),
('fail', KIND_FUNCTION, "Fail the current branch."),
# embedding
('embed', KIND_FUNCTION, "A context or syntax to embed."),
('embed_scope', KIND_FUNCTION, "A scope to apply to the embedded syntax."),
('escape', KIND_FUNCTION, "A pattern to denote the end of the embedded syntax."),
('escape_captures', KIND_CAPTURUE, "Assigns scopes to the capture groups."),
# including
('include', KIND_FUNCTION, "Includes a context."),
('apply_prototype', KIND_FUNCTION_TRUE, "Apply prototype of included syntax."),
))
# These instance variables are for communicating
# with our PostCompletionsListener instance.
base_suffix = None
@classmethod
def applies_to_primary_view_only(cls):
return False
@classmethod
def is_applicable(cls, settings):
return settings.get('syntax') == syntax_paths.SYNTAX_DEF
@inhibit_word_completions
def on_query_completions(self, prefix, locations):
def match_selector(selector, offset=0):
"""Verify scope for each location."""
return all(self.view.match_selector(point + offset, selector)
for point in locations)
# None of our business
if not match_selector("- comment - (source.regexp - keyword.other.variable)"):
return None
# Scope name completions based on our scope_data database
if match_selector("meta.expect-scope, meta.scope", -1):
return self._complete_scope(prefix, locations)
# Auto-completion for include values using the 'contexts' keys and for
if match_selector("meta.expect-context-list-or-content"
" | meta.context-list-or-content", -1):
return (self._complete_keyword(prefix, locations)
+ self._complete_context(prefix, locations))
# Auto-completion for include values using the 'contexts' keys
if match_selector("meta.expect-context-list | meta.expect-context"
" | meta.include | meta.context-list", -1):
return self._complete_context(prefix, locations) or None
# Auto-completion for branch points with 'fail' key
if match_selector("meta.expect-branch-point-reference"
" | meta.branch-point-reference", -1):
return self._complete_branch_point()
# Auto-completion for variables in match patterns using 'variables' keys
if match_selector("keyword.other.variable"):
return self._complete_variable()
# Standard completions for unmatched regions
return self._complete_keyword(prefix, locations)
def _line_prefix(self, point):
_, col = self.view.rowcol(point)
line = self.view.substr(self.view.line(point))
return line[:col]
def _complete_context(self, prefix, locations):
# Verify that we're not looking for an external include
for point in locations:
line_prefix = self._line_prefix(point)
real_prefix = re.search(r"[^,\[ ]*$", line_prefix).group(0)
if real_prefix.startswith("scope:") or "/" in real_prefix:
return [] # Don't show any completions here
elif real_prefix != prefix:
# print("Unexpected prefix mismatch: {} vs {}".format(real_prefix, prefix))
return []
return format_completions(
[(self.view.substr(r), self.view.rowcol(r.begin())[0] + 1)
for r in self.view.find_by_selector("entity.name.function.context")],
annotation="",
kind=KIND_CONTEXT,
)
def _complete_keyword(self, prefix, locations):
def match_selector(selector, offset=0):
"""Verify scope for each location."""
return all(self.view.match_selector(point + offset, selector)
for point in locations)
prefixes = set()
for point in locations:
# Ensure that we are completing a key name everywhere
line_prefix = self._line_prefix(point)
real_prefix = re.sub(r"^ +(- +)*", " ", line_prefix) # collapse leading whitespace
prefixes.add(real_prefix)
if len(prefixes) != 1:
return None
else:
real_prefix = next(iter(prefixes))
# (Supposedly) all keys start their own line
match = re.match(r"^(\s*)[\w-]*$", real_prefix)
if not match:
return None
elif not match.group(1):
return self.base_completions_root
elif match_selector("meta.block.contexts"):
return self.base_completions_contexts
else:
return None
def _complete_scope(self, prefix, locations):
# Determine entire prefix
window = self.view.window()
prefixes = set()
for point in locations:
*_, real_prefix = self._line_prefix(point).rpartition(" ")
prefixes.add(real_prefix)
if len(prefixes) > 1:
return None
else:
real_prefix = next(iter(prefixes))
# Tokenize the current selector
tokens = real_prefix.split(".")
if len(tokens) <= 1:
# No work to be done here, just return the heads
return COMPILED_HEADS.to_completion()
base_scope_completion = self._complete_base_scope(tokens[-1])
# Browse the nodes and their children
nodes = COMPILED_HEADS
for i, token in enumerate(tokens[:-1]):
node = nodes.find(token)
if not node:
status(
"`%s` not found in scope naming conventions" % '.'.join(tokens[:i + 1]),
window
)
break
nodes = node.children
if not nodes:
status("No nodes available in scope naming conventions after `%s`"
% '.'.join(tokens[:-1]), window)
break
else:
# Offer to complete from conventions or base scope
return nodes.to_completion() + base_scope_completion
# Since we don't have anything to offer,
# just complete the base scope appendix/suffix.
return base_scope_completion
def _complete_base_scope(self, last_token):
window = self.view.window()
regions = self.view.find_by_selector("meta.scope string - meta.block")
if len(regions) != 1:
status(
"Warning: Could not determine base scope uniquely",
window,
console=True
)
self.base_suffix = None
return []
base_scope = self.view.substr(regions[0])
*_, base_suffix = base_scope.rpartition(".")
# Only useful when the base scope suffix is not already the last one
# In this case it is even useful to inhibit other completions completely
if last_token == base_suffix:
self.base_suffix = None
return []
self.base_suffix = base_suffix
return format_completions([(base_suffix, None)], "base suffix", KIND_SCOPE)
def _complete_variable(self):
return format_completions(
[(self.view.substr(r), self.view.rowcol(r.begin())[0] + 1)
for r in self.view.find_by_selector("entity.name.constant")],
annotation="",
kind=KIND_VARIABLE,
)
def _complete_branch_point(self):
return format_completions(
[(self.view.substr(r), self.view.rowcol(r.begin())[0] + 1)
for r in self.view.find_by_selector("entity.name.label.branch-point")],
annotation="",
kind=KIND_BRANCH,
)
class PackagedevCommitScopeCompletionCommand(sublime_plugin.TextCommand):
def run(self, edit):
self.view.run_command("commit_completion")
# Don't add duplicated dot, if scope is edited in the middle.
if self.view.substr(self.view.sel()[0].a) == ".":
return
# Check if the completed value was the base suffix
# and don't re-open auto complete in that case.
listener = sublime_plugin.find_view_event_listener(self.view, SyntaxDefCompletionsListener)
if listener and listener.base_suffix:
point = self.view.sel()[0].a
region = sublime.Region(point - len(listener.base_suffix) - 1, point)
if self.view.substr(region) == "." + listener.base_suffix:
return
# Insert a . and trigger next completion
self.view.run_command('insert', {'characters': "."})
self.view.run_command('auto_complete', {'disable_auto_insert': True})
|
exporter/operators/delete_export_collection.py
|
drewcassidy/blender-tools
| 311 |
55347
|
"""Operator to delete an Export Collection by name."""
from bpy.props import StringProperty
from bpy.types import Operator
from ..functions import get_export_collection_by_name
class EmbarkDeleteExportCollection(Operator): # pylint: disable=too-few-public-methods
"""Deletes the named Export Collection, but leaves all contained objects in the scene."""
bl_idname = "object.embark_delete_export_collection"
bl_label = "Delete Export Collection"
bl_description = "Deletes this Export Collection, but leaves all contained objects in the scene"
bl_options = {'REGISTER', 'UNDO'}
collection_name: StringProperty(options={'HIDDEN'})
def execute(self, context):
"""Deletes the named Collection."""
collection = get_export_collection_by_name(self.collection_name)
if not collection:
self.report({'ERROR'}, f"Failed to find an Export Collection named '{self.collection_name}'")
return {'CANCELLED'}
collection.delete()
self.report({'INFO'}, f"Deleted Export Collection '{self.collection_name}'")
return {'FINISHED'}
|
tests/unicode/unicode_index.py
|
learnforpractice/micropython-cpp
| 13,648 |
55353
|
<filename>tests/unicode/unicode_index.py
print("Привет".find("т"))
print("Привет".find("П"))
print("Привет".rfind("т"))
print("Привет".rfind("П"))
print("Привет".index("т"))
print("Привет".index("П"))
|
bin/config.py
|
database64128/rclone
| 18,121 |
55370
|
<filename>bin/config.py
#!/usr/bin/env python3
"""
Test program to demonstrate the remote config interfaces in
rclone.
This program can simulate
rclone config create
rclone config update
rclone config password - NOT implemented yet
rclone authorize - NOT implemented yet
Pass the desired action as the first argument then any parameters.
This assumes passwords will be passed in the clear.
"""
import argparse
import subprocess
import json
from pprint import pprint
sep = "-"*60
def rpc(args, command, params):
"""
Run the command. This could be either over the CLI or the API.
Here we run over the API either using `rclone rc --loopback` which
is useful for making sure state is saved properly or to an
existing rclone rcd if `--rc` is used on the command line.
"""
if args.rc:
import requests
kwargs = {
"json": params,
}
if args.user:
kwargs["auth"] = (args.user, args.password)
r = requests.post('http://localhost:5572/'+command, **kwargs)
if r.status_code != 200:
raise ValueError(f"RC command failed: Error {r.status_code}: {r.text}")
return r.json()
cmd = ["rclone", "-vv", "rc", "--loopback", command, "--json", json.dumps(params)]
result = subprocess.run(cmd, stdout=subprocess.PIPE, check=True)
return json.loads(result.stdout)
def parse_parameters(parameters):
"""
Parse the incoming key=value parameters into a dict
"""
d = {}
for param in parameters:
parts = param.split("=", 1)
if len(parts) != 2:
raise ValueError("bad format for parameter need name=value")
d[parts[0]] = parts[1]
return d
def ask(opt):
"""
Ask the user to enter the option
This is the user interface for asking a user a question.
If there are examples they should be presented.
"""
while True:
if opt["IsPassword"]:
print("*** Inputting a password")
print(opt['Help'])
examples = opt.get("Examples", ())
or_number = ""
if len(examples) > 0:
or_number = " or choice number"
for i, example in enumerate(examples):
print(f"{i:3} value: {example['Value']}")
print(f" help: {example['Help']}")
print(f"Enter a {opt['Type']} value{or_number}. Press Enter for the default ('{opt['DefaultStr']}')")
print(f"{opt['Name']}> ", end='')
s = input()
if s == "":
return opt["DefaultStr"]
try:
i = int(s)
if i >= 0 and i < len(examples):
return examples[i]["Value"]
except ValueError:
pass
if opt["Exclusive"]:
for example in examples:
if s == example["Value"]:
return s
# Exclusive is set but the value isn't one of the accepted
# ones so continue
print("Value isn't one of the acceptable values")
else:
return s
return s
def create_or_update(what, args):
"""
Run the equivalent of rclone config create
or rclone config update
what should either be "create" or "update
"""
print(what, args)
params = parse_parameters(args.parameters)
inp = {
"name": args.name,
"parameters": params,
"opt": {
"nonInteractive": True,
"all": args.all,
"noObscure": args.obscured_passwords,
"obscure": not args.obscured_passwords,
},
}
if what == "create":
inp["type"] = args.type
while True:
print(sep)
print("Input to API")
pprint(inp)
print(sep)
out = rpc(args, "config/"+what, inp)
print(sep)
print("Output from API")
pprint(out)
print(sep)
if out["State"] == "":
return
if out["Error"]:
print("Error", out["Error"])
result = ask(out["Option"])
inp["opt"]["state"] = out["State"]
inp["opt"]["result"] = result
inp["opt"]["continue"] = True
def create(args):
"""Run the equivalent of rclone config create"""
create_or_update("create", args)
def update(args):
"""Run the equivalent of rclone config update"""
create_or_update("update", args)
def password(args):
"""Run the equivalent of rclone config password"""
print("password", args)
raise NotImplementedError()
def authorize(args):
"""Run the equivalent of rclone authorize"""
print("authorize", args)
raise NotImplementedError()
def main():
"""
Make the command line parser and dispatch
"""
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.add_argument("-a", "--all", action='store_true',
help="Ask all the config questions if set")
parser.add_argument("-o", "--obscured-passwords", action='store_true',
help="If set assume the passwords are obscured")
parser.add_argument("--rc", action='store_true',
help="If set use the rc (you'll need to start an rclone rcd)")
parser.add_argument("--user", type=str, default="",
help="Username for use with --rc")
parser.add_argument("--pass", type=str, default="", dest='password',
help="Password for use with --rc")
subparsers = parser.add_subparsers(dest='command', required=True)
subparser = subparsers.add_parser('create')
subparser.add_argument("name", type=str, help="Name of remote to create")
subparser.add_argument("type", type=str, help="Type of remote to create")
subparser.add_argument("parameters", type=str, nargs='*', help="Config parameters name=value name=value")
subparser.set_defaults(func=create)
subparser = subparsers.add_parser('update')
subparser.add_argument("name", type=str, help="Name of remote to update")
subparser.add_argument("parameters", type=str, nargs='*', help="Config parameters name=value name=value")
subparser.set_defaults(func=update)
subparser = subparsers.add_parser('password')
subparser.add_argument("name", type=str, help="Name of remote to update")
subparser.add_argument("parameters", type=str, nargs='*', help="Config parameters name=value name=value")
subparser.set_defaults(func=password)
subparser = subparsers.add_parser('authorize')
subparser.set_defaults(func=authorize)
args = parser.parse_args()
args.func(args)
if __name__ == "__main__":
main()
|
Contributions/PowerRecursion.py
|
sattwik21/Hacktoberfest2021-1
| 215 |
55377
|
<reponame>sattwik21/Hacktoberfest2021-1<filename>Contributions/PowerRecursion.py<gh_stars>100-1000
# Calculates a^b
def power(a, b):
if b == 0:
return 1
b -= 1
return a*power(a, b)
x = int(input())
y = int(input())
print(power(x, y))
|
tensorboard/data/server/pip_package/install.py
|
Digitaltransform/tensorboard
| 6,139 |
55387
|
<reponame>Digitaltransform/tensorboard<gh_stars>1000+
# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Build and install `tensorboard_data_server` into your virtualenv.
This bundles the `//tensorboard/data/server` binary built with Bazel.
To uninstall, just `pip uninstall tensorboard_data_server`.
"""
import os
import pathlib
import subprocess
import sys
import tempfile
def _shell(*args, **kwargs):
kwargs.setdefault("check", True)
return subprocess.run(*args, **kwargs)
def main():
if not os.environ.get("VIRTUAL_ENV"):
sys.stderr.write(
"Not in a virtualenv. You probably don't want to do this.\n"
)
sys.exit(1)
tmpdir = tempfile.TemporaryDirectory()
thisdir = pathlib.Path(os.path.dirname(__file__))
server_binary = thisdir / ".." / "server"
build_script = thisdir / "build"
try:
result = _shell(
[
build_script,
"--server-binary=%s" % (server_binary,),
"--out-dir=%s" % (tmpdir.name,),
],
capture_output=True,
)
except subprocess.CalledProcessError as e:
sys.stdout.buffer.write(e.stdout)
sys.stdout.flush()
sys.stderr.buffer.write(e.stderr)
sys.stderr.flush()
raise
lines = result.stdout.decode("utf-8").splitlines()
if len(lines) != 1:
raise RuntimeError("Expected one line of stdout; got: %r" % lines)
wheel = lines[0]
_shell(["pip", "uninstall", "-y", "tensorboard_data_server"])
_shell(["pip", "install", "--", wheel])
if __name__ == "__main__":
main()
|
Basic/Calculate Factorial of A Number/SolutionByEnthusiastDeveloper.py
|
rajethanm4/Programmers-Community
| 261 |
55391
|
'''
Program Description: Calculate factorial of a given number
'''
def calculate_factorial(n):
if n == 0:
return 1
if n < 0:
raise ValueError
fact = 1
for x in range(1,n+1):
fact *= x
return fact
print('N = ', end='')
try:
result = calculate_factorial(int(input()))
print('Output =', result)
except ValueError:
print('Only positive numbers are supported')
|
python/runtime/local/submitter_test.py
|
ikingye/sqlflow
| 4,742 |
55406
|
<reponame>ikingye/sqlflow
# Copyright 2020 The SQLFlow Authors. All rights reserved.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT 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 unittest
import runtime.temp_file as temp_file
import runtime.testing as testing
from runtime.feature.column import NumericColumn
from runtime.feature.field_desc import FieldDesc
from runtime.local import evaluate, explain, pred, train
class TestXGBoostTrain(unittest.TestCase):
@unittest.skipUnless(testing.get_driver() == "mysql",
"skip non mysql tests")
def test_train(self):
ds = testing.get_datasource()
original_sql = """SELECT * FROM iris.train
TO TRAIN xgboost.gbtree
WITH
objective="multi:softmax",
num_boost_round=20,
num_class=3,
validation.select="SELECT * FROM iris.test"
INTO iris.xgboost_train_model_test;
"""
select = "SELECT * FROM iris.train"
val_select = "SELECT * FROM iris.test"
train_params = {
"num_boost_round": 20,
}
model_params = {"num_class": 3, "objective": "multi:softmax"}
with temp_file.TemporaryDirectory(as_cwd=True):
eval_result = train(ds, original_sql, select, val_select,
"xgboost.gbtree", "", None,
NumericColumn(FieldDesc(name="class")),
model_params, train_params, None,
"iris.xgboost_train_model_test", None)
self.assertLess(eval_result['train']['merror'][-1], 0.01)
self.assertLess(eval_result['validate']['merror'][-1], 0.01)
with temp_file.TemporaryDirectory(as_cwd=True):
pred_original_sql = """SELECT * FROM iris.test
TO PREDICT iris.xgboost_pred_result.pred_val
USING iris.xgboost_train_model_test;"""
pred(ds, pred_original_sql, "SELECT * FROM iris.test",
"iris.xgboost_train_model_test", "pred_val", model_params,
"iris.xgboost_pred_result")
with temp_file.TemporaryDirectory(as_cwd=True):
explain_original_sql = """SELECT * FROM iris.test
TO EXPLAIN iris.xgboost_train_model_test
INTO iris.xgboost_explain_result;"""
explain(ds, explain_original_sql, "SELECT * FROM iris.test",
"iris.xgboost_train_model_test", model_params,
"iris.xgboost_explain_result")
with temp_file.TemporaryDirectory(as_cwd=True):
evaluate_original_sql = """SELECT * FROM iris.test
TO EVALUATE iris.xgboost_train_model_test
WITH label_col=class
INTO iris.xgboost_evaluate_result;"""
evaluate(ds, evaluate_original_sql, "SELECT * FROM iris.test",
"class", "iris.xgboost_train_model_test", model_params,
"iris.xgboost_evaluate_result")
if __name__ == '__main__':
unittest.main()
|
python/ql/test/query-tests/Classes/incomplete-ordering/incomplete_ordering.py
|
vadi2/codeql
| 4,036 |
55407
|
<reponame>vadi2/codeql
#Incomplete ordering
class PartOrdered(object):
def __eq__(self, other):
return self is other
def __ne__(self, other):
return self is not other
def __hash__(self):
return id(self)
def __lt__(self, other):
return False
#Don't blame a sub-class for super-class's sins.
class DerivedPartOrdered(PartOrdered):
pass
|
onedrive/cli_tool.py
|
timgates42/python-onedrive
| 130 |
55408
|
<reponame>timgates42/python-onedrive
#!/usr/bin/env python2
#-*- coding: utf-8 -*-
from __future__ import unicode_literals, print_function
import itertools as it, operator as op, functools as ft
from os.path import dirname, basename, exists, isdir, join, abspath
from posixpath import join as ujoin, dirname as udirname, basename as ubasename
from collections import defaultdict
import os, sys, io, logging, re, types, json
try: import chardet
except ImportError: chardet = None # completely optional
try: import onedrive
except ImportError:
# Make sure tool works from a checkout
if __name__ != '__main__': raise
pkg_root = abspath(dirname(__file__))
for pkg_root in pkg_root, dirname(pkg_root):
if isdir(join(pkg_root, 'onedrive'))\
and exists(join(pkg_root, 'setup.py')):
sys.path.insert(0, dirname(__file__))
try: import onedrive
except ImportError: pass
else: break
else: raise ImportError('Failed to find/import "onedrive" module')
from onedrive import api_v5, conf
force_encoding = None
def tree_node(): return defaultdict(tree_node)
def print_result(data, file, tpl=None, indent='', indent_first=None, indent_level=' '*2):
# Custom printer is used because pyyaml isn't very pretty with unicode
if isinstance(data, list):
for v in data:
print_result( v, file=file, tpl=tpl, indent=indent + ' ',
indent_first=(indent_first if indent_first is not None else indent) + '- ' )
indent_first = None
elif isinstance(data, dict):
indent_cur = indent_first if indent_first is not None else indent
if tpl is None:
for k, v in sorted(data.viewitems(), key=op.itemgetter(0)):
print(indent_cur + decode_obj(k, force=True) + ':', file=file, end='')
indent_cur = indent
if not isinstance(v, (list, dict)): # peek to display simple types inline
print_result(v, file=file, tpl=tpl, indent=' ')
else:
print('', file=file)
print_result(v, file=file, tpl=tpl, indent=indent_cur+indent_level)
else:
if '{' not in tpl and not re.search(r'^\s*$', tpl): tpl = '{{0[{}]}}'.format(tpl)
try: data = tpl.format(data)
except Exception as err:
log.debug( 'Omitting object that does not match template'
' (%r) from output (error: %s %s): %r', tpl, type(err), err, data )
else: print_result(data, file=file, indent=indent_cur)
else:
if indent_first is not None: indent = indent_first
print(indent + decode_obj(data, force=True), file=file)
def decode_obj(obj, force=False):
'Convert or dump object to unicode.'
if isinstance(obj, unicode): return obj
elif isinstance(obj, bytes):
if force_encoding is not None: return obj.decode(force_encoding)
if chardet:
enc_guess = chardet.detect(obj)
if enc_guess['confidence'] > 0.7:
return obj.decode(enc_guess['encoding'])
return obj.decode('utf-8')
else:
return obj if not force else repr(obj)
def size_units( size,
_units=list(reversed(list((u, 2 ** (i * 10)) for i, u in enumerate('BKMGT')))) ):
for u, u1 in _units:
if size > u1: break
return size / float(u1), u
def id_match(s, _re_id=re.compile(
r'^('
r'(file|folder)\.[0-9a-f]{16}\.[0-9A-F]{16}!\d+|folder\.[0-9a-f]{16}'
# Force-resolving all "special-looking" paths here, because
# there are separate commands (e.g. "quota") to get data from these
# r'|me(/\w+(/.*)?)?' # special paths like "me/skydrive"
r')$' ) ):
return s if s and _re_id.search(s) else None
def main():
import argparse
parser = argparse.ArgumentParser(
description='Tool to manipulate OneDrive contents.')
parser.add_argument('-c', '--config',
metavar='path', default=conf.ConfigMixin.conf_path_default,
help='Writable configuration state-file (yaml).'
' Used to store authorization_code, access and refresh tokens.'
' Should initially contain at least something like "{client: {id: xxx, secret: yyy}}".'
' Default: %(default)s')
parser.add_argument('-p', '--path', action='store_true',
help='Interpret file/folder arguments only as human paths, not ids (default: guess).'
' Avoid using such paths if non-unique "name"'
' attributes of objects in the same parent folder might be used.')
parser.add_argument('-i', '--id', action='store_true',
help='Interpret file/folder arguments only as ids (default: guess).')
parser.add_argument('-k', '--object-key', metavar='spec',
help='If returned data is an object, or a list of objects, only print this key from there.'
' Supplied spec can be a template string for python str.format,'
' assuming that object gets passed as the first argument.'
' Objects that do not have specified key or cannot'
' be formatted using supplied template will be ignored entirely.'
' Example: {0[id]} {0[name]!r} {0[count]:03d} (uploader: {0[from][name]})')
parser.add_argument('-e', '--encoding', metavar='enc', default='utf-8',
help='Use specified encoding (example: utf-8) for CLI input/output.'
' See full list of supported encodings at:'
' http://docs.python.org/2/library/codecs.html#standard-encodings .'
' Pass empty string or "detect" to detect input encoding via'
' chardet module, if available, falling back to utf-8 and terminal encoding for output.'
' Forced utf-8 is used by default, for consistency and due to its ubiquity.')
parser.add_argument('-V', '--version', action='version',
version='python-onedrive {}'.format(onedrive.__version__),
help='Print version number and exit.')
parser.add_argument('--debug', action='store_true', help='Verbose operation mode.')
cmds = parser.add_subparsers(title='Supported operations', dest='call')
cmd = cmds.add_parser('auth', help='Perform user authentication.')
cmd.add_argument('url', nargs='?', help='URL with the authorization_code.')
cmds.add_parser('auth_refresh',
help='Force-refresh OAuth2 access_token.'
' Should never be necessary under normal conditions.')
cmds.add_parser('quota', help='Print quota information.')
cmds.add_parser('user', help='Print user data.')
cmds.add_parser('recent', help='List recently changed objects.')
cmd = cmds.add_parser('info', help='Display object metadata.')
cmd.add_argument('object',
nargs='?', default='me/skydrive',
help='Object to get info on (default: %(default)s).')
cmd = cmds.add_parser('info_set', help='Manipulate object metadata.')
cmd.add_argument('object', help='Object to manipulate metadata for.')
cmd.add_argument('data',
help='JSON mapping of values to set (example: {"name": "new_file_name.jpg"}).')
cmd = cmds.add_parser('link', help='Get a link to a file.')
cmd.add_argument('object', help='Object to get link for.')
cmd.add_argument('-t', '--type', default='shared_read_link',
help='Type of link to request. Possible values'
' (default: %(default)s): shared_read_link, embed, shared_edit_link.')
cmd = cmds.add_parser('ls', help='List folder contents.')
cmd.add_argument('folder',
nargs='?', default='me/skydrive',
help='Folder to list contents of (default: %(default)s).')
cmd.add_argument('-r', '--range',
metavar='{[offset]-[limit] | limit}',
help='List only specified range of objects inside.'
' Can be either dash-separated "offset-limit" tuple'
' (any of these can be omitted) or a single "limit" number.')
cmd.add_argument('-o', '--objects', action='store_true',
help='Dump full objects, not just name and id.')
cmd = cmds.add_parser('mkdir', help='Create a folder.')
cmd.add_argument('name',
help='Name (or a path consisting of dirname + basename) of a folder to create.')
cmd.add_argument('folder',
nargs='?', default=None,
help='Parent folder (default: me/skydrive).')
cmd.add_argument('-m', '--metadata',
help='JSON mappings of metadata to set for the created folder.'
' Optonal. Example: {"description": "Photos from last trip to Mordor"}')
cmd = cmds.add_parser('get', help='Download file contents.')
cmd.add_argument('file', help='File (object) to read.')
cmd.add_argument('file_dst', nargs='?', help='Name/path to save file (object) as.')
cmd.add_argument('-b', '--byte-range',
help='Specific range of bytes to read from a file (default: read all).'
' Should be specified in rfc2616 Range HTTP header format.'
' Examples: 0-499 (start - 499), -500 (end-500 to end).')
cmd = cmds.add_parser('put', help='Upload a file.')
cmd.add_argument('file', help='Path to a local file to upload.')
cmd.add_argument('folder',
nargs='?', default='me/skydrive',
help='Folder to put file into (default: %(default)s).')
cmd.add_argument('-n', '--no-overwrite', action='store_true', default=None,
help='Do not overwrite existing files with the same "name" attribute (visible name).'
' Default (and documented) API behavior is to overwrite such files.')
cmd.add_argument('-d', '--no-downsize', action='store_true', default=None,
help='Disable automatic downsizing when uploading a large image.'
' Default (and documented) API behavior is to downsize images.')
cmd.add_argument('-b', '--bits', action='store_true',
help='Force usage of BITS API (uploads via multiple http requests).'
' Default is to only fallback to it for large (wrt API limits) files.')
cmd.add_argument('--bits-frag-bytes',
type=int, metavar='number',
default=api_v5.PersistentOneDriveAPI.api_bits_default_frag_bytes,
help='Fragment size for using BITS API (if used), in bytes. Default: %(default)s')
cmd.add_argument('--bits-do-auth-refresh-before-commit-hack', action='store_true',
help='Do auth_refresh trick before upload session commit request.'
' This is reported to avoid current (as of 2015-01-16) http 5XX errors from the API.'
' See github issue #39, gist with BITS API spec and the README file for more details.')
cmd = cmds.add_parser('cp', help='Copy file to a folder.')
cmd.add_argument('file', help='File (object) to copy.')
cmd.add_argument('folder',
nargs='?', default='me/skydrive',
help='Folder to copy file to (default: %(default)s).')
cmd = cmds.add_parser('mv', help='Move file to a folder.')
cmd.add_argument('file', help='File (object) to move.')
cmd.add_argument('folder',
nargs='?', default='me/skydrive',
help='Folder to move file to (default: %(default)s).')
cmd = cmds.add_parser('rm', help='Remove object (file or folder).')
cmd.add_argument('object', nargs='+', help='Object(s) to remove.')
cmd = cmds.add_parser('comments', help='Show comments for a file, object or folder.')
cmd.add_argument('object', help='Object to show comments for.')
cmd = cmds.add_parser('comment_add', help='Add comment for a file, object or folder.')
cmd.add_argument('object', help='Object to add comment for.')
cmd.add_argument('message', help='Comment message to add.')
cmd = cmds.add_parser('comment_delete', help='Delete comment from a file, object or folder.')
cmd.add_argument('comment_id',
help='ID of the comment to remove (use "comments"'
' action to get comment ids along with the messages).')
cmd = cmds.add_parser('tree',
help='Show contents of onedrive (or folder) as a tree of file/folder names.'
' Note that this operation will have to (separately) request a listing of every'
' folder under the specified one, so can be quite slow for large number of these.')
cmd.add_argument('folder',
nargs='?', default='me/skydrive',
help='Folder to display contents of (default: %(default)s).')
cmd.add_argument('-o', '--objects', action='store_true',
help='Dump full objects, not just name and type.')
optz = parser.parse_args()
if optz.path and optz.id:
parser.error('--path and --id options cannot be used together.')
if optz.encoding.strip('"') in [None, '', 'detect']: optz.encoding = None
if optz.encoding:
global force_encoding
force_encoding = optz.encoding
reload(sys)
sys.setdefaultencoding(force_encoding)
global log
log = logging.getLogger()
logging.basicConfig(level=logging.WARNING
if not optz.debug else logging.DEBUG)
api = api_v5.PersistentOneDriveAPI.from_conf(optz.config)
res = xres = None
resolve_path = ( (lambda s: id_match(s) or api.resolve_path(s))\
if not optz.path else api.resolve_path ) if not optz.id else (lambda obj_id: obj_id)
# Make best-effort to decode all CLI options to unicode
for k, v in vars(optz).viewitems():
if isinstance(v, bytes): setattr(optz, k, decode_obj(v))
elif isinstance(v, list): setattr(optz, k, map(decode_obj, v))
if optz.call == 'auth':
if not optz.url:
print(
'Visit the following URL in any web browser (firefox, chrome, safari, etc),\n'
' authorize there, confirm access permissions, and paste URL of an empty page\n'
' (starting with "https://login.live.com/oauth20_desktop.srf")'
' you will get redirected to in the end.' )
print(
'Alternatively, use the returned (after redirects)'
' URL with "{} auth <URL>" command.\n'.format(sys.argv[0]) )
print('URL to visit: {}\n'.format(api.auth_user_get_url()))
try: import readline # for better compatibility with terminal quirks, see #40
except ImportError: pass
optz.url = raw_input('URL after last redirect: ').strip()
if optz.url:
api.auth_user_process_url(optz.url)
api.auth_get_token()
print('API authorization was completed successfully.')
elif optz.call == 'auth_refresh':
xres = dict(scope_granted=api.auth_get_token())
elif optz.call == 'quota':
df, ds = map(size_units, api.get_quota())
res = dict(free='{:.1f}{}'.format(*df), quota='{:.1f}{}'.format(*ds))
elif optz.call == 'user':
res = api.get_user_data()
elif optz.call == 'recent':
res = api('me/skydrive/recent_docs')['data']
elif optz.call == 'ls':
offset = limit = None
if optz.range:
span = re.search(r'^(\d+)?[-:](\d+)?$', optz.range)
try:
if not span: limit = int(optz.range)
else: offset, limit = map(int, span.groups())
except ValueError:
parser.error(
'--range argument must be in the "[offset]-[limit]"'
' or just "limit" format, with integers as both offset and'
' limit (if not omitted). Provided: {}'.format(optz.range) )
res = sorted(
api.listdir(resolve_path(optz.folder), offset=offset, limit=limit),
key=op.itemgetter('name') )
if not optz.objects: res = map(op.itemgetter('name'), res)
elif optz.call == 'info':
res = api.info(resolve_path(optz.object))
elif optz.call == 'info_set':
xres = api.info_update(resolve_path(optz.object), json.loads(optz.data))
elif optz.call == 'link':
res = api.link(resolve_path(optz.object), optz.type)
elif optz.call == 'comments':
res = api.comments(resolve_path(optz.object))
elif optz.call == 'comment_add':
res = api.comment_add(resolve_path(optz.object), optz.message)
elif optz.call == 'comment_delete':
res = api.comment_delete(optz.comment_id)
elif optz.call == 'mkdir':
name, path = optz.name.replace('\\', '/'), optz.folder
if '/' in name:
name, path_ext = ubasename(name), udirname(name)
path = ujoin(path, path_ext.strip('/')) if path else path_ext
xres = api.mkdir( name=name, folder_id=resolve_path(path),
metadata=optz.metadata and json.loads(optz.metadata) or dict() )
elif optz.call == 'get':
contents = api.get(resolve_path(optz.file), byte_range=optz.byte_range)
if optz.file_dst:
dst_dir = dirname(abspath(optz.file_dst))
if not isdir(dst_dir): os.makedirs(dst_dir)
with open(optz.file_dst, "wb") as dst: dst.write(contents)
else:
sys.stdout.write(contents)
sys.stdout.flush()
elif optz.call == 'put':
dst = optz.folder
if optz.bits_do_auth_refresh_before_commit_hack:
api.api_bits_auth_refresh_before_commit_hack = True
if optz.bits_frag_bytes > 0: api.api_bits_default_frag_bytes = optz.bits_frag_bytes
if dst is not None:
xres = api.put( optz.file, resolve_path(dst),
bits_api_fallback=0 if optz.bits else True, # 0 = "always use BITS"
overwrite=optz.no_overwrite and False, downsize=optz.no_downsize and False )
elif optz.call in ['cp', 'mv']:
argz = map(resolve_path, [optz.file, optz.folder])
xres = (api.move if optz.call == 'mv' else api.copy)(*argz)
elif optz.call == 'rm':
for obj in it.imap(resolve_path, optz.object): xres = api.delete(obj)
elif optz.call == 'tree':
def recurse(obj_id):
node = tree_node()
for obj in api.listdir(obj_id):
# Make sure to dump files as lists with -o,
# not dicts, to make them distinguishable from dirs
res = obj['type'] if not optz.objects else [obj['type'], obj]
node[obj['name']] = recurse(obj['id']) \
if obj['type'] in ['folder', 'album'] else res
return node
root_id = resolve_path(optz.folder)
res = {api.info(root_id)['name']: recurse(root_id)}
else:
parser.error('Unrecognized command: {}'.format(optz.call))
if res is not None: print_result(res, tpl=optz.object_key, file=sys.stdout)
if optz.debug and xres is not None:
buff = io.StringIO()
print_result(xres, file=buff)
log.debug('Call result:\n{0}\n{1}{0}'.format('-' * 20, buff.getvalue()))
if __name__ == '__main__': main()
|
tests/utils/test_image_utils.py
|
swershrimpy/gtsfm
| 122 |
55438
|
import numpy as np
from gtsam import SfmTrack
from gtsfm.common.image import Image
import gtsfm.utils.images as image_utils
def test_get_average_point_color():
""" Ensure 3d point color is computed as mean of RGB per 2d measurement."""
# random point; 2d measurements below are dummy locations (not actual projection)
triangulated_pt = np.array([1, 2, 1])
track_3d = SfmTrack(triangulated_pt)
# in camera 0
track_3d.add_measurement(idx=0, m=np.array([130, 80]))
# in camera 1
track_3d.add_measurement(idx=1, m=np.array([10, 60]))
img0 = np.zeros((100, 200, 3), dtype=np.uint8)
img0[80, 130] = np.array([40, 50, 60])
img1 = np.zeros((100, 200, 3), dtype=np.uint8)
img1[60, 10] = np.array([60, 70, 80])
images = {0: Image(img0), 1: Image(img1)}
r, g, b = image_utils.get_average_point_color(track_3d, images)
assert r == 50
assert g == 60
assert b == 70
def test_get_downsampling_factor_per_axis_leaveintact() -> None:
"""Ensure that image is left intact, when shorter side is smaller than max_resolution."""
img_h = 700
img_w = 1500
img = Image(np.zeros((img_h, img_w, 3), dtype=np.uint8))
max_resolution = 800
scale_u, scale_v, new_h, new_w = image_utils.get_downsampling_factor_per_axis(img_h, img_w, max_resolution)
assert scale_u == 1.0
assert scale_v == 1.0
assert new_h == 700
assert new_w == 1500
def test_get_rescaling_factor_per_axis_upsample() -> None:
"""Ensure that max resolution constraint is met, when upsampling image.
Resize a 700x1500 image, so that the shorter image side is EXACTLY 800 px.
"""
img_h = 700
img_w = 1500
img = Image(np.zeros((img_h, img_w, 3), dtype=np.uint8))
max_resolution = 800
scale_u, scale_v, new_h, new_w = image_utils.get_rescaling_factor_per_axis(img_h, img_w, max_resolution)
# 8/7 will not give a clean integer division
assert np.isclose(scale_u, 1.1427, atol=4)
assert np.isclose(scale_v, 1.1429, atol=4)
assert new_h == 800
assert new_w == 1714
def test_get_downsampling_factor_per_axis() -> None:
"""Ensure that max resolution constraint is met, when downsampling image.
Resize a 700x1500 image, so that the shorter image side is AT MOST 600 px.
Image is in landscape mode.
"""
img_h = 700
img_w = 1500
img = Image(np.zeros((img_h, img_w, 3), dtype=np.uint8))
max_resolution = 600
scale_u, scale_v, new_h, new_w = image_utils.get_downsampling_factor_per_axis(img_h, img_w, max_resolution)
# Note that 600 / 700 = 0.85714
# 1500 * 0.85714 = 1285.7, which we round up to 1286.
assert np.isclose(scale_u, 0.8573, atol=4)
assert np.isclose(scale_v, 0.8571, atol=4)
assert new_h == 600
assert new_w == 1286
def test_get_rescaling_factor_per_axis_downsample() -> None:
"""Ensure that max resolution constraint is met, when downsampling image.
Resize a 700x1500 image, so that the shorter image side is EXACTLY 600 px.
Image is in landscape mode.
"""
img_h = 700
img_w = 1500
img = Image(np.zeros((img_h, img_w, 3), dtype=np.uint8))
max_resolution = 600
scale_u, scale_v, new_h, new_w = image_utils.get_rescaling_factor_per_axis(img_h, img_w, max_resolution)
# Note that 600 / 700 = 0.85714
# 1500 * 0.85714 = 1285.7, which we round up to 1286.
assert np.isclose(scale_u, 0.8573, atol=4)
assert np.isclose(scale_v, 0.8571, atol=4)
assert new_h == 600
assert new_w == 1286
def test_get_downsampling_factor_per_axis_portrait() -> None:
"""Ensure that max resolution constraint is met, when downsampling image.
Resize a 700x1500 image, so that the shorter image side is AT MOST 600 px.
Image is in portrait mode.
"""
img_h = 1500
img_w = 700
img = Image(np.zeros((img_h, img_w, 3), dtype=np.uint8))
max_resolution = 600
scale_u, scale_v, new_h, new_w = image_utils.get_downsampling_factor_per_axis(img_h, img_w, max_resolution)
# Note that 600 / 700 = 0.85714
# 1500 * 0.85714 = 1285.7, which we round up to 1286.
assert np.isclose(scale_u, 0.8571, atol=4)
assert np.isclose(scale_v, 0.8573, atol=4)
assert new_h == 1286
assert new_w == 600
def test_get_rescaling_factor_per_axis_downsample_portrait() -> None:
"""Ensure that max resolution constraint is met, when downsampling image.
Resize a 700x1500 image, so that the shorter image side is EXACTLY 600 px.
Image is in portrait mode.
"""
img_h = 1500
img_w = 700
img = Image(np.zeros((img_h, img_w, 3), dtype=np.uint8))
max_resolution = 600
scale_u, scale_v, new_h, new_w = image_utils.get_rescaling_factor_per_axis(img_h, img_w, max_resolution)
# Note that 600 / 700 = 0.85714
# 1500 * 0.85714 = 1285.7, which we round up to 1286.
assert np.isclose(scale_v, 0.8571, atol=4)
assert np.isclose(scale_u, 0.8573, atol=4)
assert new_h == 1286
assert new_w == 600
|
scripts/vis_urdf.py
|
lianghongzhuo/urdfpy
| 122 |
55464
|
"""
Script for visualizing a robot from a URDF.
Author: <NAME>
"""
import argparse
import urdfpy
if __name__ == '__main__':
# Parse Args
parser = argparse.ArgumentParser(
description='Visualize a robot from a URDF file'
)
parser.add_argument('urdf', type=str,
help='Path to URDF file that describes the robot')
parser.add_argument('-a', action='store_true',
help='Visualize robot articulation')
parser.add_argument('-c', action='store_true',
help='Use collision geometry')
args = parser.parse_args()
robot = urdfpy.URDF.load(args.urdf)
if args.a:
robot.animate(use_collision=args.c)
else:
robot.show(use_collision=args.c)
|
collectors/PDChaos.py
|
gfek/Lepus
| 218 |
55466
|
import requests
from json import loads
from termcolor import colored
from configparser import RawConfigParser
def init(domain):
PDCH = []
print(colored("[*]-Searching Project Discovery Chaos...", "yellow"))
parser = RawConfigParser()
parser.read("config.ini")
CHAOS_KEY = parser.get("PDChaos", "CHAOS_API_KEY")
if CHAOS_KEY == "":
print(" \__", colored("No Project Discovery Chaos API key configured", "red"))
return []
headers = {"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:88.0) Gecko/20100101 Firefox/88.0", "Authorization": CHAOS_KEY}
url = "https://dns.projectdiscovery.io/dns/{0}/subdomains".format(domain)
try:
response = requests.get(url, headers=headers).text
subdomains = loads(response)["subdomains"]
for subdomain in subdomains:
if subdomain:
PDCH.append("{0}.{1}".format(subdomain, domain))
PDCH = set(PDCH)
print(" \__ {0}: {1}".format(colored("Subdomains found", "cyan"), colored(len(PDCH), "yellow")))
return PDCH
except requests.exceptions.RequestException as err:
print(" \__", colored(err, "red"))
return []
except requests.exceptions.HTTPError as errh:
print(" \__", colored(errh, "red"))
return []
except requests.exceptions.ConnectionError as errc:
print(" \__", colored(errc, "red"))
return []
except requests.exceptions.Timeout as errt:
print(" \__", colored(errt, "red"))
return []
except Exception:
print(" \__", colored("Something went wrong!", "red"))
return []
|
env/Lib/site-packages/OpenGL/GLES2/ANGLE/program_binary.py
|
5gconnectedbike/Navio2
| 210 |
55469
|
'''OpenGL extension ANGLE.program_binary
This module customises the behaviour of the
OpenGL.raw.GLES2.ANGLE.program_binary to provide a more
Python-friendly API
Overview (from the spec)
This extension makes available a program binary format,
PROGRAM_BINARY_ANGLE. It enables retrieving and loading of pre-linked
ANGLE program objects.
The official definition of this extension is available here:
http://www.opengl.org/registry/specs/ANGLE/program_binary.txt
'''
from OpenGL import platform, constant, arrays
from OpenGL import extensions, wrapper
import ctypes
from OpenGL.raw.GLES2 import _types, _glgets
from OpenGL.raw.GLES2.ANGLE.program_binary import *
from OpenGL.raw.GLES2.ANGLE.program_binary import _EXTENSION_NAME
def glInitProgramBinaryANGLE():
'''Return boolean indicating whether this extension is available'''
from OpenGL import extensions
return extensions.hasGLExtension( _EXTENSION_NAME )
### END AUTOGENERATED SECTION
|
src/opts/base_opts.py
|
ParikhKadam/part-affinity
| 110 |
55517
|
import argparse
import os
class Opts:
def __init__(self):
self.parser = argparse.ArgumentParser()
def init(self):
self.parser.add_argument('-expID', default='default', help='Experiment ID')
self.parser.add_argument('-data', default='default', help='Input data folder')
self.parser.add_argument('-nThreads', default=4, type=int, help='Number of threads')
self.parser.add_argument('-expDir', default='../exp', help='Experiments directory')
self.parser.add_argument('-scaleAugFactor', default=0.25, type=float, help='Scale augment factor')
self.parser.add_argument('-rotAugProb', default=0.4, type=float, help='Rotation augment probability')
self.parser.add_argument('-flipAugProb', default=0.5, type=float, help='Flip augment probability')
self.parser.add_argument('-rotAugFactor', default=30, type=float, help='Rotation augment factor')
self.parser.add_argument('-colorAugFactor', default=0.2, type=float, help='Colo augment factor')
self.parser.add_argument('-imgSize', default=368, type=int, help='Number of threads')
self.parser.add_argument('-hmSize', default=46, type=int, help='Number of threads')
self.parser.add_argument('-DEBUG', type=int, default=0, help='Debug')
self.parser.add_argument('-sigmaPAF', default=5, type=int, help='Width of PAF')
self.parser.add_argument('-sigmaHM', default=7, type=int, help='Std. of Heatmap')
self.parser.add_argument('-variableWidthPAF', dest='variableWidthPAF', action='store_true', help='Variable width PAF based on length of part')
self.parser.add_argument('-dataset', default='coco', help='Dataset')
self.parser.add_argument('-model', default='vgg', help='Model')
self.parser.add_argument('-batchSize', default=8, type=int, help='Batch Size')
self.parser.add_argument('-LR', default=1e-3, type=float, help='Learn Rate')
self.parser.add_argument('-nEpoch', default=150, type=int, help='Number of Epochs')
self.parser.add_argument('-dropLR', type=float, default=50, help='Drop LR')
self.parser.add_argument('-valInterval', type=int, default=1, help='Val Interval')
self.parser.add_argument('-loadModel', default='none', help='Load pre-trained')
self.parser.add_argument('-train', dest='train', action='store_true', help='Train')
self.parser.add_argument('-vizOut', dest='vizOut', action='store_true', help='Visualize output?')
self.parser.add_argument('-criterionHm', default='mse', help='Heatmap Criterion')
self.parser.add_argument('-criterionPaf', default='mse', help='PAF Criterion')
def parse(self):
self.init()
self.opt = self.parser.parse_args()
self.opt.saveDir = os.path.join(self.opt.expDir, self.opt.expID)
if self.opt.DEBUG > 0:
self.opt.nThreads = 1
args = dict((name, getattr(self.opt, name)) for name in dir(self.opt)
if not name.startswith('_'))
if not os.path.exists(self.opt.saveDir):
os.makedirs(self.opt.saveDir)
file_name = os.path.join(self.opt.saveDir, 'opt.txt')
with open(file_name, 'wt') as opt_file:
opt_file.write('==> Args:\n')
for k, v in sorted(args.items()):
opt_file.write(' %s: %s\n' % (str(k), str(v)))
return self.opt
|
flatdata-generator/tests/generators/py_expectations/archives/empty.py
|
gferon/flatdata
| 140 |
55526
|
class n_A(flatdata.archive.Archive):
_SCHEMA = """namespace n {
archive A
{
}
}
"""
_NAME = "A"
_RESOURCES = {
"A.archive" : flatdata.archive.ResourceSignature(
container=flatdata.resources.RawData,
initializer=None,
schema=_SCHEMA,
is_optional=False,
doc="Archive signature"),
}
def __init__(self, resource_storage):
flatdata.archive.Archive.__init__(self, resource_storage)
|
tests/unit/operations/test_spotops.py
|
senstb/aws-elastic-beanstalk-cli
| 110 |
55580
|
# Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"). You
# may not use this file except in compliance with the License. A copy of
# the License is located at
#
# http://aws.amazon.com/apache2.0/
#
# or in the "license" file accompanying this file. This file is
# distributed on an "AS IS" BASIS, WITHOUT 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 os
import shutil
import io
import unittest
import mock
from ebcli.operations import spotops
class TestSpotOps(unittest.TestCase):
@mock.patch('ebcli.operations.spotops.prompt_for_instance_types')
def test_get_spot_instance_types_from_customer__success(
self,
prompt_for_instance_types_mock,
):
enable_spot=True
interactive=True
prompt_for_instance_types_mock.return_value='t2.micro, t3.micro'
self.assertEqual('t2.micro, t3.micro', spotops.get_spot_instance_types_from_customer(interactive, enable_spot))
@mock.patch('ebcli.operations.spotops.prompt_for_instance_types')
def test_get_spot_instance_types_from_customer__test_for_prompting(
self,
prompt_for_instance_types_mock,
):
prompt_for_instance_types_mock.return_value=''
self.assertEqual(
'',
spotops.get_spot_instance_types_from_customer(
interactive=True,
enable_spot=True,
)
)
prompt_for_instance_types_mock.assert_called_once_with()
@mock.patch('ebcli.operations.spotops.prompt_for_instance_types')
def test_get_spot_instance_types_from_customer__enable_spot_not_passed(
self,
prompt_for_instance_types_mock,
):
enable_spot=None
interactive=True
prompt_for_instance_types_mock.assert_not_called()
self.assertFalse(spotops.get_spot_instance_types_from_customer(interactive, enable_spot))
@mock.patch('ebcli.operations.spotops.prompt_for_instance_types')
def test_get_spot_instance_types_from_customer__interactive_is_disabled(
self,
prompt_for_instance_types_mock,
):
enable_spot=False
interactive=False
prompt_for_instance_types_mock.assert_not_called()
self.assertFalse(spotops.get_spot_instance_types_from_customer(interactive, enable_spot))
|
core/process_mask.py
|
liruilong940607/A-NeRF
| 110 |
55583
|
<reponame>liruilong940607/A-NeRF
import os
from io import BytesIO
import tarfile
import tempfile
from six.moves import urllib
import time
import numpy as np
from PIL import Image
import cv2, pdb, glob, argparse
import tensorflow as tf
# code borrowed from: https://github.com/senguptaumd/Background-Matting/blob/master/test_segmentation_deeplab.py
## setup ####################
def create_pascal_label_colormap():
"""Creates a label colormap used in PASCAL VOC segmentation benchmark.
Returns:
A Colormap for visualizing segmentation results.
"""
colormap = np.zeros((256, 3), dtype=int)
ind = np.arange(256, dtype=int)
for shift in reversed(range(8)):
for channel in range(3):
colormap[:, channel] |= ((ind >> channel) & 1) << shift
ind >>= 3
return colormap
def label_to_color_image(label):
"""Adds color defined by the dataset colormap to the label.
Args:
label: A 2D array with integer type, storing the segmentation label.
Returns:
result: A 2D array with floating type. The element of the array
is the color indexed by the corresponding element in the input label
to the PASCAL color map.
Raises:
ValueError: If label is not of rank 2 or its value is larger than color
map maximum entry.
"""
if label.ndim != 2:
raise ValueError('Expect 2-D input label')
colormap = create_pascal_label_colormap()
if np.max(label) >= len(colormap):
raise ValueError('label value too large.')
return colormap[label]
LABEL_NAMES = np.asarray([
'background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus',
'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike',
'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tv'
])
FULL_LABEL_MAP = np.arange(len(LABEL_NAMES)).reshape(len(LABEL_NAMES), 1)
FULL_COLOR_MAP = label_to_color_image(FULL_LABEL_MAP)
MODEL_NAME = 'xception_coco_voctrainval' # @param ['mobilenetv2_coco_voctrainaug', 'mobilenetv2_coco_voctrainval', 'xception_coco_voctrainaug', 'xception_coco_voctrainval']
_DOWNLOAD_URL_PREFIX = 'http://download.tensorflow.org/models/'
_MODEL_URLS = {
'mobilenetv2_coco_voctrainaug':
'deeplabv3_mnv2_pascal_train_aug_2018_01_29.tar.gz',
'mobilenetv2_coco_voctrainval':
'deeplabv3_mnv2_pascal_trainval_2018_01_29.tar.gz',
'xception_coco_voctrainaug':
'deeplabv3_pascal_train_aug_2018_01_04.tar.gz',
'xception_coco_voctrainval':
'deeplabv3_pascal_trainval_2018_01_04.tar.gz',
}
_TARBALL_NAME = _MODEL_URLS[MODEL_NAME]
class DeepLabModel(object):
"""Class to load deeplab model and run inference."""
INPUT_TENSOR_NAME = 'ImageTensor:0'
OUTPUT_TENSOR_NAME = 'SemanticPredictions:0'
INPUT_SIZE = 513
FROZEN_GRAPH_NAME = 'frozen_inference_graph'
def __init__(self, tarball_path):
#"""Creates and loads pretrained deeplab model."""
self.graph = tf.Graph()
graph_def = None
# Extract frozen graph from tar archive.
tar_file = tarfile.open(tarball_path)
for tar_info in tar_file.getmembers():
if self.FROZEN_GRAPH_NAME in os.path.basename(tar_info.name):
file_handle = tar_file.extractfile(tar_info)
graph_def = tf.GraphDef.FromString(file_handle.read())
break
tar_file.close()
if graph_def is None:
raise RuntimeError('Cannot find inference graph in tar archive.')
with self.graph.as_default():
tf.import_graph_def(graph_def, name='')
self.sess = tf.Session(graph=self.graph)
def run(self, image):
"""Runs inference on a single image.
Args:
image: A PIL.Image object, raw input image.
Returns:
resized_image: RGB image resized from original input image.
seg_map: Segmentation map of `resized_image`.
"""
width, height = image.size
resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)
target_size = (int(resize_ratio * width), int(resize_ratio * height))
resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)
batch_seg_map = self.sess.run(
self.OUTPUT_TENSOR_NAME,
feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})
seg_map = batch_seg_map[0]
return resized_image, seg_map
def process_masks(img_paths, save_paths, model_dir='deeplab_model'):
# download model if not already have it
if not os.path.exists(model_dir):
tf.gfile.MakeDirs(model_dir)
download_path = os.path.join(model_dir, _TARBALL_NAME)
if not os.path.exists(download_path):
print('downloading model to %s, this might take a while...' % download_path)
urllib.request.urlretrieve(_DOWNLOAD_URL_PREFIX + _MODEL_URLS[MODEL_NAME],
download_path)
print('download completed! loading DeepLab model...')
MODEL = DeepLabModel(download_path)
print('model loaded successfully!')
# process images
for i in range(0, len(img_paths)):
start_time = time.time()
if i % 500 == 0:
print(f"{i+1}/{len(img_paths)}")
start_read = time.time()
image = Image.open(img_paths[i])
start_read = time.time()
res_im,seg=MODEL.run(image)
seg=cv2.resize(seg.astype(np.uint8),image.size)
mask_sel=(seg==15).astype(np.float32)
save_dir = os.path.dirname(save_paths[i])
os.makedirs(save_dir, exist_ok=True)
# dilate the boundary a bit because as the mask is not accurate
kernel = np.ones((3, 3))
mask_sel = cv2.dilate(mask_sel, kernel=kernel, iterations=1)
start_read = time.time()
cv2.imwrite(save_paths[i],(255*mask_sel).astype(np.uint8))
print("finish mask processing.")
def process_bbox_masks(img_paths, save_paths, bboxes, model_dir='deeplab_model', mul=1.0):
if not os.path.exists(model_dir):
tf.gfile.MakeDirs(model_dir)
download_path = os.path.join(model_dir, _TARBALL_NAME)
if not os.path.exists(download_path):
print('downloading model to %s, this might take a while...' % download_path)
urllib.request.urlretrieve(_DOWNLOAD_URL_PREFIX + _MODEL_URLS[MODEL_NAME],
download_path)
print('download completed! loading DeepLab model...')
MODEL = DeepLabModel(download_path)
print('model loaded successfully!')
# process images
for i in range(0, len(img_paths)):
if i % 500 == 0:
print(f"{i+1}/{len(img_paths)}")
start_read = time.time()
image = Image.open(img_paths[i])
W, H = image.size
# crop by bounding box
cx, cy, box_len = bboxes[i]
cx, cy = int(cx), int(cy)
box_len = int(box_len * 0.5 * mul)
left = max(cx - box_len, 0)
top = max(cy - box_len, 0)
right = min(cx + box_len, W)
bot = min(cy + box_len, H)
cropped = image.crop((left, top, right, bot))
res_im,seg=MODEL.run(cropped)
seg=cv2.resize(seg.astype(np.uint8),cropped.size)
mask_sel= ((seg==15).astype(np.uint8))
mask = np.zeros((H, W), dtype=np.uint8)
mask[top:bot, left:right] = mask_sel
# put the cropped part back to the original image
save_dir = os.path.dirname(save_paths[i])
os.makedirs(save_dir, exist_ok=True)
# dilate the boundary a bit because as the mask is not accurate
kernel = np.ones((3, 3))
mask = cv2.dilate(mask, kernel=kernel, iterations=1)[..., None]
cv2.imwrite(save_paths[i],(255*mask).astype(np.uint8))
print("finish mask processing.")
if __name__ == "__main__":
import deepdish as dd
import imageio
parser = argparse.ArgumentParser(description='Arguments for masks extraction')
parser.add_argument("-b", "--base_path", type=str,
#default="data/h36m/h36m_full",
default='data/h36m/',
help='base directory')
parser.add_argument("-t", "--type", type=str, default='h36m',
help='type of data to process')
parser.add_argument("-c", "--camera_id", type=int, default=None,
help='camera to extract')
parser.add_argument("-s", "--subject", type=str, default="S9",
help='subject to extract')
parser.add_argument("-r", "--res", type=float, default=1.0,
help='mask resolution')
parser.add_argument("--h5_path", type=str, default=None,
help='path to a .h5 file, mainly for MonPerfCap')
args = parser.parse_args()
base_path = args.base_path #"data/h36m/h36m_full"
#if args.h5_path is None:
if args.type == 'h36m':
subject = args.subject # "S9"
camera_id = args.camera_id # -1
cameras = ["54138969", "55011271", "58860488", "60457274"]
camera = None
if camera_id is not None:
camera = cameras[camera_id]
if subject != 'S1':
h5_name = os.path.join(base_path, f"{subject}-camera=[{camera}]-subsample=5.h5")
else:
h5_name = os.path.join(base_path, f"{subject}-camera=[{camera}]-subsample=1.h5")
else:
h5_name = os.path.join(base_path, f"{subject}_SPIN_rect_output-maxmin.h5")
print(h5_name)
img_paths = dd.io.load(h5_name, "/img_path")
bboxes = dd.io.load(h5_name, "/bbox_params")
img_paths = [os.path.join(base_path, img_path) for img_path in img_paths]
mask_paths = [img_path.replace(f"{subject}", f"{subject}m_") for img_path in img_paths]
#process_masks(img_paths, mask_paths, res=args.res)
#process_masks(img_paths, mask_paths)
process_bbox_masks(img_paths, mask_paths, bboxes, mul=1.1)
"""
cameras = ["54138969", "55011271", "58860488", "60457274"]
base_path = args.base_path
subject = args.subject
h5_name = os.path.join(base_path, f"{subject}_processed.h5")
img_paths = dd.io.load(h5_name, "/img_path")
img_paths = [os.path.join(base_path, img_path) for img_path in img_paths]
mask_paths = [img_path.replace(f"{subject}", f"{subject}m") for img_path in img_paths]
process_masks(img_paths, mask_paths, res=args.res)
"""
elif args.type == 'perfcap':
from load_perfcap import read_spin_data
processed_est = read_spin_data(args.h5_path)
img_paths = processed_est["img_path"]
img_paths = [os.path.join(args.base_path, img_path) for img_path in img_paths]
save_paths = [img_path.replace("/images/", "/masks/") for img_path in img_paths]
process_bbox_masks(img_paths, save_paths, processed_est["bboxes"])
elif args.type == '3dhp':
from load_3dhp import read_3dhp_spin_data
subject = args.subject # "S9"
processed_est = read_3dhp_spin_data(args.h5_path, subject=subject)
img_paths = processed_est["img_path"]
img_paths = [os.path.join(args.base_path, img_path) for img_path in img_paths]
save_paths = [img_path.replace("/imageSequence/", "/masks/") for img_path in img_paths]
process_bbox_masks(img_paths, save_paths, processed_est["bboxes"])
|
rest_api_models.py
|
Bariumm/Stocks-Pattern-Analyzer
| 136 |
55589
|
<filename>rest_api_models.py
from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel
class SuccessResponse(BaseModel):
message: str = "Successful"
class SearchWindowSizeResponse(BaseModel):
sizes: List[int]
class AvailableSymbolsResponse(BaseModel):
symbols: List[str]
class MatchResponse(BaseModel):
symbol: str
distance: float
start_date: str
end_date: str
todays_value: Optional[float]
future_value: Optional[float]
change: Optional[float]
values: Optional[List[float]]
class TopKSearchResponse(BaseModel):
matches: List[MatchResponse] = []
forecast_type: str
forecast_confidence: float
anchor_symbol: str
anchor_values: Optional[List[float]]
window_size: int
top_k: int
future_size: int
class DataRefreshResponse(BaseModel):
message: str = "Last (most recent) refresh"
date: datetime
class IsReadyResponse(BaseModel):
is_ready: bool
|
metrics/mahalanobis/mahalanobis.py
|
MitchellTesla/datasets
| 3,395 |
55593
|
# Copyright 2021 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Mahalanobis metric."""
import numpy as np
import datasets
_DESCRIPTION = """
Compute the Mahalanobis Distance
Mahalonobis distance is the distance between a point and a distribution.
And not between two distinct points. It is effectively a multivariate equivalent of the Euclidean distance.
It was introduced by Prof. <NAME> in 1936
and has been used in various statistical applications ever since
[source: https://www.machinelearningplus.com/statistics/mahalanobis-distance/]
"""
_CITATION = """\
@article{de2000mahalanobis,
title={The mahalanobis distance},
author={<NAME>, <NAME> <NAME> <NAME>{\'e}sir{\'e} L},
journal={Chemometrics and intelligent laboratory systems},
volume={50},
number={1},
pages={1--18},
year={2000},
publisher={Elsevier}
}
"""
_KWARGS_DESCRIPTION = """
Args:
X: List of datapoints to be compared with the `reference_distribution`.
reference_distribution: List of datapoints from the reference distribution we want to compare to.
Returns:
mahalanobis: The Mahalonobis distance for each datapoint in `X`.
Examples:
>>> mahalanobis_metric = datasets.load_metric("mahalanobis")
>>> results = mahalanobis_metric.compute(reference_distribution=[[0, 1], [1, 0]], X=[[0, 1]])
>>> print(results)
{'mahalanobis': array([0.5])}
"""
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
class Mahalanobis(datasets.Metric):
def _info(self):
return datasets.MetricInfo(
description=_DESCRIPTION,
citation=_CITATION,
inputs_description=_KWARGS_DESCRIPTION,
features=datasets.Features(
{
"X": datasets.Sequence(datasets.Value("float", id="sequence"), id="X"),
}
),
)
def _compute(self, X, reference_distribution):
# convert to numpy arrays
X = np.array(X)
reference_distribution = np.array(reference_distribution)
# Assert that arrays are 2D
if len(X.shape) != 2:
raise ValueError("Expected `X` to be a 2D vector")
if len(reference_distribution.shape) != 2:
raise ValueError("Expected `reference_distribution` to be a 2D vector")
if reference_distribution.shape[0] < 2:
raise ValueError(
"Expected `reference_distribution` to be a 2D vector with more than one element in the first dimension"
)
# Get mahalanobis distance for each prediction
X_minus_mu = X - np.mean(reference_distribution)
cov = np.cov(reference_distribution.T)
try:
inv_covmat = np.linalg.inv(cov)
except np.linalg.LinAlgError:
inv_covmat = np.linalg.pinv(cov)
left_term = np.dot(X_minus_mu, inv_covmat)
mahal_dist = np.dot(left_term, X_minus_mu.T).diagonal()
return {"mahalanobis": mahal_dist}
|
Core/third_party/JavaScriptCore/wasm/generateWasmB3IRGeneratorInlinesHeader.py
|
InfiniteSynthesis/lynx-native
| 677 |
55638
|
#!/usr/bin/env python
# Copyright (C) 2016 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:n
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# This tool has a couple of helpful macros to process Wasm files from the wasm.json.
from generateWasm import *
import optparse
import sys
import re
parser = optparse.OptionParser(usage="usage: %prog <wasm.json> <WasmOps.h>")
(options, args) = parser.parse_args(sys.argv[0:])
if len(args) != 3:
parser.error(parser.usage)
wasm = Wasm(args[0], args[1])
opcodes = wasm.opcodes
wasmB3IRGeneratorHFile = open(args[2], "w")
opcodeRegex = re.compile('([a-zA-Z0-9]+)')
argumentRegex = re.compile('(\@[0-9]+)')
decimalRegex = re.compile('([-]?[0-9]+)')
whitespaceRegex = re.compile('\s+')
commaRegex = re.compile('(,)')
oparenRegex = re.compile('(\()')
cparenRegex = re.compile('(\))')
class Source:
def __init__(self, contents, offset=0):
self.contents = contents
self.offset = offset
def read(regex, source):
match = regex.match(source.contents, source.offset)
if not match:
return None
source.offset = match.end()
return match.group()
def lex(source):
result = []
while source.offset != len(source.contents):
read(whitespaceRegex, source)
opcode = read(opcodeRegex, source)
if opcode:
result.append(opcode)
continue
argument = read(argumentRegex, source)
if argument:
result.append(argument)
continue
number = read(decimalRegex, source)
if number:
result.append(int(number))
continue
oparen = read(oparenRegex, source)
if oparen:
result.append(oparen)
continue
cparen = read(cparenRegex, source)
if cparen:
result.append(cparen)
continue
comma = read(commaRegex, source)
if comma:
# Skip commas
continue
raise Exception("Lexing Error: could not lex token from: " + source.contents + " at offset: " + str(source.offset) + " (" + source.contents[source.offset:] + "). With tokens: [" + ", ".join(result) + "]")
return result
class CodeGenerator:
def __init__(self, tokens):
self.tokens = tokens
self.index = 0
self.code = []
def advance(self):
self.index += 1
def token(self):
return self.tokens[self.index]
def parseError(self, string):
raise Exception("Parse error " + string)
def consume(self, string):
if self.token() != string:
self.parseError("Expected " + string + " but got " + self.token())
self.advance()
def generateParameters(self):
self.advance()
params = []
tokens = self.tokens
while self.index < len(tokens):
if self.token() == ")":
self.advance()
return params
params.append(self.generateOpcode())
self.parseError("Parsing arguments fell off end")
def generateOpcode(self):
result = None
if self.token() == "i32" or self.token() == "i64":
type = "Int32"
if self.token() == "i64":
type = "Int64"
self.advance()
self.consume("(")
self.code.append(generateConstCode(self.index, self.token(), type))
result = temp(self.index)
self.advance()
self.consume(")")
elif argumentRegex.match(self.token()):
result = "arg" + self.token()[1:]
self.advance()
else:
op = self.token()
index = self.index
self.advance()
params = self.generateParameters()
self.code.append(generateB3OpCode(index, op, params))
result = temp(index)
return result
def generate(self, wasmOp):
if len(self.tokens) == 1:
params = ["arg" + str(param) for param in range(len(wasmOp["parameter"]))]
return " result = m_currentBlock->appendNew<Value>(m_proc, B3::" + self.token() + ", origin(), " + ", ".join(params) + ")"
result = self.generateOpcode()
self.code.append("result = " + result)
return " " + " \n".join(self.code)
def temp(index):
return "temp" + str(index)
def generateB3OpCode(index, op, params):
return "Value* " + temp(index) + " = m_currentBlock->appendNew<Value>(m_proc, B3::" + op + ", origin(), " + ", ".join(params) + ");"
def generateConstCode(index, value, type):
return "Value* " + temp(index) + " = constant(" + type + ", " + value + ");"
def generateB3Code(wasmOp, source):
tokens = lex(Source(source))
parser = CodeGenerator(tokens)
return parser.generate(wasmOp)
def generateSimpleCode(op):
opcode = op["opcode"]
b3op = opcode["b3op"]
args = ["ExpressionType arg" + str(param) for param in range(len(opcode["parameter"]))]
args.append("ExpressionType& result")
return """
template<> auto B3IRGenerator::addOp<OpType::""" + wasm.toCpp(op["name"]) + ">(" + ", ".join(args) + """) -> PartialResult
{
""" + generateB3Code(opcode, b3op) + """;
return { };
}
"""
definitions = [generateSimpleCode(op) for op in wasm.opcodeIterator(lambda op: isSimple(op) and (isBinary(op) or isUnary(op)))]
contents = wasm.header + """
#pragma once
#if ENABLE(WEBASSEMBLY)
namespace JSC { namespace Wasm {
""" + "".join(definitions) + """
} } // namespace JSC::Wasm
#endif // ENABLE(WEBASSEMBLY)
"""
wasmB3IRGeneratorHFile.write(contents)
wasmB3IRGeneratorHFile.close()
|
tafl/pitTafl.py
|
user01/alpha-zero-general
| 2,836 |
55682
|
<filename>tafl/pitTafl.py<gh_stars>1000+
# Note: Run this file from Arena directory (the one above /tafl)
import Arena
from MCTS import MCTS
from tafl.TaflGame import TaflGame, display
from tafl.TaflPlayers import *
#from tafl.keras.NNet import NNetWrapper as NNet
import numpy as np
from utils import *
"""
use this script to play any two agents against each other, or play manually with
any agent.
"""
g = TaflGame("Brandubh")
# all players
rp = RandomTaflPlayer(g).play
gp = GreedyTaflPlayer(g).play
hp = HumanTaflPlayer(g).play
# nnet players
#n1 = NNet(g)
#n1.load_checkpoint('./pretrained_models/tafl/keras/','6x100x25_best.pth.tar')
#args1 = dotdict({'numMCTSSims': 50, 'cpuct':1.0})
#mcts1 = MCTS(g, n1, args1)
#n1p = lambda x: np.argmax(mcts1.getActionProb(x, temp=0))
arena = Arena.Arena(hp, gp, g, display=display)
#arena = Arena.Arena(gp, rp, g, display=display)
print(arena.playGames(2, verbose=True))
|
1000-1100q/1044.py
|
rampup01/Leetcode
| 990 |
55684
|
'''
Given a string S, consider all duplicated substrings: (contiguous) substrings of S that occur 2 or more times. (The occurrences may overlap.)
Return any duplicated substring that has the longest possible length. (If S does not have a duplicated substring, the answer is "".)
Example 1:
Input: "banana"
Output: "ana"
Example 2:
Input: "abcd"
Output: ""
Note:
2 <= S.length <= 10^5
S consists of lowercase English letters.
'''
class Suffix(object):
def __init__(self):
self.index = 0
self.first_rank = -1
self.adjacent_rank = -1
def __lt__(self, other):
if self.first_rank == other.first_rank:
return self.adjacent_rank < other.adjacent_rank
return self.first_rank < other.first_rank
def create_suffix_array(s):
N = len(s)
suffix_array = []
for index, char in enumerate(s):
suffix_obj = Suffix()
suffix_obj.index = index
suffix_obj.first_rank = ord(char)-ord('a')
suffix_obj.adjacent_rank = ord(s[index+1])-ord('a') if (index+1 < N) else -1
suffix_array.append(suffix_obj)
suffix_array.sort()
no_char = 4
index_map = {}
while no_char < 2*N:
rank = 0
prev_rank, suffix_array[0].first_rank = suffix_array[0].first_rank, rank
index_map[suffix_array[0].index] = 0
for index in range(1, N):
if suffix_array[index].first_rank == prev_rank and suffix_array[index].adjacent_rank == suffix_array[index-1].adjacent_rank:
suffix_array[index].first_rank = rank
else:
rank += 1
prev_rank, suffix_array[index].first_rank = suffix_array[index].first_rank, rank
index_map[suffix_array[index].index] = index
for index in range(N):
adjacent_index = suffix_array[index].index + (no_char/2)
suffix_array[index].adjacent_rank = suffix_array[index_map[adjacent_index]] if adjacent_index < N else -1
suffix_array.sort()
no_char *= 2
return [suffix.index for suffix in suffix_array]
def lcp_w_suffix_str(array, s):
N = len(array)
lcp_array = [0]*N
inv_suffix = [0]*N
for index in range(N):
inv_suffix[array[index]] = index
maxLen = 0
for index in range(N):
if inv_suffix[index] == N-1:
maxLen = 0
continue
index_j = array[inv_suffix[index]+1]
while(index+maxLen < N and index_j+maxLen < N and s[index+maxLen] == s[index_j+maxLen]):
maxLen += 1
lcp_array[inv_suffix[index]] = maxLen
if maxLen > 0:
maxLen -= 1
return lcp_array
class Solution(object):
def longestDupSubstring(self, S):
"""
:type S: str
:rtype: str
"""
suffix_array = create_suffix_array(S)
lcp_array = lcp_w_suffix_str(suffix_array, S)
start, end = 0, 0
for index in range(len(S)):
if lcp_array[index] > end:
end = lcp_array[index]
start = suffix_array[index]
if end == 0:
return ""
# print start, end
return S[start:start+end]
|
rls/nn/mixers/qatten.py
|
StepNeverStop/RLs
| 371 |
55729
|
import numpy as np
import torch as th
import torch.nn as nn
from rls.nn.mlps import MLP
from rls.nn.represent_nets import RepresentationNetwork
class QattenMixer(nn.Module):
def __init__(self,
n_agents: int,
state_spec,
rep_net_params,
agent_own_state_size: bool,
query_hidden_units: int,
query_embed_dim: int,
key_embed_dim: int,
head_hidden_units: int,
n_attention_head: int,
constrant_hidden_units: int,
is_weighted: bool = True):
super().__init__()
self.n_agents = n_agents
self.rep_net = RepresentationNetwork(obs_spec=state_spec,
rep_net_params=rep_net_params)
self.u_dim = agent_own_state_size # TODO: implement this
self.query_embed_dim = query_embed_dim
self.key_embed_dim = key_embed_dim
self.n_attention_head = n_attention_head
self.is_weighted = is_weighted
self.query_embedding_layers = nn.ModuleList()
self.key_embedding_layers = nn.ModuleList()
for i in range(self.n_attention_head):
self.query_embedding_layers.append(MLP(input_dim=self.rep_net.h_dim, hidden_units=query_hidden_units,
layer='linear', act_fn='relu', output_shape=query_embed_dim))
self.key_embedding_layers.append(
nn.Linear(self.u_dim, self.key_embed_dim))
self.scaled_product_value = np.sqrt(self.query_embed_dim)
self.head_embedding_layer = MLP(input_dim=self.rep_net.h_dim, hidden_units=head_hidden_units,
layer='linear', act_fn='relu', output_shape=n_attention_head)
self.constrant_value_layer = MLP(input_dim=self.rep_net.h_dim, hidden_units=constrant_hidden_units,
layer='linear', act_fn='relu', output_shape=1)
def forward(self, q_values, state, **kwargs):
"""
params:
q_values: [T, B, 1, N]
state: [T, B, *]
"""
time_step = q_values.shape[0] # T
batch_size = q_values.shape[1] # B
# state: [T, B, *]
state_feat, _ = self.rep_net(state, **kwargs) # [T, B, *]
us = self._get_us(state_feat) # [T, B, N, *]
q_lambda_list = []
for i in range(self.n_attention_head):
state_embedding = self.query_embedding_layers[i](
state_feat) # [T, B, *]
u_embedding = self.key_embedding_layers[i](us) # [T, B, N, *]
state_embedding = state_embedding.unsqueeze(-2) # [T, B, 1, *]
u_embedding = u_embedding.swapaxes(-1, -2) # [T, B, *, N]
raw_lambda = (state_embedding @ u_embedding) / \
self.scaled_product_value # [T, B, 1, N]
q_lambda = raw_lambda.softmax(dim=-1) # [T, B, 1, N]
q_lambda_list.append(q_lambda) # H * [T, B, 1, N]
q_lambda_list = th.cat(q_lambda_list, dim=-2) # [T, B, H, N]
q_lambda_list = q_lambda_list.swapaxes(-1, -2) # [T, B, N, H]
q_h = q_values @ q_lambda_list # [T, B, 1, H]
if self.is_weighted:
# shape: [-1, n_attention_head, 1]
w_h = th.abs(self.head_embedding_layer(state_feat)) # [T, B, H]
w_h = w_h.unsqueeze(-1) # [T, B, H, 1]
sum_q_h = q_h @ w_h # [T, B, 1, 1]
sum_q_h = sum_q_h.view(time_step, batch_size, 1) # [T, B, 1]
else:
sum_q_h = q_h.sum(-1) # [T, B, 1]
c = self.constrant_value_layer(state_feat) # [T, B, 1]
q_tot = sum_q_h + c # [T, B, 1]
return q_tot
def _get_us(self, state_feat):
time_step = state_feat.shape[0] # T
batch_size = state_feat.shape[1] # B
agent_own_state_size = self.u_dim
with th.no_grad():
us = state_feat[:, :, :agent_own_state_size * self.n_agents].view(
time_step, batch_size, self.n_agents, agent_own_state_size) # [T, B, N, *]
return us
|
runtime/stdlib/json.py
|
cheery/lever
| 136 |
55760
|
<filename>runtime/stdlib/json.py
## Just the JSON decoder, because I only need a decoder for now.
#from rpython.rlib.unicodedata import unicodedb_6_2_0 as unicodedb
from rpython.rlib.listsort import make_timsort_class
from rpython.rlib import rfile
from rpython.rlib.rstring import UnicodeBuilder
from rpython.rlib.objectmodel import specialize, always_inline
from space import *
from space import numbers
from stdlib import fs
import space
import pathobj
import os
module = Module(u'json', {}, frozen=True)
def builtin(deco):
def _deco_(fn):
name = fn.__name__.rstrip('_').decode('utf-8')
module.setattr_force(name, Builtin(deco(fn), name))
return fn
return _deco_
@builtin(signature(Object, Object, Dict, optional=1))
def write_file(pathname, obj, config):
name = pathobj.os_stringify(pathname).encode('utf-8')
try:
fd = rfile.create_file(name, "wb")
try:
# TODO: sort of defeats the purpose of
# incremental encoder.
fd.write(configured_stringify(obj, config).encode('utf-8'))
fd.write('\n')
finally:
fd.close()
except IOError as error:
message = os.strerror(error.errno).decode('utf-8')
raise OldError(u"%s: %s" % (pathobj.stringify(pathname), message))
return null
@builtin(signature(Object, Dict, optional=1))
def write_string(obj, config):
return space.String(configured_stringify(obj, config))
def configured_stringify(obj, config):
if config is None:
ub = UnicodeBuilder()
quick_stringify(ub, obj)
return ub.build()
margin = space.to_int(get_config(config, u"margin", space.Integer(80)))
scan = Scanner(Printer(margin))
scan.indent = space.to_int(get_config(config, u"indent", space.Integer(2)))
scan.sort_keys = space.is_true(get_config(config, u"sort_keys", space.false))
stringify(scan, obj)
scan.finish()
return scan.printer.result.build()
def get_config(config, text, default):
return config.data.get(space.String(text), default)
def quick_stringify(ub, obj):
if isinstance(obj, space.Dict):
ub.append(u"{")
more = False
for key, value in obj.data.iteritems():
if not isinstance(key, String):
raise unwind(LError(
u"json supports only strings as keys: "
+ key.repr()))
if more:
ub.append(u",")
ub.append(escape_string(key.string))
ub.append(u':')
quick_stringify(ub, value)
more = True
ub.append(u"}")
elif isinstance(obj, space.List):
ub.append(u"[")
more = False
for item in obj.contents:
if more:
ub.append(u",")
quick_stringify(ub, item)
more = True
ub.append(u"]")
elif isinstance(obj, space.String):
ub.append(escape_string(obj.string))
elif isinstance(obj, space.Integer):
ub.append(numbers.integer_to_string(obj.value, 10))
elif isinstance(obj, space.Float):
ub.append(numbers.float_to_string(obj.number))
elif obj is space.null:
ub.append(u"null")
elif obj is space.true:
ub.append(u"true")
elif obj is space.false:
ub.append(u"false")
else:
raise unwind(LError(u"no handler for: " + obj.repr()))
def stringify(scan, obj):
if isinstance(obj, space.Dict):
scan.left().text(u"{").blank(u"", scan.indent)
more = False
if scan.sort_keys:
pairs = []
for key, value in obj.data.iteritems():
if not isinstance(key, String):
raise unwind(LError(
u"json supports only strings as keys: "
+ key.repr()))
pairs.append((key, value))
sorter = JSONKeySort(pairs, len(pairs))
sorter.sort()
for key, value in sorter.list:
if more:
scan.text(u",").blank(u" ", scan.indent)
scan.left()
scan.text(escape_string(key.string)+u': ')
stringify(scan, value)
scan.right()
more = True
else:
for key, value in obj.data.iteritems():
if not isinstance(key, String):
raise unwind(LError(
u"json supports only strings as keys: "
+ key.repr()))
if more:
scan.text(u",").blank(u" ", scan.indent)
scan.left()
scan.text(escape_string(key.string)+u': ')
stringify(scan, value)
scan.right()
more = True
scan.blank(u"", 0).text(u"}").right()
elif isinstance(obj, space.List):
scan.left().text(u"[").blank(u"", scan.indent)
more = False
for item in obj.contents:
if more:
scan.text(u",").blank(u" ", scan.indent)
stringify(scan, item)
more = True
scan.blank(u"", 0).text(u"]").right()
elif isinstance(obj, space.String):
scan.text(escape_string(obj.string))
elif isinstance(obj, space.Integer):
scan.text(numbers.integer_to_string(obj.value, 10))
elif isinstance(obj, space.Float):
scan.text(numbers.float_to_string(obj.number))
elif obj is space.null:
scan.text(u"null")
elif obj is space.true:
scan.text(u"true")
elif obj is space.false:
scan.text(u"false")
else:
raise unwind(LError(u"no handler for: " + obj.repr()))
TimSort = make_timsort_class()
class JSONKeySort(TimSort):
def lt(self, a, b):
return a[0].string < b[0].string
# This is the easiest point of failure in your stringifier program.
def escape_string(string):
out = UnicodeBuilder()
out.append(u'"')
for ch in string:
n = ord(ch)
if 0x20 <= n and n <= 0x7E or 0xFF < n: # remove the last part in cond if you don't want
if ch == u'\\': # unicode printed out for some reason.
ch = u'\\\\'
elif ch == u'"':
ch = u'\\"'
else:
a = u"0123456789abcdef"[n >> 12]
b = u"0123456789abcdef"[n >> 8 & 15]
c = u"0123456789abcdef"[n >> 4 & 15]
d = u"0123456789abcdef"[n & 15]
ch = u'u' + a + b + c + d
ch = u'\\' + character_escapes.get(n, ch)
out.append(ch)
out.append(u'"')
return out.build()
character_escapes = {8: u'b', 9: u't', 10: u'n', 12: u'f', 13: u'r'}
# The scanner runs three line widths before the printer and checks how many
# spaces the blanks and groups take. This allows the printer determine
# whether the line or grouping should be broken into multiple lines.
class Scanner(object):
def __init__(self, printer):
self.printer = printer
self.stream = []
self.stack = []
self.lastblank = None
self.left_total = 1
self.right_total = 1 # makes sure we won't treat the first
# item differently than others.
self.sort_keys = False
self.indent = 2
def left(self):
return self.scan(Left())
def right(self):
return self.scan(Right())
def blank(self, text, indent):
return self.scan(Blank(text, indent))
def text(self, text):
return self.scan(Text(text))
def scan(self, x):
if isinstance(x, Left):
x.size = -self.right_total
self.stack.append(x)
elif isinstance(x, Right):
if len(self.stack) > 0:
self.stack.pop().size += self.right_total
elif isinstance(x, Blank):
if self.lastblank is not None:
self.lastblank.size += self.right_total
self.lastblank = x
x.size = -self.right_total
self.right_total += len(x.text)
elif isinstance(x, Text):
self.right_total += len(x.text)
self.stream.append(x)
while len(self.stream) > 0 and self.right_total - self.left_total > 3*self.printer.margin:
self.left_total += self.printer.scan(self.stream.pop(0))
return self
def finish(self):
if self.lastblank is not None: # Well.. of course.
self.lastblank.size += self.right_total # I didn't figure this out earlier.
while len(self.stream) > 0:
self.printer.scan(self.stream.pop(0))
# Printer keeps the track of layout during printing.
class Printer:
def __init__(self, margin):
self.margin = margin
self.layout = Layout(None, margin, False)
self.spaceleft = margin
self.spaces = margin
self.result = UnicodeBuilder()
def scan(self, x):
if isinstance(x, Left):
self.layout = Layout(self.layout,
self.spaces, x.size < 0 or self.spaceleft < x.size)
elif isinstance(x, Right):
if self.layout.parent:
self.layout = self.layout.parent
elif isinstance(x, Blank):
if x.size < 0 or self.spaceleft < x.size or self.layout.force_break:
self.spaces = self.layout.spaces - x.indent
self.spaceleft = self.spaces
self.result.append(u'\n' + u' '*(self.margin - self.spaces))
else:
self.result.append(x.text)
self.spaceleft -= len(x.text)
elif isinstance(x, Text):
self.result.append(x.text)
self.spaceleft -= len(x.text)
return len(x)
# These small objects are scanner and printer internals.
class Layout(object):
def __init__(self, parent, spaces, force_break):
self.parent = parent
self.spaces = spaces
self.force_break = force_break
# These objects are mutated by the scanner, so they cannot be
# reused. Users of the pretty printer should not create them themselves.
class ScannerToken:
def __len__(self):
return 0
class Text(ScannerToken):
def __init__(self, text):
self.text = text
def __len__(self):
return len(self.text)
class Left(ScannerToken):
def __init__(self):
self.size = 0
class Right(ScannerToken):
pass
class Blank(ScannerToken):
def __init__(self, text, indent=0):
self.text = text
self.indent = indent
self.size = 0
def __len__(self):
return len(self.text)
@builtin(signature(Object))
def read_file(path):
sobj = fs.read_file([path])
assert isinstance(sobj, String)
return read_string(sobj)
@builtin(signature(String))
def read_string(string):
stack = []
ctx = ParserContext()
state = 0x00
for ch in string.string:
cat = catcode[min(ord(ch), 0x7E)]
state = parse_char(cat, ch, stack, state, ctx)
state = parse_char(catcode[32], u' ', stack, state, ctx)
if state != 0x00:
raise unwind(LError(u"JSON decode error: truncated"))
if len(ctx.ds) != 1:
raise unwind(LError(u"JSON decode error: too many objects"))
return ctx.ds.pop()
class ParserContext:
def __init__(self):
self.ds = [] # data stack
self.ss = UnicodeBuilder() # string stack
self.es = UnicodeBuilder() # escape stack
@always_inline
def parse_char(cat, ch, stack, state, ctx):
while True:
code = states[state][cat]
action = code >> 8 & 0xFF
code = code & 0xFF
if action == 0xFF and code == 0xFF:
raise unwind(LError(u"JSON decode error: syntax"))
elif action >= 0x80: # shift
stack.append(gotos[state])
action -= 0x80
if action > 0:
decode_json(action, ch, ctx)
if code == 0xFF:
state = stack.pop()
else:
state = code
return state
@always_inline
def decode_json(action, ch, ctx):
if action == 0x1: # push list
ctx.ds.append(space.List([]))
# Push object to ds
elif action == 0x2: # push object
ctx.ds.append(space.Dict())
elif action == 0x3: # pop & append
val = ctx.ds.pop()
top = ctx.ds[len(ctx.ds)-1]
assert isinstance(top, List) # we can trust this.
top.contents.append(val)
elif action == 0x4: # pop pop & setitem
val = ctx.ds.pop()
key = ctx.ds.pop()
top = ctx.ds[len(ctx.ds)-1]
assert isinstance(top, Dict) # again..
top.data[key] = val
elif action == 0x5: # push null
ctx.ds.append(space.null)
elif action == 0x6: # push true
ctx.ds.append(space.true)
elif action == 0x7: # push false
ctx.ds.append(space.false)
elif action == 0x8: # push string
val = ctx.ss.build()
ctx.ds.append(space.String(val))
ctx.ss = UnicodeBuilder()
ctx.es = UnicodeBuilder()
elif action == 0x9:
val = int(ctx.ss.build().encode('utf-8')) # push int
ctx.ds.append(space.Integer(val))
ctx.ss = UnicodeBuilder()
elif action == 0xA:
val = float(ctx.ss.build().encode('utf-8')) # push float
ctx.ds.append(space.Float(val))
ctx.ss = UnicodeBuilder()
elif action == 0xB: # push ch to ss
ctx.ss.append(ch)
elif action == 0xC: # push ch to es
ctx.es.append(ch)
elif action == 0xD: # push escape
ctx.ss.append(unichr(escape_characters[ch]))
elif action == 0xE: # push unicode point
ctx.ss.append(unichr(int(ctx.es.build().encode('utf-8'), 16)))
ctx.es = UnicodeBuilder()
else: # This is very unlikely to happen.
assert False, "JSON decoder bug"
# Non-trivial escape characters. At worst you can
# 'switch' or 'if/else' them into do_action -function.
escape_characters = {'b': 8, 't': 9, 'n': 10, 'f': 12, 'r': 13}
# generated by build_tables.py program: http://github.com/cheery/json_algorithm
states = [
[ 0xffff, 0x0000, 0x801a, 0xffff, 0xffff, 0x8b29, 0xffff, 0xffff, 0x8b28, 0x8b22, 0xffff, 0xffff, 0xffff, 0x810e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x8009, 0xffff, 0x8001, 0xffff, 0xffff, 0x8005, 0xffff, 0x8212, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0002, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0003, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0004, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, 0x05ff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0006, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0007, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0008, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, 0x06ff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x000a, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x000b, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x000c, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x000d, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, 0x07ff, ],
[ 0xffff, 0x000e, 0x801a, 0xffff, 0xffff, 0x8b29, 0xffff, 0xffff, 0x8b28, 0x8b22, 0xffff, 0xffff, 0xffff, 0x810e, 0xffff, 0x0011, 0xffff, 0xffff, 0xffff, 0x8009, 0xffff, 0x8001, 0xffff, 0xffff, 0x8005, 0xffff, 0x8212, 0xffff, ],
[ 0xffff, 0x000f, 0xffff, 0xffff, 0x0310, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0311, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0x0010, 0x801a, 0xffff, 0xffff, 0x8b29, 0xffff, 0xffff, 0x8b28, 0x8b22, 0xffff, 0xffff, 0xffff, 0x810e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x8009, 0xffff, 0x8001, 0xffff, 0xffff, 0x8005, 0xffff, 0x8212, 0xffff, ],
[ 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, ],
[ 0xffff, 0x0012, 0x801a, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0019, ],
[ 0xffff, 0x0013, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0014, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0x0014, 0x801a, 0xffff, 0xffff, 0x8b29, 0xffff, 0xffff, 0x8b28, 0x8b22, 0xffff, 0xffff, 0xffff, 0x810e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x8009, 0xffff, 0x8001, 0xffff, 0xffff, 0x8005, 0xffff, 0x8212, 0xffff, ],
[ 0xffff, 0x0015, 0xffff, 0xffff, 0x0416, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0419, ],
[ 0xffff, 0x0016, 0x801a, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0x0017, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0018, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0x0018, 0x801a, 0xffff, 0xffff, 0x8b29, 0xffff, 0xffff, 0x8b28, 0x8b22, 0xffff, 0xffff, 0xffff, 0x810e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x8009, 0xffff, 0x8001, 0xffff, 0xffff, 0x8005, 0xffff, 0x8212, 0xffff, ],
[ 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, 0x00ff, ],
[ 0x0b1a, 0x0b1a, 0x0021, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x001b, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, 0x0b1a, ],
[ 0xffff, 0xffff, 0x0b1a, 0xffff, 0xffff, 0xffff, 0xffff, 0x0b1a, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0b1a, 0xffff, 0xffff, 0x0d1a, 0xffff, 0x0d1a, 0xffff, 0x0d1a, 0x0d1a, 0xffff, 0x0d1a, 0x801c, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0c1d, 0x0c1d, 0xffff, 0x0c1d, 0x0c1d, 0xffff, 0xffff, 0xffff, 0x0c1d, 0x0c1d, 0x0c1d, 0x0c1d, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0c1e, 0x0c1e, 0xffff, 0x0c1e, 0x0c1e, 0xffff, 0xffff, 0xffff, 0x0c1e, 0x0c1e, 0x0c1e, 0x0c1e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0c1f, 0x0c1f, 0xffff, 0x0c1f, 0x0c1f, 0xffff, 0xffff, 0xffff, 0x0c1f, 0x0c1f, 0x0c1f, 0x0c1f, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0c20, 0x0c20, 0xffff, 0x0c20, 0x0c20, 0xffff, 0xffff, 0xffff, 0x0c20, 0x0c20, 0x0c20, 0x0c20, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, 0x0eff, ],
[ 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, 0x08ff, ],
[ 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x0b23, 0x09ff, 0x0b22, 0x0b22, 0x09ff, 0x09ff, 0x0b25, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x0b25, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0b24, 0x0b24, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0b24, 0x0b24, 0x0aff, 0x0aff, 0x0b25, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0b25, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, ],
[ 0xffff, 0xffff, 0xffff, 0x0b26, 0xffff, 0x0b26, 0xffff, 0xffff, 0x0b27, 0x0b27, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0b27, 0x0b27, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
[ 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0b27, 0x0b27, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, 0x0aff, ],
[ 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x0b23, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x0b25, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x0b25, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, 0x09ff, ],
[ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0b28, 0x0b22, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ],
]
gotos = [0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 15, 255, 15, 255, 19, 255, 21, 255, 23, 255, 21, 255, 255, 26, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255]
catcode = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 6, 7, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 0, 0, 0, 0, 0, 0, 11, 11, 11, 11, 12, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 15, 0, 0, 0, 16, 17, 11, 11, 18, 19, 0, 0, 0, 0, 0, 20, 0, 21, 0, 0, 0, 22, 23, 24, 25, 0, 0, 0, 0, 0, 26, 0, 27, 0]
|
sergeant/encoder/compressor/__init__.py
|
adir-intsights/sergeant
| 152 |
55796
|
from . import _compressor
from . import bzip2
from . import gzip
from . import lzma
from . import zlib
|
src/python/makeGraphs.py
|
neoremind/luceneutil
| 164 |
55817
|
<reponame>neoremind/luceneutil
import responseTimeGraph
import loadGraphActualQPS
import sys
import re
import os
reQPS = re.compile(r'\.qps([\.0-9]+)(\.|$)')
rePCT = re.compile(r'\.pct([\.0-9]+)$')
def main(maxQPS = None):
logsDir = sys.argv[1]
warmupSec = int(sys.argv[2])
reportsDir = sys.argv[3]
if maxQPS is None:
if os.path.exists(reportsDir):
print 'ERROR: please move existing reportsDir (%s) out of the way' % reportsDir
sys.exit(1)
print 'getInterpValue: list=%s interpDate=%s' % (valueList, interpDate)
os.makedirs(reportsDir)
qps = set()
names = set()
byName = {}
byPCT = {}
for f in os.listdir(logsDir):
m = reQPS.search(f)
if m is not None:
qpsString = m.group(1)
qpsValue = float(qpsString)
if False and qpsValue > 200:
continue
qps.add((qpsValue, qpsString))
name = f[:f.find('.qps')]
# nocommit
if name.find('G1') != -1:
continue
if name.lower().find('warmup') == -1:
names.add(name)
if not name in byName:
byName[name] = []
byName[name].append((qpsValue, qpsString, f))
m = rePCT.search(f)
if m is not None:
pct = int(m.group(1))
if pct not in byPCT:
byPCT[pct] = []
byPCT[pct].append((name, qpsValue, qpsString, f))
if len(names) == 0:
raise RuntimeError('no logs found @ %s' % logsDir)
if False:
for name, l in byName.items():
l.sort()
for idx, (qpsS, qps, dirName) in enumerate(l):
if dirName.find('.pct') == -1:
os.rename('%s/%s' % (logsDir, dirName),
'%s/%s.pct%s' % (logsDir, dirName, pcts[idx]))
print '%s -> %s' % (name, l)
if maxQPS is None:
indexOut = open('%s/index.html' % reportsDir, 'wb')
else:
indexOut = open('%s/index.html' % reportsDir, 'ab')
indexOut.write('\n<br>')
w = indexOut.write
names = list(names)
names.sort()
try:
if maxQPS is None:
w('<h2>By QPS:</h2>')
if len(byPCT) != 0:
l = list(byPCT.keys())
l.sort()
# Collate by PCT:
for idx, pct in enumerate(l):
# Sort by name so we get consistent colors:
l2 = byPCT[pct]
l2.sort()
d = []
for name, qpsValue, qpsString, resultsFile in l2:
d.append(('%s.qps%s' % (name, qpsString), '%s/%s/results.bin' % (logsDir, resultsFile)))
if len(d) == 0:
raise RuntimeError('nothing matches pct=%d' % pct)
print
print 'Create response-time graph @ pct=%d: d=%s' % (pct, d)
if len(d) != 0:
try:
html = responseTimeGraph.createGraph(d, warmupSec, title='Query time at %d%% load' % pct)
except IndexError:
raise
fileName = '%s/responseTime%sPCT.html' % (reportsDir, pct)
open(fileName, 'wb').write(html)
w('<a href="%s">at %d%% load</a>' % (fileName, pct))
w('<br>\n')
else:
# Collate by QPS:
l = list(qps)
l.sort()
for idx, (qps, qpsString) in enumerate(l):
d = []
validNames = []
for name in names:
resultsFile = '%s/%s.qps%s/results.bin' % (logsDir, name, qpsString)
if os.path.exists(resultsFile):
d.append(('%s.qps%s' % (name, qpsString), resultsFile))
validNames.append(name)
if len(d) == 0:
#raise RuntimeError('nothing matches qps=%s' % qpsString)
continue
print
print 'Create response-time graph @ qps=%s: d=%s' % (qps, d)
if len(d) != 0:
try:
html = responseTimeGraph.createGraph(d, warmupSec)
except IndexError:
raise
open('%s/%sqps.html' % (reportsDir, qpsString), 'wb').write(html)
w('<a href="%sqps.html">%d queries/sec [%s]</a>' % (qpsString, qps, ', '.join(responseTimeGraph.cleanName(x) for x in validNames)))
w('<br>\n')
if maxQPS is None:
w('<h2>By percentile:</h2>')
else:
w('<h2>By percentile (max QPS %d):</h2>' % maxQPS)
allPassesSLA = None
for idx in xrange(len(loadGraphActualQPS.logPoints)):
print
print 'Create pct graph @ %s%%' % loadGraphActualQPS.logPoints[idx][0]
if maxQPS is not None:
fileName = 'load%spct_max%s.html' % (loadGraphActualQPS.logPoints[idx][0], maxQPS)
else:
fileName = 'load%spct.html' % (loadGraphActualQPS.logPoints[idx][0])
stop = False
try:
passesSLA, maxActualQPS = loadGraphActualQPS.graph(idx, logsDir, warmupSec, names, '%s/%s' % (reportsDir, fileName), maxQPS=maxQPS)
except RuntimeError:
stop = True
if passesSLA is not None:
if allPassesSLA is None:
allPassesSLA = passesSLA
else:
for x in list(allPassesSLA):
if x not in passesSLA:
allPassesSLA.remove(x)
if stop:
break
w('<a href="%s">%s %%</a>' % (fileName, loadGraphActualQPS.logPoints[idx][0]))
w('<br>\n')
fileName = '%s/loadmax.html' % reportsDir
passesSLA, maxActualQPS = loadGraphActualQPS.graph('max', logsDir, warmupSec, names, fileName, maxQPS=maxQPS)
if passesSLA is not None:
for x in list(allPassesSLA):
if x not in passesSLA:
allPassesSLA.remove(x)
highest = {}
for qps, name in allPassesSLA:
if name not in highest or qps > highest[name]:
highest[name] = qps
l = [(y, x) for x, y in highest.items()]
l.sort()
print
print 'Max actual QPS:'
for name, qps in maxActualQPS.items():
print ' %s: %.1f QPS' % (name, qps)
print
print 'Highest QPS w/ SLA met:'
for qps, name in l:
print ' %s: %s QPS' % (responseTimeGraph.cleanName(name), qps)
w('<a href="loadmax.html">100%%</a>')
w('<br>')
finally:
indexOut.close()
if __name__ == '__main__':
if '-again' in sys.argv:
idx = sys.argv.index('-again')
maxQPS = int(sys.argv[1+idx])
del sys.argv[idx:idx+2]
else:
maxQPS = None
main()
if maxQPS is not None:
main(maxQPS)
|
grove/grove_sound_sensor.py
|
Mehmet-Erkan/grove.py
| 122 |
55840
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# The MIT License (MIT)
#
# Grove Base Hat for the Raspberry Pi, used to connect grove sensors.
# Copyright (C) 2018 Seeed Technology Co.,Ltd.
'''
This is the code for
- `Grove - Sound Sensor <https://www.seeedstudio.com/Grove-Sound-Sensor-p-752.html>`_
Examples:
.. code-block:: python
import time
from grove.grove_sound_sensor import GroveSoundSensor
# connect to alalog pin 2(slot A2)
PIN = 2
sensor = GroveSoundSensor(PIN)
print('Detecting sound...')
while True:
print('Sound value: {0}'.format(sensor.sound))
time.sleep(.3)
'''
import math
import time
from grove.adc import ADC
__all__ = ['GroveSoundSensor']
class GroveSoundSensor(object):
'''
Grove Sound Sensor class
Args:
pin(int): number of analog pin/channel the sensor connected.
'''
def __init__(self, channel):
self.channel = channel
self.adc = ADC()
@property
def sound(self):
'''
Get the sound strength value
Returns:
(int): ratio, 0(0.0%) - 1000(100.0%)
'''
value = self.adc.read(self.channel)
return value
Grove = GroveSoundSensor
def main():
from grove.helper import SlotHelper
sh = SlotHelper(SlotHelper.ADC)
pin = sh.argv2pin()
sensor = GroveSoundSensor(pin)
print('Detecting sound...')
while True:
print('Sound value: {0}'.format(sensor.sound))
time.sleep(.3)
if __name__ == '__main__':
main()
|
examples/ubercorn-rainbow-2x1.py
|
Robtom5/unicorn-hat-hd
| 157 |
55894
|
#!/usr/bin/env python
import colorsys
import math
import time
import unicornhathd
print("""Ubercorn rainbow 2x1
An example of how to use a 2-wide by 1-tall pair of Ubercorn matrices.
Press Ctrl+C to exit!
""")
unicornhathd.brightness(0.6)
# Enable addressing for Ubercorn matrices
unicornhathd.enable_addressing()
# Set up buffer shape to be 32 wide and 16 tall
unicornhathd.setup_buffer(32, 16)
# Set up display 0 on left, and display 1 on right
unicornhathd.setup_display(0, 0, 0, 0)
unicornhathd.setup_display(1, 16, 0, 0)
step = 0
try:
while True:
step += 1
for x in range(0, 32):
for y in range(0, 16):
dx = 7
dy = 7
dx = (math.sin(step / 20.0) * 15.0) + 7.0
dy = (math.cos(step / 15.0) * 15.0) + 7.0
sc = (math.cos(step / 10.0) * 10.0) + 16.0
h = math.sqrt(math.pow(x - dx, 2) + math.pow(y - dy, 2)) / sc
r, g, b = colorsys.hsv_to_rgb(h, 1, 1)
r *= 255.0
g *= 255.0
b *= 255.0
unicornhathd.set_pixel(x, y, r, g, b)
unicornhathd.show()
time.sleep(1.0 / 60)
except KeyboardInterrupt:
unicornhathd.off()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.