id
stringlengths 3
8
| content
stringlengths 100
981k
|
|---|---|
52915
|
import marbles.core
class ComplexTestCase(marbles.core.AnnotatedTestCase):
def test_for_edge_case(self):
self.assertTrue(False)
if __name__ == '__main__':
marbles.core.main()
|
52928
|
from secml.ml.features.normalization.tests import CNormalizerTestCases
from sklearn.preprocessing import StandardScaler
from secml.ml.features.normalization import CNormalizerMeanStd
class TestCNormalizerMeanStd(CNormalizerTestCases):
"""Unittests for CNormalizerMeanStd."""
def test_transform(self):
"""Test for `.transform()` method."""
for with_std in (True, False):
self.logger.info("Testing using std? {:}".format(with_std))
self._sklearn_comp(self.array_dense,
StandardScaler(with_std=with_std),
CNormalizerMeanStd(with_std=with_std))
self._sklearn_comp(self.array_sparse,
StandardScaler(with_std=with_std),
CNormalizerMeanStd(with_std=with_std))
self._sklearn_comp(self.row_dense.atleast_2d(),
StandardScaler(with_std=with_std),
CNormalizerMeanStd(with_std=with_std))
self._sklearn_comp(self.row_sparse,
StandardScaler(with_std=with_std),
CNormalizerMeanStd(with_std=with_std))
self._sklearn_comp(self.column_dense,
StandardScaler(with_std=with_std),
CNormalizerMeanStd(with_std=with_std))
self._sklearn_comp(self.column_sparse,
StandardScaler(with_std=with_std),
CNormalizerMeanStd(with_std=with_std))
def test_mean_std(self):
"""Test using specific mean/std."""
for (mean, std) in [(1.5, 0.1),
((1.0, 1.1, 1.2, 1.3), (0.0, 0.1, 0.2, 0.3))]:
for array in [self.array_dense, self.array_sparse]:
self.logger.info("Original array is:\n{:}".format(array))
self.logger.info(
"Normalizing using mean: {:} std: {:}".format(mean, std))
n = CNormalizerMeanStd(mean=mean, std=std).fit(array)
out = n.transform(array)
self.logger.info("Result is:\n{:}".format(out))
out_mean = out.mean(axis=0, keepdims=False)
out_std = out.std(axis=0, keepdims=False)
self.logger.info("Result mean is:\n{:}".format(out_mean))
self.logger.info("Result std is:\n{:}".format(out_std))
rev = n.inverse_transform(out)
self.assert_array_almost_equal(array, rev)
def test_chain(self):
"""Test a chain of preprocessors."""
self._test_chain(self.array_dense,
['min-max', 'pca', 'mean-std'],
[{'feature_range': (-5, 5)}, {}, {}])
def test_chain_gradient(self):
"""Check gradient of a chain of preprocessors."""
self._test_chain_gradient(self.array_dense,
['min-max', 'mean-std'],
[{'feature_range': (-5, 5)}, {}])
if __name__ == '__main__':
CNormalizerTestCases.main()
|
52969
|
from flask import Flask, request, jsonify
from sqlalchemy import create_engine
app = Flask(__name__)
engine = create_engine("mysql+pymysql://root:admin@db:3306/mydb")
@app.route("/members", methods=["POST"])
def members():
body = request.json
with engine.connect() as connection:
connection.execute("INSERT INTO members (name) VALUES (%s)", body["name"])
row = list(
connection.execute("SELECT * FROM members WHERE id=LAST_INSERT_ID()")
)[0]
return jsonify({"id": row.id, "name": row.name})
if __name__ == "__main__":
app.run(debug=True, host="0.0.0.0", port=8080)
|
53003
|
import os # system()
def can_build(env, platform):
if platform == "x11":
has_pulse = os.system("pkg-config --exists libpulse-simple") == 0
has_alsa = os.system("pkg-config --exists alsa") == 0
return has_pulse or has_alsa
elif platform in ["windows", "osx", "iphone", "android"]:
return True
else:
return False
def configure(env):
pass
def get_doc_classes():
return [
"STTConfig",
"STTQueue",
"STTRunner",
"STTError",
]
def get_doc_path():
return "doc"
|
53020
|
import urllib.request, urllib.parse, urllib.error
# http://www.py4e.com/code3/bs4.zip
# and unzip it in the same directory as this file
from urllib.request import urlopen
import re
from bs4 import BeautifulSoup
import ssl
import sqlite3
conn = sqlite3.connect('wiki2.sqlite')
cur = conn.cursor()
cur.executescript('''
CREATE TABLE IF NOT EXISTS dict (
word TEXT UNIQUE PRIMARY KEY
);
''')
fhand=''
comm = 0
#print(list_link)
#for link_T in list_link:
# print(link_T)
# Ignore SSL certificate errors
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
#url = input('Enter - ')
#html = urlopen(url, context=ctx).read()
# html.parser is the HTML parser included in the standard Python 3 library.
# information on other HTML parsers is here:
# http://www.crummy.com/software/BeautifulSoup/bs4/doc/#installing-a-parser
#soup = BeautifulSoup(html, "html.parser")
arr_junk =['http:','https:','/','<','>','=','1','2','3','4','5','6','7','8','9','0','\'','\"','}','{',']','[','(',')',':','-','+','!','~','|','\\','*','?',';','_','.','#','$','@','%','^','&','`']
cdummy = 0
dummy = 0
for i in range(100000):
list_link = cur.execute(''' SELECT link FROM data where flag = ?''',(1,))
for tlink in list_link:
print(tlink)
tlink1 = ''.join(tlink)
print(tlink1)
dummy = 0
try:
fhand = urllib.request.urlopen(tlink1)
dummy = 1
except:
print("Sorry Link cannot be opened!",tlink1)
cur.execute('''UPDATE data SET flag = 2 WHERE link = ?''',(tlink1,))
continue
if dummy == 1: #link extracted sucessfully
print("Extracting words in the link .... : ",tlink1)
for line in fhand:
big_junk=line.decode().strip().split(' ')
for junk in big_junk:
flag=1
for needle in arr_junk:
if needle in junk:
flag=0
continue
if ',' in junk:
com_pos = junk.find(',') # comma postion
ext_wrd = junk[:com_pos] # to extract word
else:
ext_wrd = junk
if flag==1:
#commit_Var = commit_Var + 1
if ext_wrd != '':
#print(ext_wrd)
ex_wrd_l = ext_wrd.lower()
print(ex_wrd_l)
cur.execute('''INSERT OR IGNORE INTO dict (word)
VALUES ( ? )''', ( ex_wrd_l, ) )
cur.execute('''UPDATE data SET flag = 2 WHERE link = ?''',(tlink1,))
cdummy = cdummy + 1
if cdummy % 20 == 0:
conn.commit()
conn.commit()
#print("Var comm = ",comm)
|
53029
|
from . import core
import io
import re
import requests
import pytz
import time
import datetime as dt
import dateutil.parser as du
import numpy as np
import pandas as pd
from typing import Tuple, Dict, List, Union, ClassVar, Any, Optional, Type
import types
class AccessModeInQuery(core.API):
# Enumeration class to list available API access modes.
NONE = 'n/a';
DOWNLOAD = 'download';
CHART = 'chart';
DEFAULT = 'download';
class EventsInQuery(core.API):
"""
Enumeration class to list the 'events' that is possible to request.
"""
NONE = '';
HISTORY = 'history';
DIVIDENDS = 'div';
SPLITS = 'split';
class Query():
"""
Class that encodes the request parameters into a query.
It provides methods to set such parameters
as well as to validate them in accordance to the Yahoo Finance API expected arguments.
"""
__events__:ClassVar[List[str]] = ["history", "split", "div"];
__chart_range__:ClassVar[List[str]] = ["1d", "5d", "1mo", "3mo", "6mo", "1y", "2y", "5y", "10y", "ytd", "max"];
__chart_interval__:ClassVar[List[str]] = ["1m", "2m", "5m", "15m", "30m", "60m", "90m", "1h", "1d", "5d", "1wk", "1mo", "3mo"];
__download_frequency__:ClassVar[List[str]] = ["1d", "1wk", "1mo"];
def __init__(self, using_api:Type[AccessModeInQuery]):
self.query:Dict[str,Optional[str]] = {};
self.__api__:AccessModeInQuery = using_api;
def __str__(self):
return "&".join([f"{param}={value}" for param, value in self.query.items() if value is not None]) if len(self.query)>0 else "";
def __len__(self):
return len(self.query);
def __bool__(self):
return True if len(self.query)>0 else False;
def SetEvents(self, events:Type[EventsInQuery]) -> None:
if not isinstance(events, EventsInQuery):
self.query['events'] = None;
raise TypeError(f"invalid type for the argument 'events'; <class 'EventsInQuery'> expected, got {type(events)}");
else:
if self.__api__ is AccessModeInQuery.CHART:
self.query['events'] = events if events not in [EventsInQuery.HISTORY, EventsInQuery.NONE] else None;
elif self.__api__ is AccessModeInQuery.DOWNLOAD:
self.query['events'] = events if events is not EventsInQuery.NONE else str(EventsInQuery.HISTORY);
else:
self.query['events'] = None;
raise ValueError(f"value of argument 'events' is not compatible with the given API '{str(self.__api__)}'");
def SetInterval(self, interval:str) -> None:
if not isinstance(interval, str):
self.query['interval'] = None;
raise TypeError(f"invalid type for the argument 'interval'; {type(str)} expected, got {type(interval)}");
else:
if (self.__api__ is AccessModeInQuery.CHART and interval in self.__chart_interval__) \
or (self.__api__ is AccessModeInQuery.DOWNLOAD and interval in self.__download_frequency__):
self.query['interval'] = interval;
else:
self.query['interval'] = None;
raise ValueError(f"value of argument 'interval' is not compatible with the given API '{str(self.__api__)}'");
def SetPeriod(self, period:Union[str,dt.datetime,List[Union[int,dt.datetime]]]) -> None:
if isinstance(period,list) and len(period) is 2 and all(lambda p: isinstance(p,int) or isinstance(p,dt.datetime) or isinstance(p,str) for p in period):
self.query['period1'], self.query['period2'] = self.__parse_periods__(*(period));
elif isinstance(period,str):
if self.__api__ is AccessModeInQuery.CHART and period in self.__chart_range__:
self.query['range'] = period;
else:
raise ValueError(f"value of argument 'period' is not compatible with the given API '{str(self.__api__)}'");
elif isinstance(period,dt.datetime):
self.query['period1'], self.query['period2'] = self.__parse_periods__(period,period);
else:
self.query['period1'], self.query['period2'], self.query['range'] = None, None, None;
raise TypeError(f"invalid type for the argument 'period'; {type(str)} or {type(dt.datetime)} or a list of either {type(int)} or {type(dt.datetime)} expected, got {type(period)}");
@classmethod
def __parse_periods__(cls, value1:Union[dt.datetime,int,str], value2:Union[dt.datetime,int,str]) -> Tuple[int,int]:
# Note that the earliest date that is possible to take into consideration is platform-dependent.
# For compatibility reasons, we do not accept timestamps prior to epoch time 0.
if isinstance(value1,str):
try:
period1 = int(du.isoparse(value1).timestamp());
except (OSError,OverflowError):
period1 = 0;
else:
period1 = max(0,(int(time.mktime(value1.timetuple())))) if isinstance(value1, dt.datetime) else max(0,value1);
if value1==value2:
period2 = period2;
elif isinstance(value2,str):
try:
period2 = int(du.isoparse(value2).timestamp());
except (OSError,OverflowError):
period2 = dt.datetime.now().timestamp();
else:
period2 = max(period1,int(time.mktime(value2.timetuple()))) if isinstance(value2, dt.datetime) else max(period1,value2);
return period1, period2
class Response:
"""
Class to parse and process responses sent back by the Yahoo Finance API.
Use the 'Parse()' method to correctly retrieve data structures in accordance to the chosen 'AccessModeInQuery' API.
"""
def __init__(self, input:Type[requests.models.Response]):
self.__format__:str = "";
self.__error__:Optional[Dict[str, str]] = None;
self.__meta__:Optional[Dict[str, Union[str, int, float]]] = None;
self.__timestamps__:Optional[List[dt.datetime]] = None;
self.__quotes__:Optional[pd.DataFrame] = None;
self.__events__:Optional[pd.DataFrame] = None;
self.__data__:Optional[Union[pd.DataFrame,dict]] = None;
def is_json() -> bool:
nonlocal input;
try:
input = input.json(parse_float=float, parse_int=int);
except ValueError :
return False
else:
return True
if is_json():
if'chart' in input.keys():
self.__format__ = 'chart';
if 'error' in input['chart'].keys():
self.__error__ = self.__response_parser__(input['chart']['error']);
if self.__error__ is None:
data = input['chart']['result'][0];
self.__error__ = {'code':"ok", 'description':"success!"};
self.__meta__ = self.__response_parser__(data['meta']);
self.__timestamps__ = pd.DatetimeIndex(list( map(dt.datetime.utcfromtimestamp, sorted(data['timestamp']))), name=f"Date ({pytz.utc})");
self.__quotes__ = pd.DataFrame({
'Open' : np.array(data['indicators']['quote'][0]['open']),
'High' : np.array(data['indicators']['quote'][0]['high']),
'Low' : np.array(data['indicators']['quote'][0]['low']),
'Close' : np.array(data['indicators']['quote'][0]['close']),
'Adj Close': np.array(data['indicators']['adjclose'][0]['adjclose'])
if 'adjclose' in data['indicators'].keys()
else np.full(len(data['indicators']['quote'][0]['close']),np.NaN),
'Volume' : np.array(data['indicators']['quote'][0]['volume'])},
index=self.__timestamps__);
if 'events' in data.keys():
index = list();
entries = list();
columns = list();
if 'splits' in data['events'].keys():
for split in data['events']['splits'].values():
index.append(split['date']);
entries.append([split['numerator'], split['denominator'], split['denominator']/split['numerator']]);
columns=['From', 'To', 'Split Ratio'];
elif 'dividends' in data['events'].keys():
for dividend in data['events']['dividends'].values():
index.append(dividend['date']);
entries.append(dividend['amount']);
columns=['Dividends'];
index = pd.DatetimeIndex(list(map(lambda ts: dt.datetime.utcfromtimestamp(ts).date(),sorted(index))), name=f"Date ({pytz.utc})");
self.__events__ = pd.DataFrame(entries,index=index,columns=columns);
elif 'finance' in input.keys():
self.__format__ = 'finance';
if 'error' in input['finance'].keys():
self.__error__ = self.__response_parser__(input['finance']['error']);
if self.__error__ is None:
self.__data__ = self.__response_parser__(input['finance']);
else:
self.__format__ = 'finance';
self.__error__ = {'code':"ok", 'description':"success!"};
self.__data__ = pd.read_csv(io.StringIO(input.text),index_col=0,parse_dates=True).sort_index();
def Parse(self) -> Dict[str,Any]:
if self.__format__ == 'chart':
return {'api':'chart', 'meta':self.__meta__, 'quotes':self.__quotes__, 'events':self.__events__, 'error':self.__error__};
elif self.__format__ == 'finance':
return {'api':'download', 'data':self.__data__, 'error':self.__error__};
else:
return {'api': 'unknown', 'error':{'code':"0", 'description':"invalid API"} };
@classmethod
def __response_parser__(cls, d:Any) -> Any:
if d is "null":
return None
elif isinstance(d,dict):
return {key:cls.__response_parser__(value) for key, value in d.items()};
elif isinstance(d,list):
try:
return list(map(float, d));
except :
return d;
elif isinstance(d,str):
try:
return float(d);
except:
return d;
else:
return d
class Session:
"""
A lower level class that explicitly requests data to Yahoo Finance via HTTP.
I provides two 'public' methods:
- With(...): to set the favorite access mode;
- Get(...): to explicitly push request to Yahoo.
It implements a recursive call to the HTTP 'GET' method in case of failure.
The maximum number of attempts has been hardcodedly set to 10.
"""
__yahoo_finance_url__:str = "";
__yahoo_finance_api__:Type[AccessModeInQuery] = AccessModeInQuery.NONE;
def __init__(self):
self.__last_time_checked__ : dt.datetime;
self.__cookies__ : Type[requests.cookies.RequestsCookieJar];
self.__crumb__ : str;
@classmethod
def With(cls, this_api:Type[AccessModeInQuery]) -> 'Session':
if not isinstance(this_api,AccessModeInQuery):
raise TypeError(f"invalid type for the argument 'this_api'; <class 'AccessModeInQuery'> expected, got {type(this_api)}.");
else:
cls.__set_api__(this_api);
cls.__set_url__();
session = cls();
session.__start__();
return session;
@classmethod
def __set_url__(cls) -> None:
if cls.__yahoo_finance_api__ is not AccessModeInQuery.NONE:
cls.__yahoo_finance_url__ = f"https://query1.finance.yahoo.com/v7/finance/{cls.__yahoo_finance_api__}/";
else:
raise UnboundLocalError("session's api has not been set yet");
@classmethod
def __set_api__(cls, input_api:Type[AccessModeInQuery]=AccessModeInQuery.DEFAULT) -> None:
if cls.__yahoo_finance_api__ is not input_api:
cls.__yahoo_finance_api__ = input_api if input_api is not AccessModeInQuery.NONE else AccessModeInQuery.DEFAULT;
#else:
# print(f"*INFO: the session 'api' was already '{input_api}'.");
def __start__(self) -> None:
r = requests.get('https://finance.yahoo.com/quote/SPY/history');
self.__cookies__ = requests.cookies.cookiejar_from_dict({'B': r.cookies['B']});
pattern = re.compile(r'.*"CrumbStore":\{"crumb":"(?P<crumb>[^"]+)"\}');
for line in r.text.splitlines():
crumb_match = pattern.match(line)
if crumb_match is not None:
self.__crumb__ = crumb_match.groupdict()['crumb'];
break;
self.__last_time_checked__ = dt.datetime.now();
def __restart__(self) -> None:
self.__abandon__();
self.__start__();
def __refresh__(self, force:bool=False) -> None:
if force:
self.__restart__();
else:
if self.__last_time_checked__ is not None:
current_time = dt.datetime.now()
delta_secs = (current_time - self.__last_time_checked__).total_seconds()
if delta_secs > 300: # 300 = 5 minutes
self.__restart__();
def __abandon__(self) -> None:
self.__cookies__ = None;
self.__crumb__ = "";
self.__last_time_checked__ = None;
def Get(self, ticker:str, params:Type[Query], attempt:int=0, timeout:int=10, last_error:str="") -> Tuple[bool, dict]:
if not isinstance(ticker,str):
raise TypeError(f"invalid type for the argument 'ticker'! {type(str)} expected; got {type(ticker)}");
if not isinstance(params, Query):
raise TypeError(f"invalid type for the argument 'params'! <class 'Query'> expected; got {type(params)}");
if attempt<10:
query = f"?{str(params)}&crumb={self.__crumb__}" if params else f"?crumb={self.__crumb__}";
url = self.__yahoo_finance_url__ + ticker + query;
try:
response = requests.get(url, cookies=self.__cookies__)
response.raise_for_status();
except requests.HTTPError as e:
if response.status_code in [408, 409, 429]:
time.sleep(timeout);
self.__refresh__();
return self.Get(ticker,params,attempt=attempt+1,timeout=timeout+1,last_error=str(e))
elif response.status_code in [401, 404, 422]:
r = Response(response).Parse();
if r['error']['description'] == "Invalid cookie":
self.__refresh__(force=True);
return self.Get(ticker,params,attempt=attempt+1,timeout=timeout+5,last_error=r['error']['description'])
else:
return True, dict({'code': r['error']['code'], 'description': f"{r['error']['description']} (attempt: {attempt})"});
else :
m = re.match(r'^(?P<code>\d{3})\s?\w*\s?Error\s?:\s?(?P<description>.+)$', str(e));
return True, dict({'code': m['code'], 'description': f"{m['description']} (attempt: {attempt})"});
except requests.Timeout as e:
time.sleep(timeout);
self.__refresh__();
return self.Get(ticker,params,attempt=attempt+1,timeout=timeout+1,last_error=str(e))
except requests.RequestException as e:
if re.search(r"^\s*Invalid\s?URL", str(e)):
time.sleep(timeout);
self.__refresh__();
return self.Get(ticker,params,attempt=attempt+1,timeout=timeout+1,last_error=str(e));
else:
return True, dict({'code': "-1", 'description': f"{str(e)} (attempt: {attempt})"});
else:
r = Response(response).Parse();
if r['error'] is not None and r['error']['code'] is not "ok":
return True, dict({'code': r['error']['code'], 'description': f"{r['error']['description']} (attempt: {attempt})"});
else:
return False, r;
else:
return True, dict({'code': "-2", 'description': "{}\nThe maximum number of attempts has been exceeded!".format(last_error)});
|
53079
|
from django.conf.urls import url
from . import views
urlpatterns = [
# generic profile endpoint
url(r'^profile/(?P<username>\w+)/', views.profile, name='profile-api'),
# current user profile
url(r'^profile/', views.profile, name='profile-api'),
]
|
53119
|
import gym
from gym.spaces.box import Box
class TransposeImagesIfRequired(gym.ObservationWrapper):
"""
When environment observations are images, this wrapper transposes
the axis. It is useful when the images have shape (W,H,C), as they can be
transposed "on the fly" to (C,W,H) for PyTorch convolutions to be applied.
Parameters
----------
env : gym.Env
Original Gym environment, previous to applying the wrapper.
op : list
New axis ordering.
"""
def __init__(self, env=None, op=[2, 0, 1]):
"""Transpose observation space for images"""
super(TransposeImagesIfRequired, self).__init__(env)
self.op = op
if isinstance(self.observation_space, gym.spaces.Box) and \
len(self.observation_space.shape) == 3:
obs_shape = self.observation_space.shape
self.observation_space = Box(
self.observation_space.low[0, 0, 0],
self.observation_space.high[0, 0, 0],
[obs_shape[self.op[0]], obs_shape[self.op[1]], obs_shape[self.op[2]]],
dtype=self.observation_space.dtype)
elif isinstance(self.observation_space, gym.spaces.Dict):
for k in self.observation_space.spaces:
if isinstance(self.observation_space[k], gym.spaces.Box) and \
len(self.observation_space[k].shape) == 3:
obs_shape = self.observation_space[k].shape
self.observation_space[k] = Box(
self.observation_space[k].low[0, 0, 0],
self.observation_space[k].high[0, 0, 0],
[obs_shape[self.op[0]], obs_shape[self.op[1]], obs_shape[self.op[2]]],
dtype=self.observation_space.dtype)
def observation(self, ob):
"""Transpose observation"""
if isinstance(ob, dict):
for k in ob:
if len(ob[k].shape) == 3:
ob[k] = ob[k].transpose(self.op[0], self.op[1], self.op[2])
else:
if len(ob.shape) == 3:
ob = ob.transpose(self.op[0], self.op[1], self.op[2])
return ob
|
53138
|
import os
from bottle import Bottle, static_file, run
HERE = os.path.abspath(os.path.dirname(__file__))
STATIC = os.path.join(HERE, 'static')
app = Bottle()
@app.route('/')
@app.route('/<filename:path>')
def serve(filename='index.html'):
return static_file(filename, root=STATIC)
if __name__ == '__main__':
run(app=app, host='localhost', port=8080)
|
53155
|
from locust import HttpUser, task, between
class LoadTest(HttpUser):
@task
def test(self):
self.client.get('/')
|
53168
|
from uninas.utils.args import Argument
from uninas.register import Register
from uninas.methods.abstract import AbstractBiOptimizationMethod
from uninas.methods.strategies.manager import StrategyManager
from uninas.methods.strategies.differentiable import DifferentiableStrategy
@Register.method(search=True)
class AsapSearchMethod(AbstractBiOptimizationMethod):
"""
Executes all choices, learns how to weights them in a weighted sum,
anneals the softmax temperature to enforce convergence and prunes the options that are weighted below a threshold
"""
@classmethod
def args_to_add(cls, index=None) -> [Argument]:
""" list arguments to add to argparse when this class (or a child class) is chosen """
return super().args_to_add(index) + [
Argument('tau_0', default=1.6, type=float, help='initial tau value for the softmax temperature'),
Argument('tau_grace', default=1.0, type=float, help='no arc training/pruning until tau is smaller'),
Argument('beta', default=0.95, type=float, help='beta value to anneal tau0'),
]
def setup_strategy(self) -> StrategyManager:
""" set up the strategy for architecture weights """
tau_0 = self._parsed_argument('tau_0', self.hparams)
return StrategyManager().add_strategy(DifferentiableStrategy(self.max_epochs, tau=tau_0, use_mask=True))
def _on_epoch_start(self) -> dict:
log_dict = super()._on_epoch_start()
tau_0, tau_grace, beta = self._parsed_arguments(['tau_0', 'tau_grace', 'beta'], self.hparams)
for strategy in StrategyManager().get_strategies_list():
strategy.tau = tau_0 * beta ** self.current_epoch
log_dict = self._add_to_dict(log_dict, dict(tau=strategy.tau))
self.update_architecture_weights = strategy.tau < tau_grace
if self.update_architecture_weights:
strategy.mask_all_weights_below(0.4, div_by_numel=True)
log_dict.update(strategy.get_masks_log_dict(prefix='asap/masks'))
self.set_loader_multiples((1, 1))
else:
self.set_loader_multiples((1, 0))
return log_dict
|
53177
|
import pandas as pd
dataset = pd.read_csv('iris.csv')
dataset.boxplot(column = 'sepal_width',by = 'species')
import matplotlib.pyplot as plt
hours_slices = [8,16]
activities = ['work','sleep']
colors = ['g','r']
plt.pie(hours_slices,labels=activities,colors=colors,startangle=90,autopct='%.1f%%')
plt.show()
|
53198
|
import os, sys
import warnings
__thisdir__ = os.path.dirname(os.path.realpath(__file__))
# Testing the import of the numpy package
def test_import_numpy():
try:
import numpy as np
except ImportError as e:
assert(1 == 0), "Numpy could not be imported:\n %s" %e
sys.path.pop(0)
# Testing the import of the scipy package
def test_import_scipy():
try:
import scipy as sp
except ImportError as e:
assert(1 == 0), "Scipy could not be imported:\n %s" %e
sys.path.pop(0)
# Testing for broken MPI installation
def test_import_mpi4py():
try:
from mpi4py import MPI
except ImportError:
warnings.warn(UserWarning("MPI for python could not be imported"))
assert(1 == 1)
sys.path.pop(0)
# Testing the import of the Qt modules QtGui and QtCore
def test_import_qt_modules():
sys.path.insert(0, __thisdir__ + "/../src")
try:
from interface.Qt import QtGui, QtCore
except ImportError as e:
assert (1 == 0), "The Qt modules QtGui and QtCore could not be imported:\n %s" %e
sys.path.pop(0)
# Testing the import of the pyqtgraph module
def test_import_pyqtgraph_module():
try:
import pyqtgraph
except ImportError:
assert (1 == 0), "The pyqtgraph module could not be imported"
sys.path.pop(0)
# Testimg the import of the interface module
def test_import_interface_module():
sys.path.insert(0, __thisdir__ + "/../src")
try:
import interface
except ImportError as e:
assert (1 == 0), "The interface module could not be imported:\n %s" %e
sys.path.pop(0)
# Testing the import of the ipc module
def test_import_ipc_module():
sys.path.insert(0, __thisdir__ + "/../src")
try:
import ipc
except ImportError as e:
assert (1 == 0), "The ipc module could not be imported:\n %s" %e
sys.path.pop(0)
# Testing the import of the plotting module
def test_import_plotting_module():
sys.path.insert(0, __thisdir__ + "/../src")
try:
import plotting
except ImportError as e:
assert (1 == 0), "The plotting module could not be imported:\n %s" %e
sys.path.pop(0)
# Testing the import of the analysis module
def test_import_analysis_module():
sys.path.insert(0, __thisdir__ + "/../src")
try:
import analysis
except ImportError as e:
assert (1 == 0), "The analysis module could not be imported:\n %s" %e
sys.path.pop(0)
# Testing the import of the simulation module
def test_import_simulation_module():
sys.path.insert(0, __thisdir__ + "/../src")
try:
import simulation
except ImportError as e:
assert (1 == 0), "The simulation module could not be imported:\n %s" %e
sys.path.pop(0)
# Testing the import of the utils module
def test_import_utils_module():
sys.path.insert(0, __thisdir__ + "/../src")
try:
import utils
except ImportError as e:
assert (1 == 0), "The utils module could not be imported:\n %s" %e
sys.path.pop(0)
# Testing if LCLS backend is imported properly
def test_import_backend_lcls():
sys.path.insert(0, __thisdir__ + "/../src")
try:
import backend.lcls
return True
except ImportError as e:
warnings.warn(UserWarning("The LCLS backend could not be imported:\n %s" %e))
assert(1 == 1)
return False
sys.path.pop(0)
|
53226
|
from trasto.model.entities import EstadoHumorRepositoryInterface
from trasto.model.value_entities import ResultadoAccion
from trasto.model.events import EventRepositoryInterface
class SensorInterface:
def listen_to_task_result(self, evento_repo: EventRepositoryInterface) -> None:
pass
def update_humor_from_task_result(self, resultado: ResultadoAccion, humor_repo: EstadoHumorRepositoryInterface) -> None:
pass
|
53251
|
import pulumi
from pulumi_aws import ec2, get_availability_zones
stack_name = pulumi.get_stack()
project_name = pulumi.get_project()
config = pulumi.Config('vpc')
vpc = ec2.Vpc(resource_name=f"eks-{project_name}-{stack_name}",
cidr_block="10.100.0.0/16",
enable_dns_support=True,
enable_dns_hostnames=True,
instance_tenancy='default',
tags={"Project": project_name,
"Stack": stack_name})
igw = ec2.InternetGateway(resource_name=f'vpc-ig-{project_name}-{stack_name}',
vpc_id=vpc.id,
tags={"Project": project_name,
"Stack": stack_name})
route_table = ec2.RouteTable(resource_name=f'vpc-route-table-{project_name}-{stack_name}',
vpc_id=vpc.id,
routes=[ec2.RouteTableRouteArgs(
cidr_block='0.0.0.0/0',
gateway_id=igw.id)],
tags={"Project": project_name,
"Stack": stack_name})
# Use availability zones defined in the configuration file if available
if config.get('azs'):
azs = config.get_object('azs')
else:
azs = get_availability_zones(state="available").names
public_subnets = []
private_subnets = []
# If you wanted to double the number of subnets because you have few
# availability zones, you can redefine the variable below to something
# like: list(itertools.chain(azs, azs)) which would just repeat the
# same list of AZs twice. The iteration logic will pick it up for
# subnet creation and create unique names.
azs_for_subnets = list(azs)
if len(azs) <= 0:
raise ValueError("There are no usable availability zones")
if len(azs) == 1:
pulumi.log.warn("There is only a single usable availability zone")
elif len(azs) == 2:
pulumi.log.warn("There are only two usable availability zones")
for i, az in enumerate(azs_for_subnets):
if not isinstance(az, str):
raise f'availability zone specified [{i}] is not a valid string value: [{az}]'
if az.strip() == "":
raise f'availability zone specified [{i}] is an empty string'
public_subnet_addr = i
resource_name = f'{az}-k8s-public-{project_name}-{stack_name}-{i}'
subnet = ec2.Subnet(resource_name=resource_name,
availability_zone=az,
vpc_id=vpc.id,
cidr_block=f"10.100.{public_subnet_addr}.0/24",
map_public_ip_on_launch=True,
tags={"Project": project_name,
"Stack": stack_name,
"kubernetes.io/role/elb": "1"})
ec2.RouteTableAssociation(f"route-table-assoc-public-{az}-{i}",
route_table_id=route_table.id,
subnet_id=subnet.id)
public_subnets.append(subnet)
for i, az in enumerate(azs_for_subnets):
private_subnet_addr = (i + 1) * 16
resource_name = f"{az}-k8s-private-{project_name}-{stack_name}-{i}"
subnet = ec2.Subnet(resource_name=resource_name,
availability_zone=az,
vpc_id=vpc.id,
cidr_block=f"10.100.{private_subnet_addr}.0/20",
tags={"Project": project_name,
"Stack": stack_name,
"kubernetes.io/role/internal-elb": "1"},
map_public_ip_on_launch=False)
ec2.RouteTableAssociation(resource_name=f"route-table-assoc-private-{az}-{project_name}-{stack_name}-{i}",
route_table_id=route_table.id,
subnet_id=subnet.id)
private_subnets.append(subnet)
eks_security_group = ec2.SecurityGroup(resource_name=f'eks-cluster-sg-{project_name}-{stack_name}',
vpc_id=vpc.id,
description="Allow all HTTP(s) traffic to EKS Cluster",
tags={"Project": project_name,
"Stack": stack_name},
ingress=[
ec2.SecurityGroupIngressArgs(
cidr_blocks=['0.0.0.0/0'],
from_port=443,
to_port=443,
protocol='tcp',
description='Allow pods to communicate with the cluster API Server.'),
ec2.SecurityGroupIngressArgs(
cidr_blocks=['0.0.0.0/0'],
from_port=80,
to_port=80,
protocol='tcp',
description='Allow internet access to pods')])
pulumi.export("azs", azs)
pulumi.export("vpc", vpc)
|
53267
|
import json
import os
import re
import sys
import maya.cmds as cmds
import maya.mel as mel
current_user = None
asset_size = 100
child_entries_margin = 5
child_assets_column = 3
asset_store_window = "houdiniEngineAssetStoreWindow"
change_user_menu_item = "houdiniEngineAssetStoreChangeUserMenuItem"
asset_entries_scroll_layout = "houdiniEngineAssetStoreEntriesScrollLayout"
def get_store_path():
if "HOUDINI_ASSET_STORE_PATH" in os.environ:
return os.environ["HOUDINI_ASSET_STORE_PATH"]
houdini_version = cmds.houdiniEngine(houdiniVersion = True).split(".")
# Get Houdini prefs directory
houdini_prefs_path = None
if sys.platform.startswith("linux"):
houdini_prefs_path = os.path.expanduser(
"~/houdini{0}.{1}".format(
houdini_version[0], houdini_version[1]
)
)
elif sys.platform.startswith("win32"):
houdini_prefs_path = os.path.expanduser(
"~/houdini{0}.{1}".format(
houdini_version[0], houdini_version[1]
)
)
elif sys.platform.startswith("darwin"):
houdini_prefs_path = os.path.expanduser(
"~/Library/Preferences/houdini/{0}.{1}".format(
houdini_version[0], houdini_version[1]
)
)
else:
raise Exception("Cannot determine asset store path. Unknown OS.")
asset_store_path = os.path.join(houdini_prefs_path, "asset_store")
return asset_store_path
def get_store_user_path():
user = get_store_current_user()
users_root = get_users()
user_dir = None
if users_root and user in users_root["users"]:
user_dir = users_root["users"][user]
if not user_dir:
user_dir = "default"
return os.path.join(get_store_path(), user_dir)
def get_store_users_path():
return os.path.join(get_store_path(), "users.json")
def get_store_installed_assets_path():
return os.path.join(get_store_user_path(), "installed_assets.json")
def get_store_otls_path():
return os.path.join(get_store_user_path(), "otls")
def get_store_icons_path():
return os.path.join(get_store_user_path(), "icons")
def get_store_licenses_path():
return os.path.join(get_store_user_path(), "licenses")
def get_store_current_user():
global current_user
if not current_user:
users_root = get_users()
if users_root and "default_user" in users_root:
current_user = users_root["default_user"]
if not current_user:
print "Warning: Cannot determine default user for asset store."
return current_user
def get_users():
users_json = get_store_users_path()
if not os.path.exists(users_json):
return None
users_root = None
with open(users_json, "r") as f:
users_root = json.load(f)
return users_root
def get_installed_assets():
installed_assets_json = get_store_installed_assets_path()
if not os.path.exists(installed_assets_json):
return None
installed_assets_root = None
with open(installed_assets_json, "r") as f:
installed_assets_root = json.load(f)
return installed_assets_root
def get_asset_license(otl_file):
license_json = os.path.join(get_store_licenses_path(),
re.sub("\\.otl$|\\.hda$|\\.otllc$|\\.hdalc$|\\.otlnc$|\\.hdanc$", ".json", otl_file))
license_root = None
with open(license_json, "r") as f:
license_root = json.load(f)
return license_root
def load_asset(otl_file, asset):
cmds.houdiniAsset(loadAsset=[otl_file, asset])
def create_asset_entry(asset):
form_layout = cmds.formLayout(width = asset_size, height = asset_size)
if "otl_file" in asset:
license = get_asset_license(asset["otl_file"])
otl_file = os.path.join(get_store_otls_path(), asset["otl_file"])
m = re.match("([^:]*)::(.*)", asset["node_type_name"])
asset_name = "{0}::{1}/{2}".format(
m.group(1),
license["category_name"],
m.group(2),
)
cmds.symbolButton(
annotation = asset["descriptive_name"],
image = os.path.join(get_store_icons_path(), asset["icon"]),
width = asset_size, height = asset_size,
command = lambda *args: load_asset(otl_file, asset_name)
)
elif "update_available" in asset and asset["update_available"]:
cmds.symbolButton(
annotation = asset["descriptive_name"],
image = os.path.join(get_store_icons_path(), asset["icon"]),
width = asset_size, height = asset_size,
)
cmds.text(
label = "Update available. Use Houdini to update asset.",
width = asset_size, height = asset_size,
wordWrap = True,
)
text = cmds.text(
label = asset["descriptive_name"],
backgroundColor = [0,0,0],
align = "right",
)
cmds.formLayout(
form_layout,
edit = True,
width = asset_size, height = asset_size,
attachForm = [[text, "left", 0], [text, "right", 0], [text, "bottom", 0]],
)
cmds.setParent(upLevel = True)
def compare_asset_entry(x, y):
if x["type"] == "folder" and y["type"] == "folder":
if x["name"] < y["name"]:
return -1
else:
return 1
elif x["type"] == "asset" and y["type"] == "asset":
return -1
elif x["type"] == "asset" and y["type"] == "folder":
return -1
elif x["type"] == "folder" and y["type"] == "asset":
return 1
def create_asset_entries(entries):
in_assets_layout = False
cmds.columnLayout(adjustableColumn = True)
for entry in sorted(entries, cmp = compare_asset_entry):
if entry["type"] == "folder":
if in_assets_layout:
in_assets_layout = False
cmds.setParent(upLevel=True)
cmds.frameLayout(
collapsable = True,
label = entry["name"],
marginWidth = child_entries_margin
)
create_asset_entries(entry["entries"])
cmds.setParent(upLevel = True)
elif entry["type"] == "asset":
if not in_assets_layout:
in_assets_layout = True
cmds.gridLayout(
numberOfColumns = child_assets_column,
cellWidthHeight = [asset_size, asset_size]
)
create_asset_entry(entry)
if in_assets_layout:
in_assets_layout = False
cmds.setParent(upLevel = True)
cmds.setParent(upLevel = True)
def change_user(user):
current_user = user
refresh_asset_entries()
def change_user_post_menu_command(*args):
cmds.menu(
change_user_menu_item,
edit = True,
deleteAllItems = True,
)
cmds.setParent(change_user_menu_item, menu = True)
users_root = get_users()
if not users_root:
return
current_user = get_store_current_user()
for user in users_root["users"]:
cmds.menuItem(
label = user,
command = lambda user=user: change_user(user),
radioButton = user == current_user
)
def refresh_asset_entries(*args):
if not cmds.window(asset_store_window, exists = True):
return
cmds.setParent(asset_store_window)
# Delete the existing layout
if cmds.scrollLayout(asset_entries_scroll_layout, exists = True):
cmds.deleteUI(asset_entries_scroll_layout)
installed_assets = get_installed_assets()
cmds.scrollLayout(asset_entries_scroll_layout, childResizable = True)
if installed_assets \
and installed_assets["organization"]["entries"]:
create_asset_entries(installed_assets["organization"]["entries"])
else:
cmds.text(
label = "There are no Orbolt assets installed for this user.<br />"
"Please visit the <a href=\"http://www.orbolt.com/maya\">Orbolt Store</a> for assets.",
wordWrap = True,
hyperlink = True,
)
cmds.setParent(upLevel = True)
def close_asset_store_window(*args):
cmds.deleteUI(asset_store_window)
def show_asset_store_window():
if cmds.window(asset_store_window, exists = True):
cmds.showWindow(asset_store_window)
return
cmds.window(
asset_store_window,
title = "Orbolt Asset Browser",
menuBar = True,
)
cmds.menu(label = "File", tearOff = True)
cmds.menuItem(
change_user_menu_item,
label = "Change User",
subMenu = True,
postMenuCommand = change_user_post_menu_command,
)
cmds.setParent(menu = True, upLevel = True);
cmds.menuItem(divider = True)
cmds.menuItem(label = "Refresh Asset List", command = refresh_asset_entries)
cmds.menuItem(divider = True)
cmds.menuItem(label = "Close", command = close_asset_store_window)
cmds.setParent(menu = True, upLevel = True);
refresh_asset_entries()
cmds.showWindow(asset_store_window)
|
53277
|
from tests.test_resources.helper import select_random_from_list
def get_muncipalities_with_hits():
with_hits = []
for m in municipalities:
if m['hits'] > 0:
with_hits.append(m)
return with_hits
def get_ten_random_municipalities_with_hits():
return select_random_from_list(full_list=get_muncipalities_with_hits(), how_many=10)
municipalities = [
{'id': 'XWKY_c49_5nv', 'name': '<NAME>', 'type': 'municipality', 'code': '0114', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 14,
'ad_ids': ['24641303', '24641232', '24636479', '24630746', '24627847', '24612651', '24608713', '24603235',
'24598186', '24580428']},
{'id': 'K4az_Bm6_hRV', 'name': 'Vallentuna', 'type': 'municipality', 'code': '0115', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 7,
'ad_ids': ['24649005', '24648696', '24641486', '24611368', '24590586', '24556609', '24519998']},
{'id': '8gKt_ZsV_PGj', 'name': 'Österåker', 'type': 'municipality', 'code': '0117', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 8,
'ad_ids': ['24640198', '24634294', '23699999', '24624738', '24577311', '24576867', '24532362', '24518247']},
{'id': '15nx_Vut_GrH', 'name': 'Värmdö', 'type': 'municipality', 'code': '0120', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 11,
'ad_ids': ['24632907', '24631461', '24620746', '24614472', '24610276', '24602803', '24590922', '24577016',
'24574442', '24509435']},
{'id': 'qm5H_jsD_fUF', 'name': 'Järfälla', 'type': 'municipality', 'code': '0123', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 16,
'ad_ids': ['24648843', '24647618', '24638674', '24637614', '24627854', '24626944', '24623198', '24622371',
'24619258', '24616216']},
{'id': 'magF_Gon_YL2', 'name': 'Ekerö', 'type': 'municipality', 'code': '0125', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 11,
'ad_ids': ['24647866', '24643150', '24638266', '24637006', '24626766', '24618010', '24617986', '24609385',
'24601615', '24541639']},
{'id': 'g1Gc_aXK_EKu', 'name': 'Huddinge', 'type': 'municipality', 'code': '0126', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 47,
'ad_ids': ['24649947', '24649919', '24649818', '24647357', '24641723', '24640701', '24639742', '24638132',
'24636901',
'24633282']},
{'id': 'CCVZ_JA7_d3y', 'name': 'Botkyrka', 'type': 'municipality', 'code': '0127', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 20,
'ad_ids': ['24649834', '24649058', '24645367', '24642952', '24637457', '24635479', '24634919', '24629461',
'24622699', '24615777']},
{'id': '4KBw_CPU_VQv', 'name': 'Salem', 'type': 'municipality', 'code': '0128', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 2, 'ad_ids': ['24635325', '24596057']},
{'id': 'Q7gp_9dT_k2F', 'name': 'Haninge', 'type': 'municipality', 'code': '0136', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 17,
'ad_ids': ['24650480', '24647950', '24630278', '24623592', '24616301', '24614366', '24606163', '24604574',
'24589305', '24586867']},
{'id': 'sTPc_k2B_SqV', 'name': 'Tyresö', 'type': 'municipality', 'code': '0138', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 7,
'ad_ids': ['24643255', '24624425', '24618754', '24614988', '24613766', '24598566', '24597634']},
{'id': 'w6yq_CGR_Fiv', 'name': 'Upplands-Bro', 'type': 'municipality', 'code': '0139', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 11,
'ad_ids': ['24649677', '24644808', '24643168', '24643140', '24641431', '24554813', '24628120', '24614768',
'24604245', '24603297']},
{'id': 'mBKv_q3B_SK8', 'name': 'Nykvarn', 'type': 'municipality', 'code': '0140', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 7,
'ad_ids': ['24649772', '24645739', '24644051', '24637850', '24630053', '24625534', '24589239']},
{'id': 'onpA_B5a_zfv', 'name': 'Täby', 'type': 'municipality', 'code': '0160', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 25,
'ad_ids': ['24640762', '24640430', '24640171', '24637534', '24625126', '24624931', '24613119', '24611999',
'24610353', '24609668']},
{'id': 'E4CV_a5E_ucX', 'name': 'Danderyd', 'type': 'municipality', 'code': '0162', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 18,
'ad_ids': ['24650650', '24650652', '24643754', '24639629', '24638561', '24638260', '24614446', '24611837',
'24609748', '24597392']},
{'id': 'Z5Cq_SgB_dsB', 'name': 'Sollentuna', 'type': 'municipality', 'code': '0163', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 8,
'ad_ids': ['24648025', '24646503', '24634127', '24627899', '24624197', '24612586', '24605084', '24604254']},
{'id': 'AvNB_uwa_6n6', 'name': 'Stockholm', 'type': 'municipality', 'code': '0180', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 775,
'ad_ids': ['24650983', '24650895', '24650889', '24650784', '24650759', '24650748', '24650728', '24650682',
'24650497', '24650349']},
{'id': 'g6hK_M1o_hiU', 'name': 'Södertälje', 'type': 'municipality', 'code': '0181', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 52,
'ad_ids': ['24650352', '24647317', '24646726', '24644816', '24644223', '24642658', '24642513', '24641912',
'24641018', '24640024']},
{'id': 'aYA7_PpG_BqP', 'name': 'Nacka', 'type': 'municipality', 'code': '0182', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 27,
'ad_ids': ['24649527', '24649274', '24645898', '24644478', '24581554', '24636080', '24634930', '24628301',
'24627163', '24621428']},
{'id': 'UTJZ_zHH_mJm', 'name': 'Sundbyberg', 'type': 'municipality', 'code': '0183', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 11,
'ad_ids': ['24643175', '24638423', '24637895', '24621759', '24611001', '24605909', '24602420', '24599279',
'24590884', '24552397']},
{'id': 'zHxw_uJZ_NJ8', 'name': 'Solna', 'type': 'municipality', 'code': '0184', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 61,
'ad_ids': ['24650876', '24649894', '24649491', '24648158', '24644646', '24643212', '24641524', '24640665',
'24639217', '24638221']},
{'id': 'FBbF_mda_TYD', 'name': 'Lidingö', 'type': 'municipality', 'code': '0186', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 13,
'ad_ids': ['24648043', '24648032', '24645326', '24631039', '24238908', '24611032', '24606240', '24604895',
'24603294', '24593721']},
{'id': '9aAJ_j6L_DST', 'name': 'Vaxholm', 'type': 'municipality', 'code': '0187', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 2, 'ad_ids': ['24618958', '24542055']},
{'id': 'btgf_fS7_sKG', 'name': 'Norrtälje', 'type': 'municipality', 'code': '0188', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 26,
'ad_ids': ['24647156', '24645902', '24645523', '24644525', '24638282', '24639147', '24636961', '24633665',
'24628281', '24626958']},
{'id': '8ryy_X54_xJj', 'name': 'Sigtuna', 'type': 'municipality', 'code': '0191', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 19,
'ad_ids': ['24649537', '24648645', '24645926', '24643945', '24636904', '24636803', '24634498', '24633655',
'24631760', '24628534']},
{'id': '37UU_T7x_oxG', 'name': 'Nynäshamn', 'type': 'municipality', 'code': '0192', 'region_code': '01',
'region_name': 'Stockholms län', 'hits': 12,
'ad_ids': ['24649508', '24649463', '24643147', '24642006', '24636125', '24620822', '24616700', '24600203',
'24575057', '24566977']},
{'id': 'Bbs5_JUs_Qh5', 'name': 'Håbo', 'type': 'municipality', 'code': '0305', 'region_code': '03',
'region_name': 'Uppsala län', 'hits': 5, 'ad_ids': ['24650354', '24645507', '24643909', '24562714', '24485221']},
{'id': 'cbyw_9aK_Cni', 'name': 'Älvkarleby', 'type': 'municipality', 'code': '0319', 'region_code': '03',
'region_name': 'Uppsala län', 'hits': 1, 'ad_ids': ['24623380']},
{'id': 'KALq_sG6_VrW', 'name': 'Knivsta', 'type': 'municipality', 'code': '0330', 'region_code': '03',
'region_name': 'Uppsala län', 'hits': 5, 'ad_ids': ['24634631', '24610544', '24593401', '24577340', '24499916']},
{'id': 'K8A2_JBa_e6e', 'name': 'Tierp', 'type': 'municipality', 'code': '0360', 'region_code': '03',
'region_name': 'Uppsala län', 'hits': 5, 'ad_ids': ['24646413', '24642957', '24632440', '24629420', '24593674']},
{'id': 'otaF_bQY_4ZD', 'name': 'Uppsala', 'type': 'municipality', 'code': '0380', 'region_code': '03',
'region_name': 'Uppsala län', 'hits': 116,
'ad_ids': ['24650128', '24649375', '24649111', '24648825', '24648007', '24641555', '24647083', '24642165',
'24645085', '24643472']},
{'id': 'HGwg_unG_TsG', 'name': 'Enköping', 'type': 'municipality', 'code': '0381', 'region_code': '03',
'region_name': 'Uppsala län', 'hits': 31,
'ad_ids': ['24649986', '24640955', '24636030', '24634261', '24634124', '24633958', '24633755', '24632200',
'24631332', '24630750']},
{'id': 'VE3L_3Ei_XbG', 'name': 'Östhammar', 'type': 'municipality', 'code': '0382', 'region_code': '03',
'region_name': 'Uppsala län', 'hits': 7,
'ad_ids': ['24636870', '24620508', '24610180', '24602559', '24545246', '24528574', '24456277']},
{'id': 'rut9_f5W_kTX', 'name': 'Vingåker', 'type': 'municipality', 'code': '0428', 'region_code': '04',
'region_name': 'Södermanlands län', 'hits': 3, 'ad_ids': ['24630384', '24611402', '24610522']},
{'id': 'os8Y_RUo_U3u', 'name': 'Gnesta', 'type': 'municipality', 'code': '0461', 'region_code': '04',
'region_name': 'Södermanlands län', 'hits': 7,
'ad_ids': ['24624678', '24614695', '24606086', '24539789', '24527883', '24452669', '24437897']},
{'id': 'KzvD_ePV_DKQ', 'name': 'Nyköping', 'type': 'municipality', 'code': '0480', 'region_code': '04',
'region_name': 'Södermanlands län', 'hits': 32,
'ad_ids': ['24648507', '24647220', '24646241', '24644029', '24643813', '24640685', '24638209', '24621102',
'24619295', '24618870']},
{'id': '72XK_mUU_CAH', 'name': 'Oxelösund', 'type': 'municipality', 'code': '0481', 'region_code': '04',
'region_name': 'Södermanlands län', 'hits': 6,
'ad_ids': ['24650534', '24638207', '24635193', '24627634', '24572186', '24470292']},
{'id': 'P8yp_WT9_Bks', 'name': 'Flen', 'type': 'municipality', 'code': '0482', 'region_code': '04',
'region_name': 'Södermanlands län', 'hits': 8,
'ad_ids': ['24642920', '24642061', '24617764', '24617668', '24584928', '24570283', '24457975', '24252077']},
{'id': 'snx9_qVD_Dr1', 'name': 'Katrineholm', 'type': 'municipality', 'code': '0483', 'region_code': '04',
'region_name': 'Södermanlands län', 'hits': 11,
'ad_ids': ['24641421', '24640118', '24638917', '24634274', '24632221', '24627764', '24624267', '24572047',
'24499697', '24462987']},
{'id': 'kMxr_NiX_YrU', 'name': 'Eskilstuna', 'type': 'municipality', 'code': '0484', 'region_code': '04',
'region_name': 'Södermanlands län', 'hits': 37,
'ad_ids': ['24649500', '24648293', '24642848', '24642008', '24635208', '24634840', '24634180', '24624433',
'24623481', '24622346']},
{'id': 'shnD_RiE_RKL', 'name': 'Strängnäs', 'type': 'municipality', 'code': '0486', 'region_code': '04',
'region_name': 'Södermanlands län', 'hits': 13,
'ad_ids': ['24645062', '24640755', '24633881', '24629018', '24628036', '24626818', '24620342', '24617315',
'24613763', '24606350']},
{'id': 'rjzu_nQn_mCK', 'name': 'Trosa', 'type': 'municipality', 'code': '0488', 'region_code': '04',
'region_name': 'Södermanlands län', 'hits': 6,
'ad_ids': ['24629673', '24617357', '24615644', '24601519', '24573221', '24568390']},
{'id': 'Fu8g_29u_3xF', 'name': 'Ödeshög', 'type': 'municipality', 'code': '0509', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 4, 'ad_ids': ['24633236', '24604733', '24604699', '24536516']},
{'id': 'vRRz_nLT_vYv', 'name': 'Ydre', 'type': 'municipality', 'code': '0512', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 1, 'ad_ids': ['24489383']},
{'id': 'U4XJ_hYF_FBA', 'name': 'Kinda', 'type': 'municipality', 'code': '0513', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 4, 'ad_ids': ['24640366', '24620200', '24513240', '24434591']},
{'id': 'e5LB_m9V_TnT', 'name': 'Boxholm', 'type': 'municipality', 'code': '0560', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 1, 'ad_ids': ['24614590']},
{'id': 'bFWo_FRJ_x2T', 'name': 'Åtvidaberg', 'type': 'municipality', 'code': '0561', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 1, 'ad_ids': ['24614818']},
{'id': 'dMFe_J6W_iJv', 'name': 'Finspång', 'type': 'municipality', 'code': '0562', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 7,
'ad_ids': ['24644134', '24625540', '24612693', '24611379', '24590409', '24583823', '24471628']},
{'id': 'Sb3D_iGB_aXu', 'name': 'Valdemarsvik', 'type': 'municipality', 'code': '0563', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 3, 'ad_ids': ['24645130', '24645129', '24597478']},
{'id': 'bm2x_1mr_Qhx', 'name': 'Linköping', 'type': 'municipality', 'code': '0580', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 110,
'ad_ids': ['24650847', '24650299', '24650286', '24650132', '24650066', '24649942', '24649791', '24649190',
'24648447', '24647737']},
{'id': 'SYty_Yho_JAF', 'name': 'Norrköping', 'type': 'municipality', 'code': '0581', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 77,
'ad_ids': ['24645698', '24644342', '24642624', '24642581', '24642596', '24638971', '24637959', '24636774',
'24635847', '24635810']},
{'id': 'Pcv9_yYh_Uw8', 'name': 'Söderköping', 'type': 'municipality', 'code': '0582', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 5,
'ad_ids': ['24643307', '24593500', '24592848', '24579758', '24540435']},
{'id': 'E1MC_1uG_phm', 'name': 'Motala', 'type': 'municipality', 'code': '0583', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 13,
'ad_ids': ['24650644', '24647728', '24647601', '24644258', '24639992', '24635027', '24627968', '24625493',
'24611718', '24574665']},
{'id': 'VcCU_Y86_eKU', 'name': 'Vadstena', 'type': 'municipality', 'code': '0584', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 6,
'ad_ids': ['24636656', '24631849', '24613868', '24605632', '24597399', '24579124']},
{'id': 'stqv_JGB_x8A', 'name': 'Mjölby', 'type': 'municipality', 'code': '0586', 'region_code': '05',
'region_name': 'Östergötlands län', 'hits': 17,
'ad_ids': ['24648019', '24644313', '24632147', '24628098', '24622278', '24616742', '24596459', '24615796',
'24613095', '24605455']},
{'id': 'yaHU_E7z_YnE', 'name': 'Lekeberg', 'type': 'municipality', 'code': '1814', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 3, 'ad_ids': ['24618574', '24590700', '24573858']},
{'id': 'oYEQ_m8Q_unY', 'name': 'Laxå', 'type': 'municipality', 'code': '1860', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 1, 'ad_ids': ['24613284']},
{'id': 'Ak9V_rby_yYS', 'name': 'Hallsberg', 'type': 'municipality', 'code': '1861', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 5, 'ad_ids': ['24645029', '24641916', '24630258', '24625794', '23791205']},
{'id': 'pvzC_muj_rcq', 'name': 'Degerfors', 'type': 'municipality', 'code': '1862', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 2, 'ad_ids': ['24640136', '24612483']},
{'id': 'sCbY_r36_xhs', 'name': 'Hällefors', 'type': 'municipality', 'code': '1863', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 2, 'ad_ids': ['24597505', '24562629']},
{'id': 'eF2n_714_hSU', 'name': 'Ljusnarsberg', 'type': 'municipality', 'code': '1864', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 1, 'ad_ids': ['24620853']},
{'id': 'kuMn_feU_hXx', 'name': 'Örebro', 'type': 'municipality', 'code': '1880', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 83,
'ad_ids': ['24650582', '24650365', '24649289', '24649147', '24648442', '24648272', '24648247', '24647801',
'24646747', '24646234']},
{'id': 'viCA_36P_pQp', 'name': 'Kumla', 'type': 'municipality', 'code': '1881', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 6,
'ad_ids': ['24628041', '24627103', '24620812', '24612404', '24591455', '24525516']},
{'id': 'dbF7_Ecz_CWF', 'name': 'Askersund', 'type': 'municipality', 'code': '1882', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 1, 'ad_ids': ['24614139']},
{'id': 'wgJm_upX_z5W', 'name': 'Karlskoga', 'type': 'municipality', 'code': '1883', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 14,
'ad_ids': ['24641108', '24640044', '24638125', '24627556', '24626010', '24619701', '24614690', '24596123',
'24574044', '24506835']},
{'id': 'WFXN_hsU_gmx', 'name': 'Nora', 'type': 'municipality', 'code': '1884', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 2, 'ad_ids': ['24645958', '24641024']},
{'id': 'JQE9_189_Ska', 'name': 'Lindesberg', 'type': 'municipality', 'code': '1885', 'region_code': '18',
'region_name': 'Örebro län', 'hits': 9,
'ad_ids': ['24621412', '24640141', '24640009', '24631398', '24629694', '24619671', '24594052', '24563255',
'24559937']},
{'id': 'Nufj_vmt_VrH', 'name': 'Skinnskatteberg', 'type': 'municipality', 'code': '1904', 'region_code': '19',
'region_name': 'Västmanlands län', 'hits': 2, 'ad_ids': ['24616844', '24561824']},
{'id': 'jfD3_Hdg_UhT', 'name': 'Surahammar', 'type': 'municipality', 'code': '1907', 'region_code': '19',
'region_name': 'Västmanlands län', 'hits': 2, 'ad_ids': ['24569744', '24569099']},
{'id': 'sD2e_1Tr_4WZ', 'name': 'Heby', 'type': 'municipality', 'code': '0331', 'region_code': '03',
'region_name': 'Uppsala län', 'hits': 6,
'ad_ids': ['24639987', '24637102', '24636561', '24622419', '24609485', '24606439']},
{'id': 'Fac5_h7a_UoM', 'name': 'Kungsör', 'type': 'municipality', 'code': '1960', 'region_code': '19',
'region_name': 'Västmanlands län', 'hits': 1, 'ad_ids': ['24615040']},
{'id': 'oXYf_HmD_ddE', 'name': 'Hallstahammar', 'type': 'municipality', 'code': '1961', 'region_code': '19',
'region_name': 'Västmanlands län', 'hits': 3, 'ad_ids': ['24620856', '24620183', '24570400']},
{'id': 'jbVe_Cps_vtd', 'name': 'Norberg', 'type': 'municipality', 'code': '1962', 'region_code': '19',
'region_name': 'Västmanlands län', 'hits': 1, 'ad_ids': ['24615173']},
{'id': '8deT_FRF_2SP', 'name': 'Västerås', 'type': 'municipality', 'code': '1980', 'region_code': '19',
'region_name': 'Västmanlands län', 'hits': 53,
'ad_ids': ['24650320', '24648681', '24647561', '24647061', '24646018', '24645554', '24645115', '24643524',
'24643419', '24641832']},
{'id': 'dAen_yTK_tqz', 'name': 'Sala', 'type': 'municipality', 'code': '1981', 'region_code': '19',
'region_name': 'Västmanlands län', 'hits': 9,
'ad_ids': ['24647939', '24629771', '24628165', '24627608', '24625106', '24625081', '24618592', '24607178',
'24568713']},
{'id': '7D9G_yrX_AGJ', 'name': 'Fagersta', 'type': 'municipality', 'code': '1982', 'region_code': '19',
'region_name': 'Västmanlands län', 'hits': 6,
'ad_ids': ['24642864', '24636952', '24621583', '24611864', '24610150', '24596200']},
{'id': '4Taz_AuG_tSm', 'name': 'Köping', 'type': 'municipality', 'code': '1983', 'region_code': '19',
'region_name': 'Västmanlands län', 'hits': 5,
'ad_ids': ['24641084', '24633855', '24614521', '24579728', '24554788']},
{'id': 'Jkyb_5MQ_7pB', 'name': 'Arboga', 'type': 'municipality', 'code': '1984', 'region_code': '19',
'region_name': 'Västmanlands län', 'hits': 6,
'ad_ids': ['24634844', '24632224', '24630389', '24629338', '24628382', '24523724']},
{'id': '1gEC_kvM_TXK', 'name': 'Olofström', 'type': 'municipality', 'code': '1060', 'region_code': '10',
'region_name': 'Blekinge län', 'hits': 3, 'ad_ids': ['24650780', '24607103', '24588059']},
{'id': 'YSt4_bAa_ccs', 'name': 'Karlskrona', 'type': 'municipality', 'code': '1080', 'region_code': '10',
'region_name': 'Blekinge län', 'hits': 28,
'ad_ids': ['24651075', '24649518', '24649448', '24645432', '24645121', '24644839', '24628869', '24633251',
'24633023', '24630721']},
{'id': 'vH8x_gVz_z7R', 'name': 'Ronneby', 'type': 'municipality', 'code': '1081', 'region_code': '10',
'region_name': 'Blekinge län', 'hits': 10,
'ad_ids': ['24648307', '24648283', '24635765', '24621669', '24621710', '24620613', '24605177', '24605428',
'24603527', '24590026']},
{'id': 'HtGW_WgR_dpE', 'name': 'Karlshamn', 'type': 'municipality', 'code': '1082', 'region_code': '10',
'region_name': 'Blekinge län', 'hits': 15,
'ad_ids': ['24649847', '24649768', '24647740', '24632517', '24612809', '24607875', '24607874', '24602594',
'24600682', '24600425']},
{'id': 'EVPy_phD_8Vf', 'name': 'Sölvesborg', 'type': 'municipality', 'code': '1083', 'region_code': '10',
'region_name': 'Blekinge län', 'hits': 4, 'ad_ids': ['24644857', '24625704', '24620694', '24535492']},
{'id': '2r6J_g2w_qp5', 'name': 'Svalöv', 'type': 'municipality', 'code': '1214', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 1, 'ad_ids': ['24645986']},
{'id': 'vBrj_bov_KEX', 'name': 'Staffanstorp', 'type': 'municipality', 'code': '1230', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 8,
'ad_ids': ['24648873', '24623551', '24614129', '24598158', '24593510', '24562275', '24565177', '24514487']},
{'id': '64g5_Lio_aMU', 'name': 'Burlöv', 'type': 'municipality', 'code': '1231', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 9,
'ad_ids': ['24649934', '24624002', '24615590', '24596313', '24598750', '24592314', '24583797', '24565624',
'24440835']},
{'id': 'Tcog_5sH_b46', 'name': 'Vellinge', 'type': 'municipality', 'code': '1233', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 3, 'ad_ids': ['24637147', '24622105', '24546803']},
{'id': 'LTt7_CGG_RUf', 'name': '<NAME>', 'type': 'municipality', 'code': '1256', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 4, 'ad_ids': ['24615444', '24610769', '24593919', '24589529']},
{'id': 'nBTS_Nge_dVH', 'name': 'Örkelljunga', 'type': 'municipality', 'code': '1257', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 1, 'ad_ids': ['24620885']},
{'id': 'waQp_FjW_qhF', 'name': 'Bjuv', 'type': 'municipality', 'code': '1260', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 2, 'ad_ids': ['24614178', '24590365']},
{'id': '5ohg_WJU_Ktn', 'name': 'Kävlinge', 'type': 'municipality', 'code': '1261', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 10,
'ad_ids': ['24645728', '24640743', '24637954', '24634361', '24631933', '24622076', '24615122', '24601405',
'24584558', '24570281']},
{'id': 'naG4_AUS_z2v', 'name': 'Lomma', 'type': 'municipality', 'code': '1262', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 10,
'ad_ids': ['24650188', '24649514', '24630578', '24607479', '24607474', '24593043', '24587683', '24555292',
'24549470', '24500680']},
{'id': 'n6r4_fjK_kRr', 'name': 'Svedala', 'type': 'municipality', 'code': '1263', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 4, 'ad_ids': ['24648311', '24624676', '24615959', '24590287']},
{'id': 'oezL_78x_r89', 'name': 'Skurup', 'type': 'municipality', 'code': '1264', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 4, 'ad_ids': ['24606877', '24596998', '24590239', '24555159']},
{'id': 'P3Cs_1ZP_9XB', 'name': 'Sjöbo', 'type': 'municipality', 'code': '1265', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 5, 'ad_ids': ['24636041', '24624217', '24572488', '24562106', '24415688']},
{'id': 'autr_KMa_cfp', 'name': 'Hörby', 'type': 'municipality', 'code': '1266', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 7,
'ad_ids': ['24647623', '24612427', '24598016', '24585770', '24576073', '24575956', '24388252']},
{'id': 'N29z_AqQ_Ppc', 'name': 'Höör', 'type': 'municipality', 'code': '1267', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 8,
'ad_ids': ['24645789', '24611931', '24590427', '24580373', '24533802', '24524712', '24505268', '24495006']},
{'id': 'UMev_wGs_9bg', 'name': 'Tomelilla', 'type': 'municipality', 'code': '1270', 'region_code': '12',
'region_name': '<NAME>', 'hits': 5, 'ad_ids': ['24629168', '24624712', '24621866', '24620688', '24616138']},
{'id': 'WMNK_PXa_Khm', 'name': 'Bromölla', 'type': 'municipality', 'code': '1272', 'region_code': '12',
'region_name': '<NAME>', 'hits': 8,
'ad_ids': ['24648756', '24645758', '24645101', '24624728', '24584175', '24582959', '24513573', '24513519']},
{'id': 'najS_Lvy_mDD', 'name': 'Osby', 'type': 'municipality', 'code': '1273', 'region_code': '12',
'region_name': '<NAME>', 'hits': 6,
'ad_ids': ['24622447', '24612064', '24590486', '24584265', '24570384', '24484317']},
{'id': 'BN7r_iPV_F9p', 'name': 'Perstorp', 'type': 'municipality', 'code': '1275', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 3, 'ad_ids': ['24644535', '24620267', '24590493']},
{'id': 'JARU_FAY_hTS', 'name': 'Klippan', 'type': 'municipality', 'code': '1276', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 11,
'ad_ids': ['24649729', '24645668', '24630230', '24630125', '24627948', '24613981', '24602922', '24592988',
'24587696', '24576122']},
{'id': 'tEv6_ktG_QQb', 'name': 'Åstorp', 'type': 'municipality', 'code': '1277', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 7,
'ad_ids': ['24646009', '24643953', '24611585', '24576459', '24572768', '24572674', '24488210']},
{'id': 'i8vK_odq_6ar', 'name': 'Båstad', 'type': 'municipality', 'code': '1278', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 6,
'ad_ids': ['24648777', '24642713', '24635648', '24546923', '24546926', '24437820']},
{'id': 'oYPt_yRA_Smm', 'name': 'Malmö', 'type': 'municipality', 'code': '1280', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 208,
'ad_ids': ['24650545', '24650520', '24650296', '24650097', '24650060', '24649950', '24648137', '24647586',
'24647704', '24647414']},
{'id': 'muSY_tsR_vDZ', 'name': 'Lund', 'type': 'municipality', 'code': '1281', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 94,
'ad_ids': ['24650438', '24650135', '24649589', '24648781', '24647011', '24647010', '24646930', '24646668',
'24645906', '24645894']},
{'id': 'Yt5s_Vf9_rds', 'name': 'Landskrona', 'type': 'municipality', 'code': '1282', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 13,
'ad_ids': ['24644146', '24644087', '24620576', '24620131', '24615771', '24573791', '24570452', '24567461',
'24540874', '24488640']},
{'id': 'qj3q_oXH_MGR', 'name': 'Helsingborg', 'type': 'municipality', 'code': '1283', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 75,
'ad_ids': ['24649269', '24648344', '24647195', '24645865', '24645699', '24644730', '24644155', '24643877',
'24643808', '24643688']},
{'id': '8QQ6_e95_a1d', 'name': 'Höganäs', 'type': 'municipality', 'code': '1284', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 5, 'ad_ids': ['24634533', '24625162', '24623134', '24620349', '24576341']},
{'id': 'gfCw_egj_1M4', 'name': 'Eslöv', 'type': 'municipality', 'code': '1285', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 7,
'ad_ids': ['24634664', '24629637', '24616790', '24608987', '24607603', '24603214', '24500582']},
{'id': 'hdYk_hnP_uju', 'name': 'Ystad', 'type': 'municipality', 'code': '1286', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 11,
'ad_ids': ['24644036', '24625823', '24601172', '24599304', '24583510', '24574648', '24572130', '24511562',
'24511260', '24473915']},
{'id': 'STvk_dra_M1X', 'name': 'Trelleborg', 'type': 'municipality', 'code': '1287', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 18,
'ad_ids': ['24649417', '24645920', '24645911', '24640015', '24632826', '24630587', '24614377', '24608596',
'24608211', '24604616']},
{'id': 'vrvW_sr8_1en', 'name': 'Kristianstad', 'type': 'municipality', 'code': '1290', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 36,
'ad_ids': ['24649118', '24646547', '24645051', '24642902', '24639033', '24636394', '24636028', '24633571',
'24631796', '24623098']},
{'id': 'dLxo_EpC_oPe', 'name': 'Simrishamn', 'type': 'municipality', 'code': '1291', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 5, 'ad_ids': ['24636522', '24601452', '24550006', '24554806', '24502004']},
{'id': 'pCuv_P5A_9oh', 'name': 'Ängelholm', 'type': 'municipality', 'code': '1292', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 29,
'ad_ids': ['24648062', '24646052', '24645263', '24644897', '24643870', '24643102', '24642941', '24641238',
'24641268', '24635578']},
{'id': 'bP5q_53x_aqJ', 'name': 'Hässleholm', 'type': 'municipality', 'code': '1293', 'region_code': '12',
'region_name': 'Skåne län', 'hits': 20,
'ad_ids': ['24645166', '24639356', '24625756', '24621467', '24614517', '24615762', '24610880', '24605726',
'24588549', '24597762']},
{'id': 'ocMw_Rz5_B1L', 'name': 'Kil', 'type': 'municipality', 'code': '1715', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 3, 'ad_ids': ['24649278', '24649261', '24492496']},
{'id': 'N5HQ_hfp_7Rm', 'name': 'Eda', 'type': 'municipality', 'code': '1730', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 8,
'ad_ids': ['24650359', '24649389', '24641459', '24638309', '24625958', '24625946', '24621089', '24601242']},
{'id': 'hQdb_zn9_Sok', 'name': 'Torsby', 'type': 'municipality', 'code': '1737', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 6,
'ad_ids': ['24649740', '24649672', '24641489', '24622563', '24547171', '24539768']},
{'id': 'mPt5_3QD_LTM', 'name': 'Storfors', 'type': 'municipality', 'code': '1760', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 2, 'ad_ids': ['24605489', '24586914']},
{'id': 'x5qW_BXr_aut', 'name': 'Hammarö', 'type': 'municipality', 'code': '1761', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 2, 'ad_ids': ['24612858', '24606451']},
{'id': 'x73h_7rW_mXN', 'name': 'Munkfors', 'type': 'municipality', 'code': '1762', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 1, 'ad_ids': ['24546455']},
{'id': 'xnEt_JN3_GkA', 'name': 'Forshaga', 'type': 'municipality', 'code': '1763', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 2, 'ad_ids': ['24612399', '24602480']},
{'id': 'PSNt_P95_x6q', 'name': 'Grums', 'type': 'municipality', 'code': '1764', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 2, 'ad_ids': ['24539560', '24566552']},
{'id': 'ymBu_aFc_QJA', 'name': 'Årjäng', 'type': 'municipality', 'code': '1765', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 1, 'ad_ids': ['24621703']},
{'id': 'oqNH_cnJ_Tdi', 'name': 'Sunne', 'type': 'municipality', 'code': '1766', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 4, 'ad_ids': ['24642867', '24622363', '24601636', '24590484']},
{'id': 'hRDj_PoV_sFU', 'name': 'Karlstad', 'type': 'municipality', 'code': '1780', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 49,
'ad_ids': ['24650860', '24645012', '24642294', '24641834', '24641215', '24641140', '24639997', '24637408',
'24635991', '24635497']},
{'id': 'SVQS_uwJ_m2B', 'name': 'Kristinehamn', 'type': 'municipality', 'code': '1781', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 5, 'ad_ids': ['24649351', '24646057', '24617982', '24610610', '24535779']},
{'id': 'UXir_vKD_FuW', 'name': 'Filipstad', 'type': 'municipality', 'code': '1782', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 0, 'ad_ids': []},
{'id': 'qk9a_g5U_sAH', 'name': 'Hagfors', 'type': 'municipality', 'code': '1783', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 3, 'ad_ids': ['24632958', '24614330', '24504796']},
{'id': 'yGue_F32_wev', 'name': 'Arvika', 'type': 'municipality', 'code': '1784', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 5, 'ad_ids': ['24626919', '24595432', '24594812', '24591333', '24532373']},
{'id': 'wmxQ_Guc_dsy', 'name': 'Säffle', 'type': 'municipality', 'code': '1785', 'region_code': '17',
'region_name': 'Värmlands län', 'hits': 5, 'ad_ids': ['24649317', '24612041', '24574208', '24558595', '24381921']},
{'id': '4eS9_HX1_M7V', 'name': 'Vansbro', 'type': 'municipality', 'code': '2021', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 2, 'ad_ids': ['24602964', '24464433']},
{'id': 'FPCd_poj_3tq', 'name': 'Malung-Sälen', 'type': 'municipality', 'code': '2023', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 5, 'ad_ids': ['24649158', '24617319', '24608124', '24606239', '24544803']},
{'id': 'Nn7p_W3Z_y68', 'name': 'Gagnef', 'type': 'municipality', 'code': '2026', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 1, 'ad_ids': ['24649209']},
{'id': '7Zsu_ant_gcn', 'name': 'Leksand', 'type': 'municipality', 'code': '2029', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 3, 'ad_ids': ['24640824', '24626128', '24571716']},
{'id': 'Jy3D_2ux_dg8', 'name': 'Rättvik', 'type': 'municipality', 'code': '2031', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 4, 'ad_ids': ['24647031', '24647028', '24621580', '24595880']},
{'id': 'CRyF_5Jg_4ht', 'name': 'Orsa', 'type': 'municipality', 'code': '2034', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 6,
'ad_ids': ['24629334', '24608617', '24566875', '24561183', '24523938', '24488375']},
{'id': 'cZtt_qGo_oBr', 'name': 'Älvdalen', 'type': 'municipality', 'code': '2039', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 4, 'ad_ids': ['24626713', '24621302', '24576229', '24576225']},
{'id': '5zZX_8FH_Sbq', 'name': 'Smedjebacken', 'type': 'municipality', 'code': '2061', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 3, 'ad_ids': ['24645686', '24645204', '24593349']},
{'id': 'UGcC_kYx_fTs', 'name': 'Mora', 'type': 'municipality', 'code': '2062', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 12,
'ad_ids': ['24648097', '24624498', '24623037', '24623017', '24593694', '24587438', '24585960', '24572253',
'24548037', '24539727']},
{'id': 'N1wJ_Cuu_7Cs', 'name': 'Falun', 'type': 'municipality', 'code': '2080', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 33,
'ad_ids': ['24649195', '24646230', '24642403', '24640180', '24639093', '24637700', '24633983', '24628486',
'24622858', '24621668']},
{'id': 'cpya_jJg_pGp', 'name': 'Borlänge', 'type': 'municipality', 'code': '2081', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 22,
'ad_ids': ['24648735', '24645716', '24643955', '24640978', '24638705', '24634803', '24627930', '24624426',
'24620908', '24615413']},
{'id': 'c3Zx_jBf_CqF', 'name': 'Säter', 'type': 'municipality', 'code': '2082', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 3, 'ad_ids': ['24646152', '24564510', '24638537']},
{'id': 'DE9u_V4K_Z1S', 'name': 'Hedemora', 'type': 'municipality', 'code': '2083', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 5, 'ad_ids': ['24617875', '24596329', '24595146', '24577346', '24518006']},
{'id': 'Szbq_2fg_ydQ', 'name': 'Avesta', 'type': 'municipality', 'code': '2084', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 4, 'ad_ids': ['24643237', '24616778', '24612778', '24596510']},
{'id': 'Ny2b_2bo_7EL', 'name': 'Ludvika', 'type': 'municipality', 'code': '2085', 'region_code': '20',
'region_name': 'Dalarnas län', 'hits': 15,
'ad_ids': ['24641952', '24640038', '24636562', '24636403', '24636399', '24636392', '24627279', '24618666',
'24608534', '24607134']},
{'id': 'GEvW_wKy_A9H', 'name': 'Ockelbo', 'type': 'municipality', 'code': '2101', 'region_code': '21',
'region_name': 'Gävleborgs län', 'hits': 3, 'ad_ids': ['24647677', '24644885', '24636701']},
{'id': 'yuNd_3bg_ttc', 'name': 'Hofors', 'type': 'municipality', 'code': '2104', 'region_code': '21',
'region_name': 'Gävleborgs län', 'hits': 2, 'ad_ids': ['24643718', '24638172']},
{'id': 'JPSe_mUQ_NDs', 'name': 'Ovanåker', 'type': 'municipality', 'code': '2121', 'region_code': '21',
'region_name': 'Gävleborgs län', 'hits': 3, 'ad_ids': ['24648796', '24626141', '24588647']},
{'id': 'fFeF_RCz_Tm5', 'name': 'Nordanstig', 'type': 'municipality', 'code': '2132', 'region_code': '21',
'region_name': 'Gävleborgs län', 'hits': 0, 'ad_ids': []},
{'id': '63iQ_V6F_REB', 'name': 'Ljusdal', 'type': 'municipality', 'code': '2161', 'region_code': '21',
'region_name': 'Gävleborgs län', 'hits': 3, 'ad_ids': ['24624560', '24621604', '24604812']},
{'id': 'qk8Y_2b6_82D', 'name': 'Gävle', 'type': 'municipality', 'code': '2180', 'region_code': '21',
'region_name': 'Gävleborgs län', 'hits': 61,
'ad_ids': ['24648286', '24647457', '24645453', '24643119', '24641947', '24641752', '24641744', '24639606',
'24639443', '24638181']},
{'id': 'BbdN_xLB_k6s', 'name': 'Sandviken', 'type': 'municipality', 'code': '2181', 'region_code': '21',
'region_name': 'Gävleborgs län', 'hits': 11,
'ad_ids': ['24640410', '24639185', '24630586', '24610267', '24602729', '24587145', '24586302', '24578542',
'24576851', '24558652']},
{'id': 'JauG_nz5_7mu', 'name': 'Söderhamn', 'type': 'municipality', 'code': '2182', 'region_code': '21',
'region_name': 'Gävleborgs län', 'hits': 6,
'ad_ids': ['24640054', '24616079', '24614547', '24595502', '24503253', '24488845']},
{'id': 'KxjG_ig5_exF', 'name': 'Bollnäs', 'type': 'municipality', 'code': '2183', 'region_code': '21',
'region_name': 'Gävleborgs län', 'hits': 12,
'ad_ids': ['24647491', '24623857', '24623859', '24632941', '24631240', '24613810', '24612003', '24590238',
'24590045', '24548369']},
{'id': 'Utks_mwF_axY', 'name': 'Hudiksvall', 'type': 'municipality', 'code': '2184', 'region_code': '21',
'region_name': 'Gävleborgs län', 'hits': 26,
'ad_ids': ['24650607', '24650499', '24649045', '24648589', '24641095', '24641643', '24641698', '24647095',
'24646916', '24645190']},
{'id': 'swVa_cyS_EMN', 'name': 'Ånge', 'type': 'municipality', 'code': '2260', 'region_code': '22',
'region_name': 'Västernorrlands län', 'hits': 4, 'ad_ids': ['24639288', '24628389', '24610700', '24460553']},
{'id': 'oJ8D_rq6_kjt', 'name': 'Timrå', 'type': 'municipality', 'code': '2262', 'region_code': '22',
'region_name': 'Västernorrlands län', 'hits': 5,
'ad_ids': ['24649312', '24628388', '24620973', '24579351', '24504810']},
{'id': 'uYRx_AdM_r4A', 'name': 'Härnösand', 'type': 'municipality', 'code': '2280', 'region_code': '22',
'region_name': 'Västernorrlands län', 'hits': 14,
'ad_ids': ['24649670', '24634810', '24626434', '24626359', '24610521', '24604584', '24599753', '24595015',
'24588000', '24568790']},
{'id': 'dJbx_FWY_tK6', 'name': 'Sundsvall', 'type': 'municipality', 'code': '2281', 'region_code': '22',
'region_name': 'Västernorrlands län', 'hits': 58,
'ad_ids': ['24650752', '24650176', '24650130', '24650080', '24649995', '24649952', '24648358', '24646387',
'24645570', '24645032']},
{'id': 'yR8g_7Jz_HBZ', 'name': 'Kramfors', 'type': 'municipality', 'code': '2282', 'region_code': '22',
'region_name': 'Västernorrlands län', 'hits': 8,
'ad_ids': ['24649705', '24633992', '24633462', '24627834', '24587306', '24582328', '24574236', '24550420']},
{'id': 'v5y4_YPe_TMZ', 'name': 'Sollefteå', 'type': 'municipality', 'code': '2283', 'region_code': '22',
'region_name': 'Västernorrlands län', 'hits': 9,
'ad_ids': ['24649400', '24649380', '24642982', '24642980', '24634683', '24605190', '24588189', '24540108',
'24455320']},
{'id': 'zBmE_n6s_MnQ', 'name': 'Örnsköldsvik', 'type': 'municipality', 'code': '2284', 'region_code': '22',
'region_name': 'Västernorrlands län', 'hits': 23,
'ad_ids': ['24650185', '24649663', '24648830', '24648370', '24646067', '24643411', '24641851', '24634399',
'24632450', '24624920']},
{'id': 'Voto_egJ_FZP', 'name': 'Ragunda', 'type': 'municipality', 'code': '2303', 'region_code': '23',
'region_name': 'Jämtlands län', 'hits': 0, 'ad_ids': []},
{'id': 'eNSc_Nj1_CDP', 'name': 'Bräcke', 'type': 'municipality', 'code': '2305', 'region_code': '23',
'region_name': 'Jämtlands län', 'hits': 1, 'ad_ids': ['24615354']},
{'id': 'yurW_aLE_4ga', 'name': 'Krokom', 'type': 'municipality', 'code': '2309', 'region_code': '23',
'region_name': 'Jämtlands län', 'hits': 0, 'ad_ids': []},
{'id': 'ppjq_Eci_Wz9', 'name': 'Strömsund', 'type': 'municipality', 'code': '2313', 'region_code': '23',
'region_name': 'Jämtlands län', 'hits': 6,
'ad_ids': ['24646613', '24635521', '24634425', '24611237', '24608422', '24566029']},
{'id': 'D7ax_CXP_6r1', 'name': 'Åre', 'type': 'municipality', 'code': '2321', 'region_code': '23',
'region_name': 'Jämtlands län', 'hits': 2, 'ad_ids': ['24587180', '24572426']},
{'id': 'gRNJ_hVW_Gpg', 'name': 'Berg', 'type': 'municipality', 'code': '2326', 'region_code': '23',
'region_name': 'Jämtlands län', 'hits': 1, 'ad_ids': ['24626189']},
{'id': 'j35Q_VKL_NiM', 'name': 'Härjedalen', 'type': 'municipality', 'code': '2361', 'region_code': '23',
'region_name': 'Jämtlands län', 'hits': 8,
'ad_ids': ['24650648', '24649337', '24648475', '24626268', '24615961', '24600435', '24565037', '24560583']},
{'id': 'Vt7P_856_WZS', 'name': 'Östersund', 'type': 'municipality', 'code': '2380', 'region_code': '23',
'region_name': 'Jämtlands län', 'hits': 36,
'ad_ids': ['24650954', '24650862', '24648805', '24647118', '24640165', '24637613', '24634928', '24634409',
'24633737', '24631136']},
{'id': 'wMab_4Zs_wpM', 'name': 'Nordmaling', 'type': 'municipality', 'code': '2401', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 2, 'ad_ids': ['24588012', '24494081']},
{'id': 'vQkf_tw2_CmR', 'name': 'Bjurholm', 'type': 'municipality', 'code': '2403', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 0, 'ad_ids': []},
{'id': 'izT6_zWu_tta', 'name': 'Vindeln', 'type': 'municipality', 'code': '2404', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 4, 'ad_ids': ['24610047', '24595064', '24585738', '24581311']},
{'id': 'p8Mv_377_bxp', 'name': 'Robertsfors', 'type': 'municipality', 'code': '2409', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 1, 'ad_ids': ['24643631']},
{'id': 'XmpG_vPQ_K7T', 'name': 'Norsjö', 'type': 'municipality', 'code': '2417', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 1, 'ad_ids': ['24577456']},
{'id': '7sHJ_YCE_5Zv', 'name': 'Malå', 'type': 'municipality', 'code': '2418', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 1, 'ad_ids': ['24641503']},
{'id': 'gQgT_BAk_fMu', 'name': 'Storuman', 'type': 'municipality', 'code': '2421', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 3, 'ad_ids': ['24648927', '24612310', '24551322']},
{'id': 'VM7L_yJK_Doo', 'name': 'Sorsele', 'type': 'municipality', 'code': '2422', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 1, 'ad_ids': ['24644670']},
{'id': 'tSkf_Tbn_rHk', 'name': 'Dorotea', 'type': 'municipality', 'code': '2425', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 2, 'ad_ids': ['24648188', '24551059']},
{'id': 'utQc_6xq_Dfm', 'name': 'Vännäs', 'type': 'municipality', 'code': '2460', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 1, 'ad_ids': ['24477260']},
{'id': 'tUnW_mFo_Hvi', 'name': 'Vilhelmina', 'type': 'municipality', 'code': '2462', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 3, 'ad_ids': ['24650955', '24646598', '24389476']},
{'id': 'xLdL_tMA_JJv', 'name': 'Åsele', 'type': 'municipality', 'code': '2463', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 2, 'ad_ids': ['24635862', '24596209']},
{'id': 'QiGt_BLu_amP', 'name': 'Umeå', 'type': 'municipality', 'code': '2480', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 61,
'ad_ids': ['24651085', '24650971', '24649245', '24649034', '24648882', '24647955', '24647299', '24646501',
'24643021', '24642426']},
{'id': '7rpN_naz_3Uz', 'name': 'Lycksele', 'type': 'municipality', 'code': '2481', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 5,
'ad_ids': ['24650360', '24636787', '24624131', '24584326', '24461658']},
{'id': 'kicB_LgH_2Dk', 'name': 'Skellefteå', 'type': 'municipality', 'code': '2482', 'region_code': '24',
'region_name': 'Västerbottens län', 'hits': 26,
'ad_ids': ['24650579', '24650245', '24647140', '24646439', '24644842', '24644817', '24641617', '24639673',
'24633366', '24629478']},
{'id': 'A5WX_XVo_Zt6', 'name': 'Arvidsjaur', 'type': 'municipality', 'code': '2505', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 0, 'ad_ids': []},
{'id': 'vkQW_GB6_MNk', 'name': 'Arjeplog', 'type': 'municipality', 'code': '2506', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 4, 'ad_ids': ['24650467', '24594796', '24505073', '24488974']},
{'id': 'mp6j_2b6_1bz', 'name': 'Jokkmokk', 'type': 'municipality', 'code': '2510', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 2, 'ad_ids': ['24636604', '24629767']},
{'id': 'n5Sq_xxo_QWL', 'name': 'Överkalix', 'type': 'municipality', 'code': '2513', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 2, 'ad_ids': ['24626297', '24562294']},
{'id': 'cUyN_C9V_HLU', 'name': 'Kalix', 'type': 'municipality', 'code': '2514', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 7,
'ad_ids': ['24650117', '24647684', '24617672', '24610596', '24598334', '24578326', '24549825']},
{'id': 'ehMP_onv_Chk', 'name': 'Övertorneå', 'type': 'municipality', 'code': '2518', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 2, 'ad_ids': ['24615259', '24602364']},
{'id': 'dHMF_72G_4NM', 'name': 'Pajala', 'type': 'municipality', 'code': '2521', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 5,
'ad_ids': ['24613530', '24579678', '24421022', '24421085', '24421026']},
{'id': '6R2u_zkb_uoS', 'name': 'Gällivare', 'type': 'municipality', 'code': '2523', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 12,
'ad_ids': ['24650616', '24647793', '24646122', '24646015', '24645490', '24639665', '24631189', '24626915',
'24620850', '24613056']},
{'id': '14WF_zh1_W3y', 'name': 'Älvsbyn', 'type': 'municipality', 'code': '2560', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 1, 'ad_ids': ['24648879']},
{'id': 'CXbY_gui_14v', 'name': 'Luleå', 'type': 'municipality', 'code': '2580', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 54,
'ad_ids': ['24650277', '24649382', '24646536', '24646256', '24645408', '24645272', '24644929', '24642846',
'24640988', '24637961']},
{'id': 'umej_bP2_PpK', 'name': 'Piteå', 'type': 'municipality', 'code': '2581', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 21,
'ad_ids': ['24647791', '24646569', '24646410', '24642289', '24640981', '24629378', '24627010', '24615196',
'24614741', '24613745']},
{'id': 'y4NQ_tnB_eVd', 'name': 'Boden', 'type': 'municipality', 'code': '2582', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 6,
'ad_ids': ['24641061', '24625531', '24621825', '24593711', '24591832', '24547017']},
{'id': 'tfRE_hXa_eq7', 'name': 'Haparanda', 'type': 'municipality', 'code': '2583', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 3, 'ad_ids': ['24649761', '24641448', '24585171']},
{'id': 'biN6_UiL_Qob', 'name': 'Kiruna', 'type': 'municipality', 'code': '2584', 'region_code': '25',
'region_name': 'Norrbottens län', 'hits': 18,
'ad_ids': ['24649230', '24637663', '24620869', '24616612', '24609586', '24609582', '24607586', '24605447',
'24604398', '24594403']},
{'id': 'y9HE_XD7_WaD', 'name': 'Aneby', 'type': 'municipality', 'code': '0604', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 2, 'ad_ids': ['24623297', '24579234']},
{'id': '91VR_Hxi_GN4', 'name': 'Gnosjö', 'type': 'municipality', 'code': '0617', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 5,
'ad_ids': ['24628681', '24604131', '24590061', '24566659', '24558133']},
{'id': 'smXg_BXp_jTW', 'name': 'Mullsjö', 'type': 'municipality', 'code': '0642', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 5,
'ad_ids': ['24643973', '24607032', '24606628', '24577681', '24537205']},
{'id': '9zQB_3vU_BQA', 'name': 'Habo', 'type': 'municipality', 'code': '0643', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 1, 'ad_ids': ['24579245']},
{'id': 'cNQx_Yqi_83Q', 'name': 'Gislaved', 'type': 'municipality', 'code': '0662', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 9,
'ad_ids': ['24613432', '24626013', '24612979', '24609415', '24604594', '24601733', '24599387', '24593831',
'24586269']},
{'id': 'zFup_umX_LVv', 'name': 'Vaggeryd', 'type': 'municipality', 'code': '0665', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 5,
'ad_ids': ['24647651', '24633078', '24629708', '24550532', '24583814']},
{'id': 'KURg_KJF_Lwc', 'name': 'Jönköping', 'type': 'municipality', 'code': '0680', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 85,
'ad_ids': ['24651032', '24650982', '24650248', '24648832', '24647954', '24647864', '24644298', '24647107',
'24644341', '24644259']},
{'id': 'KfXT_ySA_do2', 'name': 'Nässjö', 'type': 'municipality', 'code': '0682', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 10,
'ad_ids': ['24644891', '24639953', '24633087', '24629181', '24621427', '24613566', '24610827', '24589332',
'24575224', '24528277']},
{'id': '6bS8_fzf_xpW', 'name': 'Värnamo', 'type': 'municipality', 'code': '0683', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 26,
'ad_ids': ['24641062', '24634862', '24632296', '24631196', '24627728', '24623817', '24622843', '24620357',
'24620014', '24614169']},
{'id': 'L1cX_MjM_y8W', 'name': 'Sävsjö', 'type': 'municipality', 'code': '0684', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 7,
'ad_ids': ['24640990', '24631381', '24612486', '24597187', '24581570', '24534133', '24468408']},
{'id': 'xJqx_SLC_415', 'name': 'Vetlanda', 'type': 'municipality', 'code': '0685', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 16,
'ad_ids': ['24643277', '24641529', '24640373', '24637057', '24628455', '24627538', '24627537', '24621685',
'24613356', '24609736']},
{'id': 'VacK_WF6_XVg', 'name': 'Eksjö', 'type': 'municipality', 'code': '0686', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 14,
'ad_ids': ['24637053', '24632911', '24615733', '24617245', '24609055', '24599160', '24597461', '24594324',
'24586118', '24585765']},
{'id': 'Namm_SpC_RPG', 'name': 'Tranås', 'type': 'municipality', 'code': '0687', 'region_code': '06',
'region_name': 'Jönköpings län', 'hits': 10,
'ad_ids': ['24642284', '24641464', '24626417', '24623265', '24619248', '24618419', '24590114', '24499769',
'24476521', '24433907']},
{'id': '78cu_S5T_Pgp', 'name': 'Uppvidinge', 'type': 'municipality', 'code': '0760', 'region_code': '07',
'region_name': 'Kronobergs län', 'hits': 3, 'ad_ids': ['24639253', '24617976', '24414696']},
{'id': 'nXZy_1Jd_D8X', 'name': 'Lessebo', 'type': 'municipality', 'code': '0761', 'region_code': '07',
'region_name': 'Kronobergs län', 'hits': 1, 'ad_ids': ['24538499']},
{'id': 'qz8Q_kDz_N2Y', 'name': 'Tingsryd', 'type': 'municipality', 'code': '0763', 'region_code': '07',
'region_name': 'Kronobergs län', 'hits': 4, 'ad_ids': ['24641348', '24624969', '24511207', '24491412']},
{'id': 'MMph_wmN_esc', 'name': 'Alvesta', 'type': 'municipality', 'code': '0764', 'region_code': '07',
'region_name': 'Kronobergs län', 'hits': 5,
'ad_ids': ['24650556', '24621112', '24617389', '24576031', '24476169']},
{'id': 'EK6X_wZq_CQ8', 'name': 'Älmhult', 'type': 'municipality', 'code': '0765', 'region_code': '07',
'region_name': 'Kronobergs län', 'hits': 11,
'ad_ids': ['24649769', '24649654', '24641236', '24641229', '24638136', '24632509', '24631497', '24625110',
'24617479', '24614602']},
{'id': 'ZhVf_yL5_Q5g', 'name': 'Markaryd', 'type': 'municipality', 'code': '0767', 'region_code': '07',
'region_name': 'Kronobergs län', 'hits': 10,
'ad_ids': ['24629043', '24643980', '24643878', '24639757', '24637755', '24627553', '24618793', '24583008',
'24553167', '24470454']},
{'id': 'mmot_H3A_auW', 'name': 'Växjö', 'type': 'municipality', 'code': '0780', 'region_code': '07',
'region_name': 'Kronobergs län', 'hits': 68,
'ad_ids': ['24649803', '24649739', '24649728', '24647829', '24647003', '24644326', '24644173', '24643867',
'24643342', '24641504']},
{'id': 'GzKo_S48_QCm', 'name': 'Ljungby', 'type': 'municipality', 'code': '0781', 'region_code': '07',
'region_name': 'Kronobergs län', 'hits': 11,
'ad_ids': ['24648839', '24648771', '24645854', '24643124', '24637014', '24636725', '24635767', '24633273',
'24624230', '24622854']},
{'id': 'WPDh_pMr_RLZ', 'name': 'Högsby', 'type': 'municipality', 'code': '0821', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 2, 'ad_ids': ['24640369', '24636070']},
{'id': 'wYFb_q7w_Nnh', 'name': 'Torsås', 'type': 'municipality', 'code': '0834', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 4, 'ad_ids': ['24620345', '24621317', '24604125', '24566576']},
{'id': 'Muim_EAi_EFp', 'name': 'Mörbylånga', 'type': 'municipality', 'code': '0840', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 9,
'ad_ids': ['24638175', '24629762', '24627653', '24611449', '24607639', '24594093', '24572030', '24546217',
'24488349']},
{'id': 'AEQD_1RT_vM9', 'name': 'Hultsfred', 'type': 'municipality', 'code': '0860', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 9,
'ad_ids': ['24648249', '24644661', '24636959', '24627269', '24627176', '24620579', '24588831', '24527019',
'24510303']},
{'id': '8eEp_iz4_cNN', 'name': 'Mönsterås', 'type': 'municipality', 'code': '0861', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 5, 'ad_ids': ['24648226', '24625464', '24618320', '24583746', '24573755']},
{'id': '1koj_6Bg_8K6', 'name': 'Emmaboda', 'type': 'municipality', 'code': '0862', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 2, 'ad_ids': ['24635771', '24615839']},
{'id': 'Pnmg_SgP_uHQ', 'name': 'Kalmar', 'type': 'municipality', 'code': '0880', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 52,
'ad_ids': ['24649776', '24649356', '24648115', '24647817', '24647756', '24643992', '24643651', '24641992',
'24641371', '24613487']},
{'id': 'xk68_bJa_6Fh', 'name': 'Nybro', 'type': 'municipality', 'code': '0881', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 6,
'ad_ids': ['24649149', '24638088', '24631517', '24625340', '24621795', '24612228']},
{'id': 'tUP8_hRE_NcF', 'name': 'Oskarshamn', 'type': 'municipality', 'code': '0882', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 14,
'ad_ids': ['24648664', '24648628', '24646920', '24645350', '24640633', '24635629', '24630203', '24628734',
'24624215', '24617181']},
{'id': 't7H4_S2P_3Fw', 'name': 'Västervik', 'type': 'municipality', 'code': '0883', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 18,
'ad_ids': ['24647144', '24641319', '24634992', '24632176', '24628636', '24618501', '24617706', '24614479',
'24608624', '24603700']},
{'id': 'a7hJ_zwv_2FR', 'name': 'Vimmerby', 'type': 'municipality', 'code': '0884', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 15,
'ad_ids': ['24642646', '24642469', '24634998', '24632703', '24628660', '24619779', '24619775', '24614093',
'24593900', '24590275']},
{'id': 'LY9i_qNL_kXf', 'name': 'Borgholm', 'type': 'municipality', 'code': '0885', 'region_code': '08',
'region_name': 'Kalmar län', 'hits': 4, 'ad_ids': ['24631885', '24600006', '24575680', '24496816']},
{'id': 'Ft9P_E8F_VLJ', 'name': 'Gotland', 'type': 'municipality', 'code': '0980', 'region_code': '09',
'region_name': 'Gotlands län', 'hits': 32,
'ad_ids': ['24649062', '24646081', '24645577', '24643883', '24641060', '24637605', '24637052', '24636730',
'24631180', '24631256']},
{'id': '3XMe_nGt_RcU', 'name': 'Hylte', 'type': 'municipality', 'code': '1315', 'region_code': '13',
'region_name': 'Hallands län', 'hits': 7,
'ad_ids': ['24647998', '24646997', '24645469', '24640710', '24633518', '24629087', '24575788']},
{'id': 'kUQB_KdK_kAh', 'name': 'Halmstad', 'type': 'municipality', 'code': '1380', 'region_code': '13',
'region_name': 'Hallands län', 'hits': 48,
'ad_ids': ['24650491', '24649086', '24648647', '24647496', '24646397', '24646379', '24645317', '24644390',
'24643943', '24643937']},
{'id': 'c1iL_rqh_Zja', 'name': 'Laholm', 'type': 'municipality', 'code': '1381', 'region_code': '13',
'region_name': 'Hallands län', 'hits': 7,
'ad_ids': ['24637743', '24624670', '24624583', '24615475', '24614113', '24588536', '24552904']},
{'id': 'qaJg_wMR_C8T', 'name': 'Falkenberg', 'type': 'municipality', 'code': '1382', 'region_code': '13',
'region_name': 'Hallands län', 'hits': 26,
'ad_ids': ['24650289', '24646671', '24644450', '24644424', '24638795', '24638078', '24635865', '24635663',
'24630122', '24612894']},
{'id': 'AkUx_yAq_kGr', 'name': 'Varberg', 'type': 'municipality', 'code': '1383', 'region_code': '13',
'region_name': 'Hallands län', 'hits': 34,
'ad_ids': ['24650646', '24648999', '24648048', '24647269', '24647256', '24646756', '24646453', '24646370',
'24646335', '24646315']},
{'id': '3JKV_KSK_x6z', 'name': 'Kungsbacka', 'type': 'municipality', 'code': '1384', 'region_code': '13',
'region_name': 'Hallands län', 'hits': 16,
'ad_ids': ['24650147', '24650006', '24640093', '24638112', '24635197', '24632626', '24630508', '24624655',
'24622514', '24607841']},
{'id': 'dzWW_R3G_6Eh', 'name': 'Härryda', 'type': 'municipality', 'code': '1401', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 7,
'ad_ids': ['24631009', '24621857', '24606754', '24587980', '24587111', '24568233', '24531121']},
{'id': 'CCiR_sXa_BVW', 'name': 'Partille', 'type': 'municipality', 'code': '1402', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 9,
'ad_ids': ['24644886', '24643254', '24642579', '24642082', '24623735', '24612128', '24611787', '24502309',
'24468685']},
{'id': 'Zjiv_rhk_oJK', 'name': 'Öckerö', 'type': 'municipality', 'code': '1407', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 2, 'ad_ids': ['24616589', '24601739']},
{'id': 'wHrG_FBH_hoD', 'name': 'Stenungsund', 'type': 'municipality', 'code': '1415', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 5,
'ad_ids': ['24635632', '24628237', '24612130', '24606880', '24587131']},
{'id': 'TbL3_HmF_gnx', 'name': 'Tjörn', 'type': 'municipality', 'code': '1419', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 2, 'ad_ids': ['24594903', '24590040']},
{'id': 'tmAp_ykH_N6k', 'name': 'Orust', 'type': 'municipality', 'code': '1421', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 5,
'ad_ids': ['24642072', '24596275', '24586295', '24541260', '24519447']},
{'id': 'aKkp_sEX_cVM', 'name': 'Sotenäs', 'type': 'municipality', 'code': '1427', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 6,
'ad_ids': ['24612938', '24564119', '24535667', '24520889', '24500709', '24485653']},
{'id': '96Dh_3sQ_RFb', 'name': 'Munkedal', 'type': 'municipality', 'code': '1430', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 3, 'ad_ids': ['24641856', '24624344', '24595408']},
{'id': 'qffn_qY4_DLk', 'name': 'Tanum', 'type': 'municipality', 'code': '1435', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 8,
'ad_ids': ['24627761', '24623563', '24623580', '24621916', '24610846', '24608306', '24607156', '24600587']},
{'id': 'NMc9_oEm_yxy', 'name': 'Dals-Ed', 'type': 'municipality', 'code': '1438', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 0, 'ad_ids': []},
{'id': 'kCHb_icw_W5E', 'name': 'Färgelanda', 'type': 'municipality', 'code': '1439', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 2, 'ad_ids': ['24639807', '24556773']},
{'id': '17Ug_Btv_mBr', 'name': 'Ale', 'type': 'municipality', 'code': '1440', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 3, 'ad_ids': ['24636146', '24628807', '24616322']},
{'id': 'yHV7_2Y6_zQx', 'name': 'Lerum', 'type': 'municipality', 'code': '1441', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 4, 'ad_ids': ['24650394', '24620026', '24603503', '24588967']},
{'id': 'NfFx_5jj_ogg', 'name': 'Vårgårda', 'type': 'municipality', 'code': '1442', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 5,
'ad_ids': ['24648984', '24648901', '24613448', '24595489', '24497926']},
{'id': 'ypAQ_vTD_KLU', 'name': 'Bollebygd', 'type': 'municipality', 'code': '1443', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 1, 'ad_ids': ['24576508']},
{'id': 'ZNZy_Hh5_gSW', 'name': 'Grästorp', 'type': 'municipality', 'code': '1444', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 0, 'ad_ids': []},
{'id': 'ZzEA_2Fg_Pt2', 'name': 'Essunga', 'type': 'municipality', 'code': '1445', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 2, 'ad_ids': ['24626743', '24523562']},
{'id': 'e413_94L_hdh', 'name': 'Karlsborg', 'type': 'municipality', 'code': '1446', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 0, 'ad_ids': []},
{'id': 'roiB_uVV_4Cj', 'name': 'Gullspång', 'type': 'municipality', 'code': '1447', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 1, 'ad_ids': ['24643272']},
{'id': 'SEje_LdC_9qN', 'name': 'Tranemo', 'type': 'municipality', 'code': '1452', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 6,
'ad_ids': ['24645375', '24615877', '24608246', '24595425', '24595398', '24589648']},
{'id': 'hejM_Jct_XJk', 'name': 'Bengtsfors', 'type': 'municipality', 'code': '1460', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 5,
'ad_ids': ['24628976', '24627769', '24606787', '24606679', '24606575']},
{'id': 'tt1B_7rH_vhG', 'name': 'Mellerud', 'type': 'municipality', 'code': '1461', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 4, 'ad_ids': ['24644889', '24638627', '24615086', '24614249']},
{'id': 'YQcE_SNB_Tv3', 'name': '<NAME>', 'type': 'municipality', 'code': '1462', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 4, 'ad_ids': ['24642553', '24632874', '24622421', '24610751']},
{'id': '7HAb_9or_eFM', 'name': 'Mark', 'type': 'municipality', 'code': '1463', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 14,
'ad_ids': ['24648862', '24646848', '24646268', '24641228', '24630473', '24636557', '24636719', '24634116',
'24622756', '24605393']},
{'id': 'rZWC_pXf_ySZ', 'name': 'Svenljunga', 'type': 'municipality', 'code': '1465', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 6,
'ad_ids': ['24643128', '24623466', '24623505', '24615913', '24601846', '24557637']},
{'id': 'J116_VFs_cg6', 'name': 'Herrljunga', 'type': 'municipality', 'code': '1466', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 6,
'ad_ids': ['24641573', '24636142', '24617273', '24602256', '24589027', '24344092']},
{'id': 'fbHM_yhA_BqS', 'name': 'Vara', 'type': 'municipality', 'code': '1470', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 9,
'ad_ids': ['24629592', '24623071', '24600787', '24581780', '24573835', '24573476', '24564712', '24560074',
'24550766']},
{'id': 'txzq_PQY_FGi', 'name': 'Götene', 'type': 'municipality', 'code': '1471', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 4, 'ad_ids': ['24640957', '24645273', '24482625', '24435186']},
{'id': 'aLFZ_NHw_atB', 'name': 'Tibro', 'type': 'municipality', 'code': '1472', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 8,
'ad_ids': ['24645712', '24644627', '24629456', '24602786', '24606277', '24573354', '24571196', '24529612']},
{'id': 'a15F_gAH_pn6', 'name': 'Töreboda', 'type': 'municipality', 'code': '1473', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 4, 'ad_ids': ['24627789', '24606276', '24602447', '24522711']},
{'id': 'PVZL_BQT_XtL', 'name': 'Göteborg', 'type': 'municipality', 'code': '1480', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 366,
'ad_ids': ['24681247', '24676773', '24650996', '24650965', '24650945', '24650584', '24650192', '24649925',
'24649915', '24649703']},
{'id': 'mc45_ki9_Bv3', 'name': 'Mölndal', 'type': 'municipality', 'code': '1481', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 34,
'ad_ids': ['24650280', '24647664', '24645598', '24645052', '24644887', '24642987', '24642642', '24641578',
'24635304', '24632723']},
{'id': 'ZkZf_HbK_Mcr', 'name': 'Kungälv', 'type': 'municipality', 'code': '1482', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 10,
'ad_ids': ['24649688', '24636513', '24631373', '24599794', '24597606', '24594445', '24587159', '24487095',
'24361598', '24329253']},
{'id': 'z2cX_rjC_zFo', 'name': 'Lysekil', 'type': 'municipality', 'code': '1484', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 5,
'ad_ids': ['24635267', '24618391', '24605089', '24566449', '24554224']},
{'id': 'xQc2_SzA_rHK', 'name': 'Uddevalla', 'type': 'municipality', 'code': '1485', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 19,
'ad_ids': ['24649569', '24648333', '24641531', '24640747', '24639878', '24635023', '24633830', '24627768',
'24624785', '24619542']},
{'id': 'PAxT_FLT_3Kq', 'name': 'Strömstad', 'type': 'municipality', 'code': '1486', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 3, 'ad_ids': ['24645683', '24640280', '24612600']},
{'id': 'THif_q6H_MjG', 'name': 'Vänersborg', 'type': 'municipality', 'code': '1487', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 12,
'ad_ids': ['24643619', '24641986', '24626856', '24624150', '24615861', '24615817', '24615329', '24592505',
'24598715', '24598400']},
{'id': 'CSy8_41F_YvX', 'name': 'Trollhättan', 'type': 'municipality', 'code': '1488', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 21,
'ad_ids': ['24646037', '24639347', '24627262', '24624949', '24615219', '24615218', '24609960', '24607976',
'24606466', '24604829']},
{'id': 'UQ75_1eU_jaC', 'name': 'Alingsås', 'type': 'municipality', 'code': '1489', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 19,
'ad_ids': ['24641757', '24632495', '24631417', '24629793', '24626567', '24624598', '24618097', '24615747',
'24607775', '24607729']},
{'id': 'TpRZ_bFL_jhL', 'name': 'Borås', 'type': 'municipality', 'code': '1490', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 74,
'ad_ids': ['24674944', '24649696', '24649621', '24647020', '24641526', '24645912', '24644338', '24643016',
'24641652', '24641101']},
{'id': 'an4a_8t2_Zpd', 'name': 'Ulricehamn', 'type': 'municipality', 'code': '1491', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 5,
'ad_ids': ['24650721', '24645207', '24643748', '24639136', '24570351']},
{'id': 'M1UC_Cnf_r7g', 'name': 'Åmål', 'type': 'municipality', 'code': '1492', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 5,
'ad_ids': ['24633826', '24629622', '24627722', '24593424', '24541403']},
{'id': 'Lzpu_thX_Wpa', 'name': 'Mariestad', 'type': 'municipality', 'code': '1493', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 3, 'ad_ids': ['24646647', '24607084', '24606384']},
{'id': 'FN1Y_asc_D8y', 'name': 'Lidköping', 'type': 'municipality', 'code': '1494', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 9,
'ad_ids': ['24641522', '24624546', '24624090', '24606663', '24606030', '24586133', '24585588', '24516242',
'24417820']},
{'id': 'k1SK_gxg_dW4', 'name': 'Skara', 'type': 'municipality', 'code': '1495', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 13,
'ad_ids': ['24644221', '24639811', '24639532', '24631244', '24616809', '24614229', '24606824', '24600741',
'24595277', '24552003']},
{'id': 'fqAy_4ji_Lz2', 'name': 'Skövde', 'type': 'municipality', 'code': '1496', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 31,
'ad_ids': ['24649472', '24645228', '24642392', '24642391', '24638912', '24636831', '24636136', '24635424',
'24633671', '24628305']},
{'id': 'YbFS_34r_K2v', 'name': 'Hjo', 'type': 'municipality', 'code': '1497', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 5,
'ad_ids': ['24624908', '24585725', '24583812', '24573430', '24483113']},
{'id': 'Zsf5_vpP_Bs4', 'name': 'Tidaholm', 'type': 'municipality', 'code': '1498', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 2, 'ad_ids': ['24617483', '24600800']},
{'id': 'ZySF_gif_zE4', 'name': 'Falköping', 'type': 'municipality', 'code': '1499', 'region_code': '14',
'region_name': 'Västra Götalands län', 'hits': 8,
'ad_ids': ['24650374', '24640803', '24636373', '24635597', '24630448', '24628992', '24620333', '24617776']},
]
|
53315
|
from tgt_grease.enterprise.Model import Detector
import re
class Regex(Detector):
"""Regular Expression Detector for GREASE Detection
A Typical Regex configuration looks like this::
{
...
'logic': {
'Regex': [
{
'field': String, # <-- Field to search for
'pattern': String, # <-- Regex to perform on field
'variable': Boolean, # <-- OPTIONAL, if true then create a context variable of result
'variable_name: String # <-- REQUIRED IF variable, name of context variable
}
...
]
...
}
}
"""
def processObject(self, source, ruleConfig):
"""Processes an object and returns valid rule data
Data returned in the second parameter from this method should be in this form::
{
'<field>': Object # <-- if specified as a variable then return the key->Value pairs
...
}
Args:
source (dict): Source Data
ruleConfig (list[dict]): Rule Configuration Data
Return:
tuple: first element boolean for success; second dict for any fields returned as variables
"""
final = {}
finalBool = False
if not isinstance(source, dict):
return False, {}
if not isinstance(ruleConfig, list):
return False, {}
else:
# loop through configuration for each set of logical configurations
for block in ruleConfig:
if not isinstance(block, dict):
self.ioc.getLogger().error(
"INVALID REGEX LOGICAL BLOCK! NOT TYPE LIST [{0}]".format(str(type(block))),
notify=False
)
return False, {}
else:
# look for field and perform regex
if block.get('field') in source:
if source.get(block.get('field')):
result = re.findall(block.get('pattern'), str(source.get(block.get('field'))))
if len(result):
finalBool = True
if block.get('variable') and block.get('variable_name'):
final[str(block.get('variable_name'))] = result
else:
continue
else:
self.ioc.getLogger().trace(
"Field did not pass regex",
verbose=True
)
return False, {}
else:
# truthy false field value
self.ioc.getLogger().trace(
"Field [{0}] equates to false [{1}]".format(
block.get('field'),
source.get(block.get('field'))
),
notify=False,
verbose=True
)
return False, {}
else:
self.ioc.getLogger().trace(
"Field not found in source [{0}]".format(block.get('field')),
notify=False,
verbose=True
)
return False, {}
return finalBool, final
|
53348
|
from boa3.builtin.interop.runtime import invocation_counter
def Main(example: int) -> int:
invocation_counter = example
return invocation_counter
|
53352
|
import json
import glob
import os
import argparse
import time
_DEFAULT_DATASET_DIR_PATH = "D:\\Documents\\output_vvs_2020\\labeled"
_DEFAULT_METADATA_PATH = "C:\\Users\\Steven\\github\\kvasir-capsule\\metadata.json"
_DEFAULT_WORK_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
_ANATOMY_CLASSES = [
"Pylorus",
"Ileocecal valve",
"Ampulla of Vater"
]
_LUMINAL_CLASSES = [
"Normal clean mucosa",
"Reduced mucosal view",
"Blood - fresh",
"Blood - hematin",
"Erythema",
"Foreign body",
"Angiectasia",
"Erosion",
"Ulcer",
"Polyp",
"Lymphangiectasia"
]
argument_parser = argparse.ArgumentParser(description="")
argument_parser.add_argument("-d", "--dataset-dir", type=str, default=_DEFAULT_DATASET_DIR_PATH)
argument_parser.add_argument("-m", "--metadata-file", type=str, default=_DEFAULT_METADATA_PATH)
argument_parser.add_argument("-o", "--output-file", type=str, default=os.path.join(_DEFAULT_WORK_DIR, "metadata.csv"))
def match_sequence(path, start, end):
frame_number = int(os.path.splitext(os.path.basename(path).split("_")[1])[0])
if frame_number >= start and frame_number <= end:
return True
return False
def match_frame_id(path, match):
return os.path.splitext(os.path.basename(path).split("_")[-1])[0] == match
def clean_metadata_json(dataset_dir_path, metadata_file_path, output_file_path):
all_video_frames = list(glob.glob(os.path.join(dataset_dir_path, "*", "*")))
timer = time.time()
with open(metadata_file_path) as f:
metadata = json.load(f)
with open(output_file_path, mode="w") as f:
f.write("filename;video_id;frame_number;finding_category;finding_class;x1;y1;x2;y2;x3;y3;x4;y4\n")
for video_id, video_data in metadata.items():
print("Reading video with ID %s..." % video_id)
video_specific_frames = list(filter(
lambda x: os.path.basename(x).split("_")[0] == video_id, all_video_frames
))
for segment_id, segment_data in video_data["segments"].items():
for seen_segment in segment_data["seen"]:
start_frame = seen_segment[0]
end_frame = seen_segment[1]
segment_class = segment_data["metadata"]["pillcam_subtype"]
if segment_class is None:
segment_class = segment_data["metadata"]["segment_type"]
segment_category = "Anatomy" if segment_class in _ANATOMY_CLASSES else "Luminal"
segment_frames = list(filter(
lambda x: match_sequence(x, start_frame, end_frame), video_specific_frames
))
segment_frames = sorted(
segment_frames,
key=lambda x: int(os.path.splitext(os.path.basename(x).split("_")[1])[0])
)
for frame in segment_frames:
frame_id = os.path.splitext(os.path.basename(frame))[0].split("_")[-1]
f.write("%s;%s;%s;%s;%s;;;;;;;\n" % (os.path.basename(frame), video_id, frame_id, segment_category, segment_class))
for finding_id, finding_data in video_data["findings"].items():
finding_class = finding_data["metadata"]["pillcam_subtype"]
finding_category = "Anatomy" if finding_class in _ANATOMY_CLASSES else "Luminal"
for frame_id, frame_data in finding_data["frames"].items():
frame = filter(lambda x: match_frame_id(x, frame_id), video_specific_frames)
frame = list(frame)
if len(frame) <= 0:
print("Missing frames for %s!" % video_id)
continue
f.write("%s;%s;%s;%s;%s" % (os.path.basename(frame[0]), video_id, frame_id, finding_category, finding_class))
for box in frame_data["shape"]:
f.write(";%s;%s" % (int(box["x"]), int(box["y"])))
f.write("\n")
print("Finished after %s seconds!" % int(time.time() - timer))
if __name__ == "__main__":
args = argument_parser.parse_args()
clean_metadata_json(
dataset_dir_path=args.dataset_dir,
metadata_file_path=args.metadata_file,
output_file_path=args.output_file
)
|
53377
|
from collections import defaultdict
from copy import copy, deepcopy
from tqdm import tqdm
from ..eventuality import Eventuality
from ..relation import Relation
def conceptualize_eventualities(aser_conceptualizer, eventualities):
""" Conceptualize eventualities by an ASER conceptualizer
:param aser_conceptualizer: an ASER conceptualizer
:type aser_conceptualizer: aser.conceptualize.aser_conceptualizer.BaseASERConceptualizer
:param eventualities: a list of eventualities
:type eventualities: List[aser.event.Eventuality]
:return: a dictionary from cid to concept, a list of concept-instance pairs, a dictionary from cid to weights
:rtype: Dict[str, aser.concept.ASERConcept], List[aser.concept.ASERConcept, aser.eventuality.Eventuality, float], Dict[str, float]
"""
cid2concept = dict()
concept_instance_pairs = []
cid2score = dict()
for eventuality in tqdm(eventualities):
results = aser_conceptualizer.conceptualize(eventuality)
for concept, score in results:
if concept.cid not in cid2concept:
cid2concept[concept.cid] = deepcopy(concept)
concept = cid2concept[concept.cid]
if (eventuality.eid, eventuality.pattern, score) not in concept.instances:
concept.instances.append(((eventuality.eid, eventuality.pattern, score)))
if concept.cid not in cid2score:
cid2score[concept.cid] = 0.0
cid2score[concept.cid] += score * eventuality.frequency
concept_instance_pairs.append((concept, eventuality, score))
return cid2concept, concept_instance_pairs, cid2score
def build_concept_relations(concept_conn, relations):
""" Build relations between conceptualized eventualities from the given relations between eventualities
:param concept_conn: ASER concept KG connection
:type concept_conn: aser.database.kg_connection.ASERConceptConnection
:param relations: relations between eventualities
:type relations: List[aser.relation.Relations]
:return: a dictionary from rid to relations between conceptualized eventualities
:rtype: Dict[str, aser.relation.Relation]
"""
rid2relation = dict()
hid2related_events = defaultdict(list)
for relation in tqdm(relations):
hid2related_events[relation.hid].append((relation.tid, relation))
for h_cid in tqdm(concept_conn.cids):
instances = concept_conn.get_eventualities_given_concept(h_cid)
for h_eid, pattern, instance_score in instances:
# eid -> event -> related eids -> related events, relations -> related concepts, relations
related_events = hid2related_events[h_eid]
for t_eid, relation in related_events:
concept_score_pairs = concept_conn.get_concepts_given_eventuality(t_eid)
for t_concept, score in concept_score_pairs:
t_cid = t_concept.cid
if h_cid == t_cid:
continue
rid = Relation.generate_rid(h_cid, t_cid)
if rid not in rid2relation:
rid2relation[rid] = Relation(h_cid, t_cid)
rid2relation[rid].update({k: v * instance_score * score for k, v in relation.relations.items()})
return rid2relation
|
53422
|
from shlex import split
import json
class RawCommand:
def __init__(self, command, client="local", posix=True, inline=False):
# TODO: check shlex.quote, raw string, etc..
if inline:
self.command = split(command, posix=posix)
else:
self.command = split(command, posix=posix)[1:]
self.options = {"expr_form": "glob"}
self.client = client
def parse(self):
args = self.command
if args[0].startswith("--client"):
self.client = args[0].split("=")[1]
args.pop(0)
low = {"client": self.client}
if self.client.startswith("local"):
if len(args) < 2:
return "Command or target not specified"
# Batch option
low["batch"] = None
if self.client == "local_batch":
batch_index = None
for index, arg in enumerate(args):
if arg in ["-b", "--batch", "--batch-size"]:
low["batch"] = args[index + 1]
batch_index = index
if batch_index:
args.pop(batch_index)
args.pop(batch_index)
# Timeout option
timeout_index = None
for index, arg in enumerate(args):
if arg in ["-t", "--timeout"]:
low["timeout"] = int(args[index + 1])
timeout_index = index
if timeout_index:
args.pop(timeout_index)
args.pop(timeout_index)
# take care of targeting.
target_dict = {
"pcre": ["-E", "--pcre"],
"list": ["-L", "--list"],
"grain": ["-G", "--grain"],
"grain_pcre": ["--grain-pcre"],
"pillar": ["-I", "--pillar"],
"pillar_pcre": ["--pillar-pcre"],
"range": ["-R", "--range"],
"compound": ["-C", "--compound"],
"nodegroup": ["-N", "--nodegroup"],
}
for key, value in target_dict.items():
if args[0] in value:
self.options["expr_form"] = key
args.pop(0)
low["tgt_type"] = self.options["expr_form"]
low["tgt"] = args.pop(0)
low["fun"] = args.pop(0)
low["arg"] = args
elif self.client.startswith("runner") or self.client.startswith("wheel"):
low["fun"] = args.pop(0)
for arg in args:
if "=" in arg:
key, value = arg.split("=", 1)
try:
low[key] = json.loads(value)
except json.JSONDecodeError:
low[key] = value
else:
low.setdefault("arg", []).append(arg)
else:
# This should never happen
return "Client not implemented: {0}".format(self.client)
return [low]
|
53426
|
from happytransformer import HappyNextSentence
def test_sp_true():
happy_ns = HappyNextSentence()
result = happy_ns.predict_next_sentence(
"Hi nice to meet you. How old are you?",
"I am 21 years old."
)
assert result > 0.5
def test_sp_false():
happy_ns = HappyNextSentence()
result = happy_ns.predict_next_sentence(
"How old are you?",
"The Eiffel Tower is in Paris."
)
assert result < 0.5
def test_sp_save():
happy = HappyNextSentence()
happy.save("model/")
result_before = happy.predict_next_sentence(
"How old are you?",
"The Eiffel Tower is in Paris."
)
happy = HappyNextSentence(load_path="model/")
result_after = happy.predict_next_sentence(
"How old are you?",
"The Eiffel Tower is in Paris."
)
assert result_before == result_after
|
53463
|
import torch
import numpy as np
from torch import nn
from torch.nn import functional as F
# from modeling.dynamic_filters.multiheadatt import TransformerBlock
from modeling.dynamic_filters.build import DynamicFilter,ACRM_query,ACRM_video
from utils import loss as L
from utils.rnns import feed_forward_rnn
import utils.pooling as POOLING
class Localization_ACRM(nn.Module):
def __init__(self, cfg):
super(Localization_ACRM, self).__init__()
self.cfg = cfg
self.batch_size = cfg.BATCH_SIZE_TRAIN
self.model_df = ACRM_query(cfg)
# if cfg.ACRM_VIDEO.TAIL_MODEL == "LSTM":
# self.model_video_GRU = nn.LSTM(input_size = cfg.DYNAMIC_FILTER.LSTM_VIDEO.INPUT_SIZE,
# num_layers = cfg.DYNAMIC_FILTER.LSTM_VIDEO.NUM_LAYERS,
# hidden_size = cfg.DYNAMIC_FILTER.LSTM_VIDEO.HIDDEN_SIZE,
# bias = cfg.DYNAMIC_FILTER.LSTM_VIDEO.BIAS,
# dropout = cfg.DYNAMIC_FILTER.LSTM_VIDEO.DROPOUT,
# bidirectional= cfg.DYNAMIC_FILTER.LSTM_VIDEO.BIDIRECTIONAL,
# batch_first = cfg.DYNAMIC_FILTER.LSTM_VIDEO.BATCH_FIRST)
self.model_video_GRU = ACRM_video(cfg)
# self.reduction = nn.Linear(cfg.REDUCTION.INPUT_SIZE, cfg.REDUCTION.OUTPUT_SIZE)
self.multimodal_fc1 = nn.Linear(512*2, 1)
self.multimodal_fc2 = nn.Linear(512, 1)
self.is_use_rnn_loc = cfg.ACRM_CLASSIFICATION.USED
self.rnn_localization = nn.LSTM(input_size = cfg.ACRM_CLASSIFICATION.INPUT_SIZE,
hidden_size = cfg.ACRM_CLASSIFICATION.INPUT_SIZE_RNN,
num_layers = cfg.LOCALIZATION.ACRM_NUM_LAYERS,
bias = cfg.LOCALIZATION.BIAS,
dropout = cfg.LOCALIZATION.DROPOUT,
bidirectional= cfg.LOCALIZATION.BIDIRECTIONAL,
batch_first = cfg.LOCALIZATION.BATCH_FIRST)
if cfg.ACRM_CLASSIFICATION.FUSION == 'CAT':
cfg.ACRM_CLASSIFICATION.INPUT_SIZE = cfg.DYNAMIC_FILTER.LSTM_VIDEO.HIDDEN_SIZE * (1 + int(cfg.DYNAMIC_FILTER.LSTM_VIDEO.BIDIRECTIONAL)) \
+ cfg.DYNAMIC_FILTER.LSTM.HIDDEN_SIZE * (1 + int(cfg.DYNAMIC_FILTER.LSTM.BIDIRECTIONAL))
else:
assert cfg.DYNAMIC_FILTER.LSTM_VIDEO.HIDDEN_SIZE * (1 + int(cfg.DYNAMIC_FILTER.LSTM_VIDEO.BIDIRECTIONAL)) == \
cfg.DYNAMIC_FILTER.LSTM.HIDDEN_SIZE * (1 + int(cfg.DYNAMIC_FILTER.LSTM.BIDIRECTIONAL))
cfg.ACRM_CLASSIFICATION.INPUT_SIZE = cfg.DYNAMIC_FILTER.LSTM_VIDEO.HIDDEN_SIZE * (1 + int(cfg.DYNAMIC_FILTER.LSTM_VIDEO.BIDIRECTIONAL))
if cfg.ACRM_CLASSIFICATION.USED == True:
cfg.ACRM_CLASSIFICATION.INPUT_SIZE = cfg.ACRM_CLASSIFICATION.INPUT_SIZE_RNN * (1 + int(cfg.LOCALIZATION.BIDIRECTIONAL))
self.pooling = POOLING.MeanPoolingLayer()
self.starting = nn.Sequential(
nn.Linear(cfg.ACRM_CLASSIFICATION.INPUT_SIZE, cfg.ACRM_CLASSIFICATION.HIDDEN_SIZE),
nn.Tanh(),
# nn.Dropout(cfg.LOCALIZATION.ACRM_DROPOUT),
nn.Linear(cfg.ACRM_CLASSIFICATION.HIDDEN_SIZE, cfg.ACRM_CLASSIFICATION.OUTPUT_SIZE))
self.ending = nn.Sequential(
nn.Linear(cfg.ACRM_CLASSIFICATION.INPUT_SIZE, cfg.ACRM_CLASSIFICATION.HIDDEN_SIZE),
nn.Tanh(),
# nn.Dropout(cfg.LOCALIZATION.ACRM_DROPOUT),
nn.Linear(cfg.ACRM_CLASSIFICATION.HIDDEN_SIZE, cfg.ACRM_CLASSIFICATION.OUTPUT_SIZE))
self.intering = nn.Sequential(
nn.Linear(cfg.ACRM_CLASSIFICATION.INPUT_SIZE, cfg.ACRM_CLASSIFICATION.HIDDEN_SIZE),
nn.Tanh(),
# nn.Dropout(cfg.LOCALIZATION.ACRM_DROPOUT),
nn.Linear(cfg.ACRM_CLASSIFICATION.HIDDEN_SIZE, cfg.ACRM_CLASSIFICATION.OUTPUT_SIZE))
# self.dropout_layer = nn.Dropout(cfg.DYNAMIC_FILTER.LSTM_VIDEO.DROPOUT)
self.dropout_layer = nn.Dropout(cfg.DYNAMIC_FILTER.LSTM_VIDEO.DROPOUT)
# self.starting = nn.Linear(cfg.CLASSIFICATION.INPUT_SIZE, cfg.CLASSIFICATION.OUTPUT_SIZE)
# self.ending = nn.Linear(cfg.CLASSIFICATION.INPUT_SIZE, cfg.CLASSIFICATION.OUTPUT_SIZE)
def attention(self, videoFeat, filter, lengths):
pred_local = torch.bmm(videoFeat, filter.unsqueeze(2)).squeeze()
return pred_local
def get_mask_from_sequence_lengths(self, sequence_lengths: torch.Tensor, max_length: int):
ones = sequence_lengths.new_ones(sequence_lengths.size(0), max_length)
range_tensor = ones.cumsum(dim=1)
return (sequence_lengths.unsqueeze(1) >= range_tensor).long()
def feature_l2_normalize(self, data_tensor):
mu = torch.norm(data_tensor,dim=-1, keepdim=True)
data_tensor = data_tensor/mu
return data_tensor
def feature_gauss_normalize(self, data_tensor):
mu = torch.mean(data_tensor,dim=-1,keepdim=True)
std_value = torch.std(data_tensor,dim=-1,keepdim=True)
return (data_tensor - mu)/std_value
def fusion_layer(self , filter_start, output_video, mode):
if mode == 'CAT':
output = torch.cat([filter_start.unsqueeze(dim=1).repeat(1,output_video.shape[1],1),output_video],dim=-1)
elif mode == 'COS':
output = filter_start.unsqueeze(dim=1).repeat(1,output_video.shape[1],1) * output_video
elif mode =='SUB':
output = (filter_start.unsqueeze(dim=1).repeat(1,output_video.shape[1],1) - output_video)
elif mode == 'CROSS_COS':
output = filter_start * output_video
elif mode == 'CROSS_SUB':
output = torch.abs(filter_start - output_video)
return output
def masked_softmax(self, vector: torch.Tensor, mask: torch.Tensor, dim: int = -1, memory_efficient: bool = False, mask_fill_value: float = -1e32):
if mask is None:
result = torch.nn.functional.softmax(vector, dim=dim)
else:
mask = mask.float()
while mask.dim() < vector.dim():
mask = mask.unsqueeze(1)
if not memory_efficient:
# To limit numerical errors from large vector elements outside the mask, we zero these out.
result = torch.nn.functional.softmax(vector * mask, dim=dim)
result = result * mask
result = result / (result.sum(dim=dim, keepdim=True) + 1e-13)
else:
masked_vector = vector.masked_fill((1 - mask).byte(), mask_fill_value)
result = torch.nn.functional.softmax(masked_vector, dim=dim)
return result + 1e-13
def mask_softmax(self, feat, mask):
return self.masked_softmax(feat, mask, memory_efficient=False)
def kl_div(self, p, gt, length):
individual_loss = []
for i in range(length.size(0)):
vlength = int(length[i])
ret = gt[i][:vlength] * torch.log(p[i][:vlength]/gt[i][:vlength])
individual_loss.append(-torch.sum(ret))
individual_loss = torch.stack(individual_loss)
return torch.mean(individual_loss), individual_loss
def max_boundary(self, p, gt, length):
individual_loss = []
for i in range(length.size(0)):
# vlength = int(length[i])
index_bd = gt[i]
ret = torch.log(p[i][index_bd])
individual_loss.append(-torch.sum(ret))
individual_loss = torch.stack(individual_loss)
return torch.mean(individual_loss), individual_loss
def max_inter(self, p, gt_s, gt_e, length):
individual_loss = []
for i in range(length.size(0)):
# vlength = int(length[i])
index_bs = gt_s[i]
index_be = gt_e[i]
ret = torch.log(p[i][index_bs:(index_be+1)])/(max(index_be-index_bs,1))
individual_loss.append(-torch.sum(ret))
individual_loss = torch.stack(individual_loss)
return torch.mean(individual_loss), individual_loss
def forward(self, videoFeat, videoFeat_lengths, tokens, tokens_lengths, start, end, localiz, frame_start, frame_end):
mask = self.get_mask_from_sequence_lengths(videoFeat_lengths, int(videoFeat.shape[1]))
output_video = self.model_video_GRU(videoFeat,videoFeat_lengths,mask)
filter_start, lengths = self.model_df(tokens, tokens_lengths,output_video)
# output_video = self.feature_gauss_normalize(output_video)
# filter_start = self.feature_gauss_normalize(filter_start)
# attention_weights = attention_weights.detach().cpu().numpy()
# np.save('/home/thy/disk/proposal_free/experiments/visualization/attention.npy',attention_weights)
output = self.fusion_layer(filter_start,output_video,self.cfg.ACRM_CLASSIFICATION.FUSION)
# output = torch.cat([filter_start.unsqueeze(dim=1).repeat(1,output_video.shape[1],1),output_video],dim=-1)
# output = filter_start.unsqueeze(dim=1).repeat(1,output_video.shape[1],1) * output_video
if self.is_use_rnn_loc == True:
output, _ = feed_forward_rnn(self.rnn_localization,
output,
lengths=videoFeat_lengths)
output = self.dropout_layer(output)
pred_start = self.starting(output.view(-1, output.size(2))).view(-1,output.size(1),1).squeeze()
pred_start = self.mask_softmax(pred_start, mask)
pred_end = self.ending(output.view(-1, output.size(2))).view(-1,output.size(1),1).squeeze()
pred_end = self.mask_softmax(pred_end, mask)
pred_inter = self.intering(output.view(-1, output.size(2))).view(-1,output.size(1),1).squeeze()
pred_inter = self.mask_softmax(pred_inter, mask)
start_loss, individual_start_loss = self.max_boundary(pred_start, frame_start, videoFeat_lengths)
end_loss, individual_end_loss = self.max_boundary(pred_end, frame_end, videoFeat_lengths)
inter_loss, individual_inter_loss = self.max_inter(pred_inter,frame_start,frame_end,videoFeat_lengths)
individual_loss = individual_start_loss + individual_end_loss + individual_inter_loss
atten_loss = torch.tensor(0).cuda()
# atten_loss = torch.sum(-( (1-localiz) * torch.log((1-attention) + 1E-12)), dim=1)
# atten_loss = torch.mean(atten_loss)
attention = output_video[:,:,0]
if True:
# total_loss = start_loss + end_loss + atten_loss
total_loss = start_loss + end_loss + 1*inter_loss
else:
total_loss = start_loss + end_loss
return total_loss, individual_loss, pred_start, pred_end, attention, atten_loss
|
53482
|
import re
from functools import lru_cache
from pathlib import Path
import typing as T
from yaml import dump as yaml_dump
from faker import Faker
from faker.config import AVAILABLE_LOCALES
from tools.faker_docs_utils.format_samples import (
yaml_samples_for_docstring,
snowfakery_output_for,
)
from .summarize_fakers import summarize_all_fakers
from .language_codes import language_codes
from snowfakery.fakedata.fake_data_generator import FakeData
_RE_COMBINE_WHITESPACE = re.compile(r"(?<=^) +", re.MULTILINE)
_RE_STRIP_SAMPLES = re.compile(r"^\s*:sample:.*$", re.MULTILINE)
_COMMENT_LINES_THAT_LOOK_LIKE_TITLES = re.compile(r"^#", re.MULTILINE)
non_countries = ("fr_QC", "ar_AA")
AVAILABLE_LOCALES = [
locale
for locale in AVAILABLE_LOCALES
if locale not in non_countries and "_" in locale
]
def cleanup_docstring(my_str):
"Clean up a docstring to remove Faker-doc weirdness and excesss whitespace"
my_str = _RE_COMBINE_WHITESPACE.sub("", my_str)
my_str = _RE_STRIP_SAMPLES.sub("", my_str).strip()
my_str = _COMMENT_LINES_THAT_LOOK_LIKE_TITLES.sub(" #", my_str)
my_str = my_str.replace(":example", "\nExample:")
my_str = my_str.replace(":param", "\nParam:")
my_str = my_str.replace(":return", "\nReturn:")
return my_str
@lru_cache(maxsize=1000)
def country_for_locale(locale: str):
f = Faker(locale)
return f.current_country()
def locales_as_markdown_links(current_locale: str, locale_list: T.List[str]):
"Generate a list of Markdown locale links"
def format_link(locale: str):
try:
country_name = country_for_locale(locale)
except (ValueError, AttributeError):
return None
language = language_codes[locale.split("_")[0]]
link_text = f"{language} as spoken in {country_name}: ({locale})"
return f" - [{link_text}](fakedata/{locale}.md)\n"
other_locales = [locale for locale in locale_list if locale != current_locale]
links = [format_link(locale) for locale in other_locales]
return " ".join(link for link in links if link)
standard_header = (Path(__file__).parent / "fakedata_header_short.md").read_text()
def generate_markdown_for_fakers(outfile, locale: str, header: str = standard_header):
"Generate the Markdown page for a locale"
faker = Faker(locale)
language = language_codes[locale.split("_")[0]]
fd = FakeData([], locale)
all_fakers = summarize_all_fakers(fd)
def output(*args, **kwargs):
print(*args, **kwargs, file=outfile)
head_md = header.format(
locale=locale, current_country=faker.current_country(), language=language
)
output(
head_md,
)
output("[TOC]\n")
output("## Commonly Used\n")
output_fakers_in_categories(output, [f for f in all_fakers if f.common], "", locale)
output("## Rarely Used\n")
output_fakers_in_categories(
output, [f for f in all_fakers if not f.common], "", locale
)
def output_fakers_in_categories(output, fakers, common: str, locale):
"""Sort fakers into named categores and then output them"""
categorized = categorize(fakers)
for category_name, fakers in categorized.items():
output(f"### {category_name.title()} Fakers\n")
for faker in fakers:
output_faker(faker.name, faker, output, locale)
def categorize(fakers):
"Sort fakers based on their categories (what module they came from)"
categories = {}
for fakerdata in fakers:
category = fakerdata.category
categories.setdefault(category, [])
categories[category].append(fakerdata)
return {name: value for name, value in sorted(categories.items())}
def gather_samples(name, data, locale):
if data.sample: # I already have a sample, no need to generate one
if locale and locale != "en_US":
locale_header = [{"var": "snowfakery_locale", "value": locale}]
sample = locale_header + data.sample
else:
sample = data.sample
example = yaml_dump(sample, sort_keys=False)
samples = [snowfakery_output_for(data.name, example, example)]
else: # need to generate a sample from scratch
samples = yaml_samples_for_docstring(name, data.fullname, data.doc, locale)
return list(filter(None, samples))
def output_faker(name: str, data: str, output: callable, locale: str):
"""Output the data relating to a particular faker"""
samples = gather_samples(name, data, locale)
# if there isn't at least one sample, don't publish
if not samples:
return
output(f"#### fake: {name}\n")
cleaned_docstring = cleanup_docstring(data.doc)
if cleaned_docstring:
output(cleaned_docstring)
output()
output("Aliases: ", ", ".join(data.aliases))
output()
link = f"[{data.source}]({data.url}) : {data.fullname}"
output("Source:", link)
if samples:
output()
for sample in samples:
yaml, out = sample
output("Recipe:\n")
output(indent(yaml))
output("Outputs:\n")
output(indent(out))
else:
output()
def indent(yaml: str):
"""Add indents to yaml"""
lines = yaml.split("\n")
def prefix(line):
return " " if line.strip() else ""
lines = [prefix(line) + line for line in lines]
return "\n".join(lines)
def generate_markdown_for_all_locales(path: Path, locales=None):
"Generate markdown file for each listed locale. None means all locales"
locales = locales or AVAILABLE_LOCALES
for locale in locales:
with Path(path, f"{locale}.md").open("w") as f:
print(f.name)
generate_markdown_for_fakers(f, locale)
def generate_locales_index(path: Path, locales_list: T.List[str]):
"Generate markdown index including listed locales. None means all locales"
locales_list = locales_list or AVAILABLE_LOCALES
with Path(path).open("w") as outfile:
def output(*args, **kwargs):
print(*args, **kwargs, file=outfile)
locales = locales_as_markdown_links(None, locales_list)
if locales:
output("## Fake Data Locales\n")
output(
"Learn more about Snowfakery localization in the [Fake Data Tutorial](fakedata.md#localization)\n"
)
output(locales)
|
53511
|
import numpy as np
import torch
from fairseq.data.indexed_dataset import __best_fitting_dtype, MMapIndexedDatasetBuilder, IndexedDatasetBuilder
from fairseq.tokenizer import tokenize_line
# TODO move this file into data folder
def make_builder(out_file, impl, vocab_size=None, dtype=None):
if impl == 'mmap':
if dtype is None:
dtype = __best_fitting_dtype(vocab_size)
return MMapIndexedDatasetBuilder(out_file, dtype=dtype)
else:
return IndexedDatasetBuilder(out_file)
def binarize_file(input_file, out_file_pref, impl, dtype=np.int64, tokenize=tokenize_line):
out_file = out_file_pref + '.bin'
index_file = out_file_pref + '.idx'
ds = make_builder(out_file, impl=impl, dtype=dtype)
with open(input_file, 'r') as f:
for line in f:
if line.strip():
line = tokenize_line(line)
line = list(map(int, line))
line = torch.tensor(line)
ds.add_item(line)
else:
raise Exception('empty line')
ds.finalize(index_file)
return
|
53512
|
from __future__ import annotations
from enum import Enum
from typing import TYPE_CHECKING
from robot_server.robot.calibration.constants import STATE_WILDCARD
if TYPE_CHECKING:
from typing_extensions import Final
class PipetteOffsetCalibrationState(str, Enum):
sessionStarted = "sessionStarted"
labwareLoaded = "labwareLoaded"
preparingPipette = "preparingPipette"
inspectingTip = "inspectingTip"
joggingToDeck = "joggingToDeck"
savingPointOne = "savingPointOne"
calibrationComplete = "calibrationComplete"
sessionExited = "sessionExited"
WILDCARD = STATE_WILDCARD
class PipetteOffsetWithTipLengthCalibrationState(str, Enum):
sessionStarted = "sessionStarted"
labwareLoaded = "labwareLoaded"
measuringNozzleOffset = "measuringNozzleOffset"
preparingPipette = "preparingPipette"
inspectingTip = "inspectingTip"
measuringTipOffset = "measuringTipOffset"
joggingToDeck = "joggingToDeck"
savingPointOne = "savingPointOne"
calibrationComplete = "calibrationComplete"
sessionExited = "sessionExited"
tipLengthComplete = "tipLengthComplete"
WILDCARD = STATE_WILDCARD
TIP_RACK_SLOT: Final = "8"
|
53523
|
while(True):
jars = [int(x) for x in input().split()]
if sum(jars) == 0:
break
if sum(jars) == 13:
print("Never speak again.")
elif jars[0] > jars[1]:
print("To the convention.")
elif jars[1] > jars[0]:
print("Left beehind.")
elif jars[1] == jars[0]:
print("Undecided.")
|
53618
|
import time
import eventlet
import ast
from st2reactor.sensor.base import PollingSensor
__all_ = [
'AutoscaleGovernorSensor'
]
eventlet.monkey_patch(
os=True,
select=True,
socket=True,
thread=True,
time=True)
GROUP_ACTIVE_STATUS = [
'expanding',
'deflating'
]
class AutoscaleGovernorSensor(PollingSensor):
def __init__(self, sensor_service, config=None, poll_interval=60):
super(AutoscaleGovernorSensor, self).__init__(sensor_service=sensor_service,
config=config,
poll_interval=poll_interval)
self._logger = self._sensor_service.get_logger(__name__)
self._kvp_get = self._sensor_service.get_value
self._trigger = {
'expand': 'autoscale.ScaleUpPulse',
'deflate': 'autoscale.ScaleDownPulse'
}
self._bound = {
'expand': 'max',
'deflate': 'min'
}
def setup(self):
pass
def poll(self):
alerting_asgs = []
stable_asgs = []
# Get all the ASG related keys in the Key Store
kvps = self._sensor_service.list_values(local=False, prefix='asg.')
# Sort out which Applications are actively alerting, and which are not.
for kvp in kvps:
if 'active_incident' in kvp.name:
asg_data = kvp.name.split('.')
asg = asg_data[1]
if ast.literal_eval(kvp.value):
alerting_asgs.append(asg)
else:
stable_asgs.append(asg)
# Attempt to determine if an ASG needs to scale up...
for asg in alerting_asgs:
self._process_asg(asg, 'expand')
# ... or down
for asg in stable_asgs:
self._process_asg(asg, 'deflate')
def cleanup(self):
pass
def add_trigger(self, trigger):
pass
def update_trigger(self, trigger):
pass
def remove_trigger(self, trigger):
pass
def _process_asg(self, asg, action):
trigger_type = self._trigger[action]
bound = self._bound[action]
group_status = self._kvp_get('asg.%s.status' % (asg), local=False)
last_event_timestamp = self._kvp_get('asg.%s.last_%s_timestamp' % (asg, action), local=False)
event_delay = self._kvp_get('asg.%s.%s_delay' % (asg, action), local=False)
current_node_count = self._kvp_get('asg.%s.total_nodes' % (asg), local=False)
node_bound = self._kvp_get('asg.%s.%s_nodes' % (asg, bound), local=False)
total_nodes = self._kvp_get('asg.%s.total_nodes' % (asg), local=False)
if group_status in GROUP_ACTIVE_STATUS:
self._logger.info("AutoScaleGovernor: Autoscale group is currently %s. Skipping..." %
(group_status))
return
# ensure we have all the required variables
if last_event_timestamp and event_delay and current_node_count and node_bound and total_nodes:
# See if an ASG is even eligible to be acted upon, min or max.
bound_check = getattr(self, '_%s_bound_check' % bound)(int(node_bound), int(total_nodes))
delay_check = self._event_delay_check(int(last_event_timestamp), int(event_delay))
if bound_check and delay_check:
self._dispatch_trigger(trigger_type, asg)
else:
self._logger.info("AutoScaleGovernor: Not all K/V pairs exist for ASG %s. Skipping..." % asg)
def _event_delay_check(self, last_event_timestamp, event_delay):
check = True if last_event_timestamp + (event_delay * 60) < int(time.time()) else False
return check
def _max_bound_check(self, max_nodes, total_nodes):
"""
Make sure we have not reached the threshold and are not above max_nodes.
We only want to send scale up pulse if we are not above max_nodes threshold.
"""
check = True if total_nodes < max_nodes else False
return check
def _min_bound_check(self, min_nodes, total_nodes):
"""
Make sure we have not reached the min_nodes threshold.
We only want to scale down if current number of nodes is greater than min_nodes.
"""
check = True if total_nodes > min_nodes else False
return check
def _dispatch_trigger(self, trigger, asg):
payload = {
'asg': asg,
}
self._sensor_service.dispatch(trigger=trigger, payload=payload)
|
53630
|
import nltk
from nltk.corpus import wordnet
from nltk.corpus import wordnet as wn
from nltk.corpus import wordnet_ic
brown_ic = wordnet_ic.ic('ic-brown.dat')
semcor_ic = wordnet_ic.ic('ic-semcor.dat')
from nltk.corpus import genesis
genesis_ic = wn.ic(genesis, False, 0.0)
lion = wn.synset('lion.n.01')
cat = wn.synset('cat.n.01')
print(lion.res_similarity(cat, brown_ic))
print(lion.res_similarity(cat, genesis_ic))
print(lion.jcn_similarity(cat, brown_ic))
print(lion.jcn_similarity(cat, genesis_ic))
print(lion.lin_similarity(cat, semcor_ic))
|
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]
|
53681
|
import argparse
from FVC_utils import load_from_pickle, save_to_pickle, readData, printx, time, path
from xgboost import XGBClassifier
import warnings
warnings.filterwarnings('ignore')
# from sklearn.preprocessing import StandardScaler
def training_series(X_train, y_train, normalizer=None, xgb_params={}):
printx('########### training FVC model ... ############')
printx('training set shape: {}'.format(X_train.shape))
if normalizer:
X_train = normalizer.fit_transform(X_train)
t0 = time.time()
clf = XGBClassifier(**xgb_params)
printx(clf.get_params())
clf.fit(X_train, y_train)
# printx('model parameters: \n{}'.format(clf.get_params()))
clfkit = {'FVC':clf}
printx('use {:.0f} s\n'.format(time.time()-t0))
return [clfkit], normalizer
parser = argparse.ArgumentParser(
description='extract the complex region' )
parser.add_argument(
'--in_tp', type=str,
default="training_tp_tensor.record",
help="wait to describe")
parser.add_argument(
'--in_fp', type=str,
default="training_fp_tensor.record",
help="wait to describe")
parser.add_argument(
'--model', type=str,
default="no",
help="the absolute path of pretrained model, default no pretrained model.")
parser.add_argument(
'--out_model', type=str,
default="retrain.model",
help="wait to describe")
parser.add_argument(
'--random_seed', type=int,
default=0,
help="random state, default 0")
parser.add_argument(
'--scale_strategy', type=str,
default='standard', choices=['standard', 'no'],
help='set normalization strategy, default standard scale. \nIf set no, oringal features will be used. \nIf --model is not no, the parameter will be ignored.')
args = parser.parse_args()
train_TP_file = args.in_tp
train_FP_file = args.in_fp
premodel_file = args.model
out_model = args.out_model
random_seed = args.random_seed
scale_strategy = args.scale_strategy
xgb_params = {
'n_estimators':200,
'n_jobs':-1,
'random_state':random_seed,
# 'tree_method':'approx'
}
if premodel_file != 'no':
printx("loading the pre-trained model: {} ...".format(premodel_file))
premodel, normalizer = load_from_pickle(premodel_file, '../pretrain')
xgb_params['xgbdef'] = list(premodel[0].values())[0]
elif premodel_file == 'no' and scale_strategy == 'standard':
printx("standardly scale all features ...")
from sklearn.preprocessing import StandardScaler
normalizer = StandardScaler()
else:
normalizer = None
printx('load files, {} and {}'.format(train_TP_file, train_FP_file))
X_train, y_train = readData(train_TP_file, train_FP_file)
outmodel, normalizer = save_to_pickle(training_series(X_train, y_train, normalizer=normalizer, xgb_params=xgb_params),
out_model)
|
53692
|
from itsdangerous import TimedJSONWebSignatureSerializer, \
JSONWebSignatureSerializer
from nanohttp import settings, context, HTTPForbidden
class BaseJWTPrincipal:
def __init__(self, payload):
self.payload = payload
@classmethod
def create_serializer(cls, force=False, max_age=None):
config = cls.get_config()
if force:
return JSONWebSignatureSerializer(
config['secret'],
algorithm_name=config['algorithm']
)
else:
return TimedJSONWebSignatureSerializer(
config['secret'],
expires_in=max_age or config['max_age'],
algorithm_name=config['algorithm']
)
def dump(self, max_age=None):
return self.create_serializer(max_age=max_age).dumps(self.payload)
@classmethod
def load(cls, encoded, force=False):
if encoded.startswith('Bearer '):
encoded = encoded[7:]
payload = cls.create_serializer(force=force).loads(encoded)
return cls(payload)
@classmethod
def get_config(cls):
raise NotImplementedError()
class JWTPrincipal(BaseJWTPrincipal):
def is_in_roles(self, *roles):
if 'roles' in self.payload:
if set(self.payload['roles']).intersection(roles):
return True
return False
def assert_roles(self, *roles):
"""
.. versionadded:: 0.29
:param roles:
:return:
"""
if roles and not self.is_in_roles(*roles):
raise HTTPForbidden()
@property
def email(self):
return self.payload.get('email')
@property
def session_id(self):
return self.payload.get('sessionId')
@property
def id(self):
return self.payload.get('id')
@property
def roles(self):
return self.payload.get('roles', [])
@classmethod
def get_config(cls):
"""
Warning! Returned value is a dict, so it's mutable. If you modify this
value, default config of the whole project will be changed and it may
cause unpredictable problems.
"""
return settings.jwt
class JWTRefreshToken:
def __init__(self, payload):
self.payload = payload
@classmethod
def create_serializer(cls):
return TimedJSONWebSignatureSerializer(
settings.jwt.refresh_token.secret,
expires_in=settings.jwt.refresh_token.max_age,
algorithm_name=settings.jwt.refresh_token.algorithm
)
def dump(self):
return self.create_serializer().dumps(self.payload)
@classmethod
def load(cls, encoded):
payload = cls.create_serializer().loads(encoded)
return cls(payload)
@property
def id(self):
return self.payload.get('id')
class DummyIdentity(JWTPrincipal):
def __init__(self, *roles):
super().__init__({'roles': list(roles)})
class ImpersonateAs:
backup_identity = None
def __init__(self, principal):
self.principal = principal
def __enter__(self):
if hasattr(context, 'identity'):
self.backup_identity = context.identity
context.identity = self.principal
def __exit__(self, exc_type, exc_val, exc_tb):
context.identity = self.backup_identity
|
53739
|
import datetime
import json
import pandas as pd
import yfinance as yf
from yahoofinancials import YahooFinancials
from fastapi import FastAPI
app = FastAPI()
@app.get("/stock/{ticker}")
async def get_stock_data(ticker: str):
ticker_data = yf.Ticker(ticker).info
mktopen = ticker_data["open"]
mkthigh = ticker_data["dayHigh"]
mktlow = ticker_data["dayLow"]
mktvolume = ticker_data["volume"]
mkforwardPE = ticker_data["forwardPE"]
mkforwardEps = ticker_data["forwardEps"]
return {
"open": mktopen,
"high": mkthigh,
"low": mktlow,
"volume": mktvolume,
"forwardPE": mkforwardPE,
"forwardEps": mkforwardEps,
}
# This needs to be completed!
@app.get("/stock/historic/{ticker}")
async def get_historical_data(ticker: str, tperiod: str = "1mo"):
# periods: 1m,2m,5m,15m,30m,60m,90m,1h,1d,5d,1wk,1mo,3mo
ticker_data = yf.Ticker(ticker).history(period=tperiod)
return json.loads(ticker_data.to_json(orient="index", date_format="iso"))
@app.get("/stock/data-options/{ticker}")
async def get_data_options(ticker: str):
tk = yf.Ticker(ticker)
exps = tk.options
# Get options for each expiration
options = pd.DataFrame()
for e in exps:
opt = tk.option_chain(e)
opt = pd.DataFrame().append(opt.calls).append(opt.puts)
opt["expirationDate"] = e
options = options.append(opt, ignore_index=True)
# Bizarre error in yfinance that gives the wrong expiration date
# Add 1 day to get the correct expiration date
options["expirationDate"] = pd.to_datetime(
options["expirationDate"]
) + datetime.timedelta(days=1)
options["dte"] = (
options["expirationDate"] - datetime.datetime.today()
).dt.days / 365
# Boolean column if the option is a CALL
options["CALL"] = options["contractSymbol"].str[4:].apply(lambda x: "C" in x)
options[["bid", "ask", "strike"]] = options[["bid", "ask", "strike"]].apply(
pd.to_numeric
)
options["mark"] = (
options["bid"] + options["ask"]
) / 2 # Calculate the midpoint of the bid-ask
# Drop unnecessary and meaningless columns
options = options.drop(
columns=[
"contractSize",
"currency",
"change",
"percentChange",
"lastTradeDate",
"lastPrice",
]
)
pd.set_option("display.max_rows", 1500)
options = options.to_json(orient="records")
return options
@app.get("/stock/futures-data/{ticker}")
async def get_futures_data(ticker: str):
yahoo_financials_commodities = YahooFinancials(ticker)
daily_commodity_prices = yahoo_financials_commodities.get_historical_price_data(
'2008-09-15', '2018-09-15', 'daily')
futures_data = json.dumps(daily_commodity_prices, indent=4)
return futures_data
|
53753
|
from typing import Dict, List, Optional, Union
import numpy as np
import torch
MOLECULAR_ATOMS = (
"H,He,Li,Be,B,C,N,O,F,Ne,Na,Mg,Al,Si,P,S,Cl,Ar,K,Ca,Sc,Ti,V,Cr,Mn,Fe,Co,Ni,Cu,Zn,"
"Ga,Ge,As,Se,Br,Kr,Rb,Sr,Y,Zr,Nb,Mo,Tc,Ru,Rh,Pd,Ag,Cd,In,Sn,Sb,Te,I,Xe,Cs,Ba,La,Ce,"
"Pr,Nd,Pm,Sm,Eu,Gd,Tb,Dy,Ho,Er,Tm,Yb,Lu,Hf,Ta,W,Re,Os,Ir,Pt,Au,Hg,Tl,Pb,Bi,Po,At,"
"Rn,Fr,Ra,Ac,Th,Pa,U,Np,Pu,Am,Cm,Bk,Cf,Es,Fm,Md,No,Lr,Rf,Db,Sg,Bh,Hs,Mt,Ds,Rg,Cn,"
"Nh,Fl,Mc,Lv,Ts,Og"
).split(",")
MOLECULAR_CHARGES = list(range(-15, 16)) + [":", "^", "^^"]
MOLECULAR_BOND_TYPES = [1, 2, 3, 4, 5, 6, 7, 8]
class MolecularEncoder:
"""Molecular structure encoder class.
This class is a kind of tokenizers for MoT model. Every transformer models have
their own subword tokenizers (and it even creates attention masks), and of course
MoT needs its own input encoder. While 3D-molecular structure data is not as simple
as sentences which are used in common transformer model, we create new input encoder
which creates input encodings from the 3D-molecular structure data. Using this, you
can simply encode the structure data and pass to the MoT model.
Args:
cls_token: The name of classification token. Default is `[CLS]`.
pad_token: The name of padding token. Default is `[PAD]`.
"""
# This field is a part of MoT configurations. If you are using MoT model with this
# encoder class, then you can simply define the number of embeddings and attention
# types using this field. The vocabularies are predefined, so you do not need to
# handle the vocabulary sizes.
mot_config = dict(
num_embeddings=[len(MOLECULAR_ATOMS) + 2, len(MOLECULAR_CHARGES) + 2],
num_attention_types=len(MOLECULAR_BOND_TYPES) + 2,
)
def __init__(
self,
cls_token: str = "[CLS]",
pad_token: str = "[PAD]",
):
self.vocab1 = [pad_token, cls_token] + MOLECULAR_ATOMS
self.vocab2 = [pad_token, cls_token] + MOLECULAR_CHARGES
self.vocab3 = [pad_token, cls_token] + MOLECULAR_BOND_TYPES
self.cls_token = cls_token
self.pad_token = pad_token
def collect_input_sequences(self, molecular: Dict[str, List]) -> Dict[str, List]:
"""Collect input sequences from the molecular structure data.
Args:
molecular: The molecular data which contains 3D atoms and their bonding
informations.
Returns:
A dictionary which contains the input tokens and 3d positions of the atoms.
"""
input_ids = [
[self.vocab1.index(self.cls_token)],
[self.vocab2.index(self.cls_token)],
]
position_ids = [[0.0, 0.0, 0.0]]
attention_mask = [1] * (len(molecular["atoms"]) + 1)
for atom in molecular["atoms"]:
input_ids[0].append(self.vocab1.index(atom[3]))
input_ids[1].append(self.vocab2.index(atom[4]))
position_ids.append(atom[:3])
return {
"input_ids": input_ids,
"position_ids": position_ids,
"attention_mask": attention_mask,
}
def create_attention_type_ids(self, molecular: Dict) -> np.ndarray:
"""Create an attention types from the molecular structure data.
MoT supports attention types which are applied to the attention scores
relatively. Using this, you can give attention weights (bond types) directly to
the self-attention module. This method creates the attention type array by using
the bond informations in the molecular structure.
Args:
molecular: The molecular data which contains 3D atoms and their bonding
informations.
Returns:
The attention type array from the bond informations.
"""
max_seq_len = len(molecular["atoms"]) + 1
attention_type_ids = np.empty((max_seq_len, max_seq_len), dtype=np.int64)
attention_type_ids.fill(self.vocab3.index(self.pad_token))
attention_type_ids[0, :] = self.vocab3.index(self.cls_token)
attention_type_ids[:, 0] = self.vocab3.index(self.cls_token)
for first, second, bond_type in molecular["bonds"]:
attention_type_ids[first + 1, second + 1] = self.vocab3.index(bond_type)
attention_type_ids[second + 1, first + 1] = self.vocab3.index(bond_type)
return attention_type_ids
def encode(self, molecular: Dict[str, List]) -> Dict[str, Union[List, np.ndarray]]:
"""Encode the molecular structure data to the model inputs.
Args:
molecular: The molecular data which contains 3D atoms and their bonding
informations.
Returns:
An encoded output which contains input ids, 3d positions, position mask, and
attention types.
"""
return {
**self.collect_input_sequences(molecular),
"attention_type_ids": self.create_attention_type_ids(molecular),
}
def collate(
self,
encodings: List[Dict[str, Union[List, np.ndarray]]],
max_length: Optional[int] = None,
pad_to_multiple_of: Optional[int] = None,
) -> Dict[str, Union[List, np.ndarray, torch.Tensor]]:
"""Collate the encodings of which lengths are different to each other.
The lengths of encoded molecular structure data are not exactly same. To group
the sequences into the batch requires equal lengths. To resolve the problem,
this class supports sequence and attention mask paddings. Using this, you can
pad the encodings to desired lengths or match to the longest sequences. In
addition, this method automatically converts the sequences to torch tensors.
Args:
encodings: The batch of encodings.
max_length: The desired maximum length of sequences. Default is `None`.
pad_to_multiple_of: To match the sequence length to be multiple of certain
factor. Default is `None`.
Returns:
The collated batched encodings which contain converted tensors.
"""
longest_length = max(len(enc["input_ids"][0]) for enc in encodings)
max_length = min(max_length or longest_length, longest_length)
if pad_to_multiple_of is not None:
max_length = max_length + pad_to_multiple_of - 1
max_length = max_length // pad_to_multiple_of * pad_to_multiple_of
padding_id_1 = self.vocab1.index(self.pad_token)
padding_id_2 = self.vocab2.index(self.pad_token)
for enc in encodings:
num_paddings = max_length - len(enc["input_ids"][0])
if num_paddings >= 0:
enc["input_ids"][0] += [padding_id_1] * num_paddings
enc["input_ids"][1] += [padding_id_2] * num_paddings
enc["position_ids"] += [[0.0, 0.0, 0.0]] * num_paddings
enc["attention_mask"] += [0] * num_paddings
enc["attention_type_ids"] = np.pad(
enc["attention_type_ids"],
pad_width=((0, num_paddings), (0, num_paddings)),
constant_values=self.vocab3.index(self.pad_token),
)
else:
# If the encoded sequences are longer than the maximum length, then
# truncate the sequences and attention mask.
enc["input_ids"][0] = enc["input_ids"][0][:max_length]
enc["input_ids"][1] = enc["input_ids"][1][:max_length]
enc["position_ids"] = enc["position_ids"][:max_length]
enc["attention_mask"] = enc["attention_mask"][:max_length]
enc["attention_type_ids"] = enc["attention_type_ids"][
:max_length, :max_length
]
# Collect all sequences into their batch and convert them to torch tensor. After
# that, you can use the sequences to the model because all inputs are converted
# to the tensors. Since we use two `input_ids` and handle them on the list, they
# will be converted individually.
encodings = {k: [enc[k] for enc in encodings] for k in encodings[0]}
encodings["input_ids"] = [
torch.tensor([x[0] for x in encodings["input_ids"]]),
torch.tensor([x[1] for x in encodings["input_ids"]]),
]
encodings["position_ids"] = torch.tensor(encodings["position_ids"])
encodings["attention_mask"] = torch.tensor(encodings["attention_mask"])
encodings["attention_type_ids"] = torch.tensor(encodings["attention_type_ids"])
if "labels" in encodings:
encodings["labels"] = torch.tensor(encodings["labels"])
return encodings
|
53767
|
import pytest
from ncoreparser.util import Size
class TestSize:
@pytest.mark.parametrize("size1, size2", [("1024 MiB", "1 GiB"),
("10 MiB", "10 MiB"),
("2048 KiB", "2 MiB")])
def test_equal(self, size1, size2):
s1 = Size(size1)
s2 = Size(size2)
assert s1 == s2
@pytest.mark.parametrize("size1, size2", [("1023 MiB", "1 GiB"),
("10 MiB", "11 MiB"),
("2049 KiB", "2 MiB")])
def test_not_equal(self, size1, size2):
s1 = Size(size1)
s2 = Size(size2)
assert s1 != s2
@pytest.mark.parametrize("size1, size2", [("1025 MiB", "1 GiB"),
("11 MiB", "10 MiB"),
("2049 KiB", "2 MiB")])
def test_greater_than(self, size1, size2):
s1 = Size(size1)
s2 = Size(size2)
assert s1 > s2
@pytest.mark.parametrize("size1, size2", [("1025 MiB", "1 GiB"),
("10 MiB", "10 MiB"),
("2049 KiB", "2 MiB"),
("2048 KiB", "2 MiB")])
def test_greater_equal(self, size1, size2):
s1 = Size(size1)
s2 = Size(size2)
assert s1 >= s2
@pytest.mark.parametrize("size1, size2, expected", [("1024 MiB", "1 GiB", "2.00 GiB"),
("10 MiB", "11 MiB", "21.00 MiB"),
("2048 KiB", "2 MiB", "4.00 MiB")])
def test_add(self, size1, size2, expected):
s = Size(size1) + Size(size2)
assert str(s) == expected
s = Size(size1)
s += Size(size2)
assert str(s) == expected
|
53769
|
from bottle import (
template,
route,
redirect,
request,
)
from models import (
Article,
ArticleLinks,
Wiki,
Author,
Tag,
Metadata,
)
from peewee import SQL
from .decorators import *
from .wiki import wiki_home
from .media import image_search
from utils import Message, Error, Unsafe
import datetime
@route(f"{Wiki.PATH}/article")
@wiki_env
def articles(wiki: Wiki, user: Author):
return wiki_home(wiki, user)
@route(f"{Wiki.PATH}{Article.PATH}")
@article_env
def article_display_(wiki: Wiki, user: Author, article: Article):
return article_display(wiki, user, article)
def new_article_from_form_core(wiki: Wiki, user: Author, form: str, title: str):
form_article = wiki.articles.where(Article.title == wiki.url_to_title(form)).get()
new_article = form_article.make_from_form(wiki.url_to_title(title))
return redirect(new_article.edit_link)
@route(f"{Wiki.PATH}/new_from_form/<form>")
@wiki_env
def article_new_from_form(wiki: Wiki, user: Author, form: str):
return new_article_from_form_core(wiki, user, form, "Untitled")
@route(f"{Wiki.PATH}/new_from_form/<form>/<title>")
@wiki_env
def article_new_from_form_with_title(wiki: Wiki, user: Author, form: str, title: str):
return new_article_from_form_core(wiki, user, form, title)
@route(f"{Wiki.PATH}{Article.PATH}/revision/<revision_id>")
@article_env
def article_revision(wiki: Wiki, user: Author, article: Article, revision_id: str):
try:
revision = article.revisions.where(Article.id == int(revision_id)).get()
except Exception:
return wiki_home(wiki, user)
return template(
"article.tpl",
articles=[revision],
page_title=f"{revision.title} ({wiki.title})",
wiki=wiki,
)
@route(f"{Wiki.PATH}{Article.PATH}/history")
@article_env
def article_history(wiki: Wiki, user: Author, article: Article):
return template(
"article_history.tpl",
article=article,
page_title=f"History: {article.title} ({wiki.title})",
wiki=wiki,
)
@route(f"{Wiki.PATH}{Article.PATH}/preview", method=("GET", "POST"))
@article_env
def article_preview(wiki: Wiki, user: Author, article: Article):
if request.method == "POST":
article = Article(
title=request.forms.article_title, content=request.forms.article_content,
)
if article.id is None:
article.content = f'This article does not exist. Click the <a class="autogenerate" href="{article.edit_link}">edit link</a> to create this article.'
return template(
"includes/article_core.tpl",
article=article,
page_title=article.title,
wiki=wiki,
style=wiki.stylesheet(),
)
@route(f"{Wiki.PATH}{Article.PATH}/save", method="POST")
def article_save_ajax(wiki_title: str, article_title: str):
return article_edit(wiki_title, article_title, ajax=True)
@route(f"{Wiki.PATH}{Article.PATH}/edit", method=("GET", "POST"))
@article_env
def article_edit(wiki: Wiki, user: Author, article: Article, ajax=False):
# Redirect to article creation if we try to edit a nonexistent article
if article.id is None:
return redirect(f"{wiki.link}/new?title={Wiki.title_to_url(article.title)}")
# Redirect to edit link if we visit the draft of the article
if request.method == "GET":
if article.draft_of:
return redirect(article.draft_of.edit_link)
error = None
warning = None
# Create draft if it doesn't exist
if article.id is not None and not article.draft_of:
if article.drafts.count():
article = article.drafts.get()
else:
# TODO: check for name collisions
draft = Article(
wiki=article.wiki,
title=f"Draft: {article.title}",
content=article.content,
author=article.author,
created=article.created,
draft_of=article,
)
draft.save()
draft.update_links()
draft.update_autogen_metadata()
draft.copy_tags_from(article)
draft.copy_metadata_from(article)
article = draft
wiki.invalidate_cache()
original_article = article
original_id = article.id
# Check if article opened in edit mode without being formally closed out
if request.method == "GET":
if article.opened_by is None:
article.opened_by = article.author
article.last_edited = datetime.datetime.now()
article.save()
else:
warning = Message(
"This article was previously opened for editing without being saved. It may contain unsaved changes elsewhere. Use 'Save and Exit' or 'Quit Editing' to remove this message."
)
if request.method == "POST" or ajax is True:
action = request.forms.save
if action == "quit":
article.opened_by = None
article.save()
article.update_index()
article.update_autogen_metadata()
article.update_links()
wiki.invalidate_cache()
return redirect(article.link)
elif action == "discard":
wiki.invalidate_cache()
return redirect(article.discard_draft_link)
article_content = request.forms.article_content
article_title = request.forms.article_title
if article_content != article.content:
article.content = article_content
article.last_edited = datetime.datetime.now()
renamed = False
if article.new_title is None:
if article_title != article.draft_of.title:
article.new_title = article_title
renamed = True
else:
if article_title != article.new_title:
article.new_title = article_title
renamed = True
if renamed:
if article.has_new_name_collision():
error = Error(
f'An article named "{Unsafe(article_title)}" already exists. Choose another name for this article.'
)
if error is None:
article.save()
article.update_index()
article.update_links()
article.update_autogen_metadata()
wiki.invalidate_cache()
if action == "exit":
article.opened_by = None
article.save()
return redirect(article.link)
elif action in {"publish", "revise"}:
new_article = article.draft_of
if action == "revise":
new_article.make_revision()
if article.new_title:
new_article.title = article.new_title
# Check for rename options here
new_article.content = article.content
new_article.last_edited = article.last_edited
new_article.save()
new_article.update_index()
new_article.update_links()
new_article.clear_metadata()
new_article.update_autogen_metadata()
new_article.copy_metadata_from(article)
new_article.clear_tags()
new_article.copy_tags_from(article)
article.delete_()
return redirect(new_article.link)
elif action == "save":
article.opened_by = None
article.save()
if article.draft_of:
return redirect(article.draft_of.edit_link)
return redirect(article.link)
else:
original_article = Article.get(Article.id == article.id)
if ajax:
if error:
return str(error)
return str(Message("Article successfully saved.", color="success"))
article.content = article.content.replace("&", "&")
return template(
"article_edit.tpl",
article=article,
page_title=f"Editing: {article.title} ({wiki.title})",
wiki=wiki,
original_article=original_article,
messages=[error, warning],
has_error="true" if error else "false",
style=wiki.stylesheet(),
)
@route(f"{Wiki.PATH}{Article.PATH}/delete")
@article_env
def article_delete(wiki: Wiki, user: Author, article: Article):
warning = f'Article "{Unsafe(article.title)}" is going to be deleted! Deleted articles are GONE FOREVER.'
if article.revision_of:
warning += "<hr/>This is an earlier revision of an existing article. Deleting this will remove it from that article's revision history. This is allowed, but NOT RECOMMENDED."
return template(
"article.tpl",
articles=[article],
page_title=f"Delete: {article.title} ({wiki.title})",
wiki=wiki,
messages=[Message(warning, yes=article.delete_confirm_link, no=article.link,)],
)
@route(f"{Wiki.PATH}{Article.PATH}/delete/<delete_key>")
@article_env
def article_delete_confirm(
wiki: Wiki, user: Author, article: Article, delete_key: str, redirect_to=None,
):
if article.id is None:
return redirect(wiki.link)
if article.delete_key != delete_key:
return redirect(article.link)
# TODO: this stuff should be in the delete_instance method
ArticleLinks.update(link=article.title, valid_link=None).where(
ArticleLinks.valid_link == article
).execute()
if article.drafts.count():
draft = article.drafts.get()
draft.delete_()
for revision in article.revisions.select():
revision.delete_()
article.delete_()
# TODO: Move tag-clearing / orphan-check operations to override of delete_instance for article?
wiki.invalidate_cache()
if redirect_to is None:
redirect_to = wiki.main_article
return template(
"article.tpl",
wiki=wiki,
articles=[redirect_to],
messages=[Error(f'Article "{Unsafe(article.title)}" has been deleted.')],
)
@route(f"{Wiki.PATH}{Article.PATH}/discard-draft")
@article_env
def draft_discard(wiki: Wiki, user: Author, article: Article):
if article.id is None:
return redirect(article.link)
if article.draft_of is None:
return redirect(article.link)
warning = f'"{Unsafe(article.title)}" is going to be discarded.'
if article.content != article.draft_of.content:
warning += (
"<br/>THIS DRAFT HAS MODIFICATIONS THAT WERE NOT SAVED TO THE ARTICLE."
)
return template(
"article.tpl",
articles=[article],
page_title=f"Discard draft: {article.title} ({wiki.title})",
wiki=wiki,
messages=[
Message(warning, yes=article.discard_draft_confirm_link, no=article.link,)
],
)
@route(f"{Wiki.PATH}{Article.PATH}/discard-draft/<delete_key>")
@article_env
def draft_discard_confirm(
wiki: Wiki, user: Author, article: Article, delete_key: str,
):
return article_delete_confirm.__wrapped__(
wiki, user, article, delete_key, redirect_to=article.draft_of
)
@route(f"{Wiki.PATH}{Article.PATH}/insert-image")
@article_env
def modal_insert_image(wiki: Wiki, user: Author, article: Article):
return template(
"includes/modal.tpl",
title="Insert image into article",
body=template(
"includes/modal_search.tpl",
url=f"{article.link}/insert-image",
search_results=image_search(wiki, None),
),
footer="",
)
@route(f"{Wiki.PATH}{Article.PATH}/insert-image", method="POST")
@article_env
def modal_insert_image_search(wiki: Wiki, user: Author, article: Article):
search = request.forms.search_query
return image_search(wiki, search)
def existing_tags(article):
taglist = [""]
for tag in article.tags_alpha:
taglist.append(
f'<a href="#" onclick="removeTag(this)"; title="Click to remove this tag from this article" class="badge badge-primary">{tag.title}</a> '
)
tags = "".join(taglist)
return tags
def search_results(wiki, search):
if search is None or search == "":
search_results = (
wiki.tags.select().order_by(SQL("title COLLATE NOCASE")).limit(100)
)
else:
search_results = (
wiki.tags.select()
.where(Tag.title.contains(search))
.order_by(SQL("title COLLATE NOCASE"))
.limit(10)
)
results = ["<ul>"]
for result in search_results:
results.append(
f'<li><a href="#" onclick="insertTag(this);">{result.title}</li>'
)
results.append("</ul>")
return "".join(results)
@route(f"{Wiki.PATH}{Article.PATH}/insert-tag")
@article_env
def modal_tags(wiki: Wiki, user: Author, article: Article):
tags = existing_tags(article)
body = template(
"includes/modal_tag_search.tpl",
url=f"{article.link}/insert-tag",
search_results=search_results(wiki, None),
)
return template(
"includes/modal.tpl",
title="Edit article tags",
body=f'Existing tags (click to remove):<br/><div id="modal-tag-listing">{tags}</div><hr/>{body}',
footer="",
)
@route(f"{Wiki.PATH}{Article.PATH}/insert-tag", method="POST")
@article_env
def modal_tags_search(wiki: Wiki, user: Author, article: Article):
search = request.forms.search_query
return search_results(wiki, search)
@route(f"{Wiki.PATH}{Article.PATH}/add-tag", method="POST")
@article_env
def modal_add_tag(wiki: Wiki, user: Author, article: Article):
tag = request.forms.tag
article.add_tag(tag)
wiki.invalidate_cache()
return existing_tags(article)
@route(f"{Wiki.PATH}{Article.PATH}/remove-tag", method="POST")
@article_env
def modal_remove_tag(wiki: Wiki, user: Author, article: Article):
tag = request.forms.tag
article.remove_tag(tag)
wiki.invalidate_cache()
return existing_tags(article)
@route(f"{Wiki.PATH}{Article.PATH}/edit-metadata")
@article_env
def modal_edit_metadata(wiki: Wiki, user: Author, article: Article):
return template(
"includes/modal.tpl",
title="Edit article metadata",
body=template(
"includes/modal_metadata.tpl",
url=f"{article.link}/edit-metadata",
article=article,
),
footer="",
)
@route(f"{Wiki.PATH}{Article.PATH}/edit-metadata", method="POST")
@article_env
def modal_edit_metadata_post(wiki: Wiki, user: Author, article: Article):
key = request.forms.key
if key:
value = request.forms.value
article.set_metadata(key, value)
delete = request.forms.delete
if delete:
try:
delete_instance = article.metadata.where(Metadata.id == delete).get()
delete_instance.delete_instance()
except Metadata.DoesNotExist:
pass
return template(
"includes/modal_metadata.tpl",
url=f"{article.link}/edit-metadata",
article=article,
)
def link_search(wiki, search):
search_results = wiki.articles.select().where(
Article.draft_of.is_null(), Article.revision_of.is_null()
)
if search:
search_results = search_results.where(Article.title.contains(search))
search_results = search_results.order_by(SQL("title COLLATE NOCASE")).limit(10)
results = ['<ul class="list-unstyled">']
for result in search_results:
link = f'<li><a onclick="insertLinkFromList(this);" href="#">{result.title}</a></li>'
results.append(link)
return "".join(results)
@route(f"{Wiki.PATH}{Article.PATH}/insert-link")
@article_env
def modal_insert_link_search(wiki: Wiki, user: Author, article: Article):
return template(
"includes/modal.tpl",
title="Insert link into article",
body=template(
"includes/modal_search.tpl",
url=f"{article.link}/insert-link",
search_results=link_search(wiki, None),
alt_input=("Text for link", "link_text"),
),
footer="",
)
@route(f"{Wiki.PATH}{Article.PATH}/insert-link", method="POST")
@article_env
def modal_insert_link_search_post(wiki: Wiki, user: Author, article: Article):
search = request.forms.search_query
return link_search(wiki, search)
|
53794
|
from geosolver.utils.prep import sentence_to_words_statements_values
__author__ = 'minjoon'
def test_prep():
paragraph = r"If \sqrt{x+5}=40.5, what is x+5?"
print(sentence_to_words_statements_values(paragraph))
if __name__ == "__main__":
test_prep()
|
53816
|
import argparse
import calendar
from datetime import datetime
import glob
import os
import shutil
import subprocess
import sys
import gzip
import unifyQueryTypes
from utility import utility
import config
os.nice(19)
months = {'january': [1, 31],
'february': [2, 28],
'march': [3, 31],
'april': [4, 30],
'may': [5, 31],
'june': [6, 30],
'july': [7, 31],
'august': [8, 31],
'september': [9, 30],
'october': [10, 31],
'november': [11, 30],
'december': [12, 31]}
parser = argparse.ArgumentParser("This script extracts the raw log data (if "
+ "it was not already done), processes them"
+ " using the java application and unifies "
+ "the query types.")
parser.add_argument("--ignoreLock", "-i", help="Ignore locked file and "
+ "execute anyways", action="store_true")
parser.add_argument("--threads", "-t", default=6, type=int, help="The number "
+ "of threads to run the java program with (default 7).")
parser.add_argument("--logging", "-l", help="Enables file logging.",
action="store_true")
parser.add_argument("--noBotMetrics", "-b", help="Disables metric calculation"
+ " for bot queries.", action="store_true")
parser.add_argument("--noDynamicQueryTypes", "-d", help="Disables dynamic "
+ "generation of query types.", action="store_true")
parser.add_argument("--noGzipOutput", "-g", help="Disables gzipping of the "
+ "output files.", action="store_true")
parser.add_argument("--noExampleQueriesOutput", "-e", help="Disables the "
+ "matching of example queries.", action="store_true")
parser.add_argument("--withUniqueQueryDetection", "-u", help="Enable unique query detection", action="store_true")
parser.add_argument("--dbLocation", "-p", type = str, default = config.dbLocation, help = "The path of the uniqueQueriesMapDb file.")
parser.add_argument("--queryTypeMapLocation", "-q", type = str, default = config.queryTypeMapDbLocation, help = "The path of the query type map db file. Default is in the working directory.")
parser.add_argument("--monthsFolder", "-m", default=config.monthsFolder,
type=str,
help="The folder in which the months directory are "
+ "residing.")
parser.add_argument("--year", "-y", default=datetime.now().year, type=int,
help="The year to be processed (default current year).")
parser.add_argument("months", type=str, help="The months to be processed")
# These are the field we extract from wmf.wdqs_extract that form the raw
# log data. They are not configurable via argument because the java program
# does not detect headers and thus depends on this specific order.
fields = ["uri_query", "uri_path", "user_agent", "ts", "agent_type",
"hour", "http_status"]
header = ""
for field in fields:
header += field + "\t"
header = header[:-1] + "\n"
if (len(sys.argv[1:]) == 0):
parser.print_help()
parser.exit()
args = parser.parse_args()
if calendar.isleap(args.year):
months['february'][1] = 29
for monthName in args.months.split(","):
if os.path.isfile(utility.addMissingSlash(args.monthsFolder)
+ utility.addMissingSlash(monthName) + "locked") \
and not args.ignoreLock:
print "ERROR: The month " + monthName + " is being edited at the " \
+ "moment. Use -i if you want to force the execution of this script."
sys.exit()
month = utility.addMissingSlash(os.path.abspath(utility.addMissingSlash(args.monthsFolder)
+ utility.addMissingSlash(monthName)))
processedLogDataDirectory = month + "processedLogData/"
rawLogDataDirectory = month + "rawLogData/"
tempDirectory = rawLogDataDirectory + "temp/"
# If the month directory does not exist it is being created along with
# the directories for raw and processed log data.
if not os.path.exists(month):
print("Starting data extraction from wmf.wdqs_extract for "
+ monthName + ".")
os.makedirs(month)
os.makedirs(processedLogDataDirectory)
os.makedirs(rawLogDataDirectory)
# For each day we send a command to hive that extracts all entries for
# this day (in the given month and year) and writes them to temporary
# files.
for day in xrange(1, months[monthName][1] + 1):
arguments = ['hive', '-e']
os.makedirs(tempDirectory)
hive_call = 'insert overwrite local directory \'' + tempDirectory \
+ '\' row format delimited fields terminated ' \
+ 'by \'\\t\' select '
# We add all the fields to the request
for field in fields:
hive_call += field + ", "
hive_call = hive_call[:-2] + " "
hive_call += ' from wmf.wdqs_extract where uri_query<>"" ' \
+ 'and year=\'' + str(args.year) + '\' and month=\'' \
+ str(months[monthName][0]) + '\' and day=\'' + str(day) + '\''
arguments.append(hive_call)
if subprocess.call(arguments) != 0:
print("ERROR: Raw data for month " + monthName + " does not "
+ "exist but could not be extracted using hive.")
sys.exit(1)
# The content of the temporary files is then copied to the actual
# raw log data file (with added headers)
with gzip.open(rawLogDataDirectory + "QueryCnt"
+ "%02d"%day + ".tsv.gz", "wb") as dayfile:
dayfile.write(header)
for filename in glob.glob(tempDirectory + '*'):
with open(filename) as temp:
for line in temp:
dayfile.write(line)
shutil.rmtree(tempDirectory)
# We build the call to execute the java application with the location of
# the files, the number of threads to use and any optional arguments needed
mavenCall = ['mvn', 'exec:java@QueryAnalysis']
mavenArguments = '-Dexec.args=-w ' + month + ' -t ' + str(args.threads) + ' -p ' + args.dbLocation + " -q " + args.queryTypeMapLocation
if args.logging:
mavenArguments += " -l"
if args.noBotMetrics:
mavenArguments += " -b"
if args.noDynamicQueryTypes:
mavenArguments += " -d"
if args.noGzipOutput:
mavenArguments += " -g"
if args.noExampleQueriesOutput:
mavenArguments += " -e"
if args.withUniqueQueryDetection:
mavenArguments += " -u"
mavenCall.append(mavenArguments)
owd = os.getcwd()
os.chdir("..")
print "Starting data processing using QueryAnalysis for " + monthName + "."
if subprocess.call(['mvn', 'clean', 'package']) != 0:
print "ERROR: Could not package the java application."
sys.exit(1)
if subprocess.call(mavenCall) != 0:
print("ERROR: Could not execute the java application. Check the logs "
+ "for details or rerun this script with -l to generate logs.")
sys.exit(1)
os.chdir(owd)
|
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
|
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']
)
|
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
|
53963
|
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
import os
import pickle
def add_scatter(ax,x,y,c='b',m='o',lab='',s=80,drawln=False,alpha=1):
ax.scatter(x,y, s=s, lw=2.,facecolors='none',edgecolors=c, marker=m,label=lab,alpha=alpha)
if drawln: ax.plot(x,y, c=c,ls='-')
def draw_unit_sphere(ramin=243.,ramax=246.,dcmin=7.,dcmax=10.,Nran=216000,seed=2015):
'''# from https://github.com/desihub/imaginglss/master/scripts/imglss-mpi-make-random.py'''
rng = np.random.RandomState(seed)
u1,u2= rng.uniform(size=(2, Nran))
#
cmin = np.sin(dcmin*np.pi/180)
cmax = np.sin(dcmax*np.pi/180)
#
RA = ramin + u1*(ramax-ramin)
DEC = 90-np.arccos(cmin+u2*(cmax-cmin))*180./np.pi
return RA,DEC
class QuickRandoms(object):
'''Draw randomly from unit sphere
Example:
qran= QuickRandoms(ramin=243.,ramax=246.,dcmin=7.,dcmax=10.,Nran=216000)
qran.get_randoms()
# save and plot
qran.save_randoms()
qran.plot(xlim=(244.,244.1),ylim=(8.,8.1)) #,xlim=(244.,244.+10./360),ylim=(8.,8.+10./360.))
'''
def __init__(self,ramin=243.,ramax=246.,dcmin=7.,dcmax=10.,Nran=216000):
self.ramin=ramin
self.ramax=ramax
self.dcmin=dcmin
self.dcmax=dcmax
self.Nran=Nran
def get_randoms(self, fn='quick_randoms.pickle'):
if os.path.exists(fn):
ra,dec= self.read_randoms()
else:
ra,dec=draw_unit_sphere(ramin=self.ramin,ramax=self.ramax,\
dcmin=self.dcmin,dcmax=self.dcmax,Nran=self.Nran)
self.ra,self.dec=ra,dec
def save_randoms(self,fn='quick_randoms.pickle'):
if not os.path.exists(fn):
fout=open(fn, 'w')
pickle.dump((self.ra,self.dec),fout)
fout.close()
print("Wrote randoms to: %s" % fn)
else:
print("WARNING: %s exists, not overwritting it" % fn)
def read_randoms(self,fn='quick_randoms.pickle'):
print("Reading randoms from %s" % fn)
fobj=open(fn, 'r')
ra,dec= pickle.load(fobj)
fobj.close()
return ra,dec
def plot(self,xlim=None,ylim=None,text=''):
fig,ax=plt.subplots()
add_scatter(ax,self.ra,self.dec,c='b',m='.',alpha=0.5)
ax.set_xlabel('RA')
ax.set_ylabel('DEC')
if xlim is not None and ylim is not None:
ax.set_xlim(xlim)
ax.set_ylim(ylim)
text='_xlim%0.5f_%.5f_ylim%.5f_%.5f' % (xlim[0],xlim[1],ylim[0],ylim[1])
plt.savefig("quick_randoms%s.png" % text)
plt.close()
class DesiRandoms(object):
'''Draw randomly from unit sphere & provide 2 masks:
mask1: inbricks -- indices where ra,dec pts are in LegacySurvey bricks
mask2: inimages -- union with inbricks and where we have legacy survey imaging data at these ra,dec pts
Example:
ran= DesiRandoms(ramin=243.,ramax=246.,dcmin=7.,dcmax=10.,Nran=216000)
ran.get_randoms()
# save randoms if file not exist and plot
ran.save_randoms()
ran.plot(xlim=(244.,244.1),ylim=(8.,8.1)) #,xlim=(244.,244.+10./360),ylim=(8.,8.+10./360.))
'''
def __init__(self,ramin=243.,ramax=246.,dcmin=7.,dcmax=10.,Nran=216000):
self.ramin=ramin
self.ramax=ramax
self.dcmin=dcmin
self.dcmax=dcmax
self.Nran=Nran
def get_randoms(self,fn='desi_randoms.pickle'):
if os.path.exists(fn):
self.ra,self.dec,self.i_inbricks,self.i_inimages= self.read_randoms()
else:
self.ra,self.dec,self.i_inbricks,self.i_inimages= self.make_randoms()
def save_randoms(self,fn='desi_randoms.pickle'):
if not os.path.exists(fn):
fout=open(fn, 'w')
pickle.dump((self.ra,self.dec,self.i_inbricks,self.i_inimages),fout)
fout.close()
print("Wrote: %s" % fn)
else:
print "WARNING: not saving randoms b/c file already exists: %s" % fn
def make_randoms(self):
'''Nran -- # of randoms'''
import imaginglss
from imaginglss.model import dataproduct
from imaginglss.model.datarelease import contains
import h5py
print "Creating %d Randoms" % self.Nran
# dr2 cache
decals = imaginglss.DECALS('/project/projectdirs/desi/users/burleigh/dr3_testdir_for_bb/imaginglss/dr2.conf.py')
foot= decals.datarelease.create_footprint((self.ramin,self.ramax,self.dcmin,self.dcmax))
print('Total sq.deg. covered by Bricks= ',foot.area)
# Sample full ra,dec box
ra,dec=draw_unit_sphere(ramin=self.ramin,ramax=self.ramax,\
dcmin=self.dcmin,dcmax=self.dcmax,Nran=self.Nran)
#randoms = np.empty(len(ra), dtype=dataproduct.RandomCatalogue)
#randoms['RA'] = ra
#randoms['DEC'] = dec
# Get indices of inbrick points, copied from def filter()
coord= np.array((ra,dec))
bid = foot.brickindex.query_internal(coord)
i_inbricks = contains(foot._covered_brickids, bid)
i_inbricks = np.where(i_inbricks)[0]
print('Number Density in bricks= ',len(ra)/foot.area)
# Union of inbricks and have imaging data, evaluate depths at ra,dec
coord= coord[:, i_inbricks]
cat_lim = decals.datarelease.read_depths(coord, 'grz')
depth= cat_lim['DECAM_DEPTH'] ** -0.5 / cat_lim['DECAM_MW_TRANSMISSION']
nanmask= np.isnan(depth)
nanmask=np.all(nanmask[:,[1,2,4]],axis=1) # shape (Nran,)
i_inimages= i_inbricks[nanmask == False]
print('ra.size=%d, i_inbricks.size=%d, i_inimages.size=%d' % (ra.size, i_inbricks.size, i_inimages.size))
# We are not using Yu's randoms dtype=dataproduct.RandomCatalogue
#randoms['INTRINSIC_NOISELEVEL'][:, :6] = (cat_lim['DECAM_DEPTH'] ** -0.5 / cat_lim['DECAM_MW_TRANSMISSION'])
#randoms['INTRINSIC_NOISELEVEL'][:, 6:] = 0
#nanmask = np.isnan(randoms['INTRINSIC_NOISELEVEL'])
#randoms['INTRINSIC_NOISELEVEL'][nanmask] = np.inf
print('Total sq.deg. where have imaging data approx.= ',foot.area*(len(ra[i_inimages]))/len(ra))
print('Number Density for sources where have images= ',len(ra[i_inimages])/foot.area)
# save ra,dec,mask to file
#with h5py.File('eboss_randoms.hdf5', 'w') as ff:
# ds = ff.create_dataset('_HEADER', shape=(0,))
# ds.attrs['FootPrintArea'] = decals.datarelease.footprint.area
# ds.attrs['NumberDensity'] = 1.0 * len(randoms) / decals.datarelease.footprint.area
# for column in randoms.dtype.names:
# ds = ff.create_dataset(column, data=randoms[column])
# ds = ff.create_dataset('nanmask', data=nanmask)
return ra,dec, i_inbricks,i_inimages
def plot(self,name='desirandoms.png'):
fig,ax=plt.subplots(1,3,sharey=True,sharex=True,figsize=(15,5))
add_scatter(ax[0],self.ra, self.dec, c='b',m='o')
add_scatter(ax[1],self.ra[self.i_inbricks], self.dec[self.i_inbricks], c='b',m='.')
add_scatter(ax[2],self.ra[self.i_inimages], self.dec[self.i_inimages], c='b',m='.')
for i,title in zip(range(3),['All','in Bricks','in Images']):
ti=ax[i].set_title(title)
xlab=ax[i].set_xlabel('ra')
ax[i].set_ylim((self.dec.min(),self.dec.max()))
ax[i].set_xlim((self.ra.min(),self.ra.max()))
ylab=ax[0].set_ylabel('dec')
plt.savefig(name, bbox_extra_artists=[ti,xlab,ylab], bbox_inches='tight',dpi=150)
plt.close()
print "wrote: %s" % name
class Angular_Correlator(object):
'''Compute w(theta) from observed ra,dec and random ra,dec
uses landy szalay estimator: DD - 2DR + RR / RR
two numerical methods: 1) Yu Feng's kdcount, 2) astroML
Example:
ac= Angular_Correlator(gal_ra,gal_dec,ran_ra,ran_dec)
ac.compute()
ac.plot()
'''
def __init__(self,gal_ra,gal_dec,ran_ra,ran_dec,ncores=1):
self.gal_ra=gal_ra
self.gal_dec=gal_dec
self.ran_ra=ran_ra
self.ran_dec=ran_dec
self.ncores=ncores
def compute(self):
self.theta,self.w={},{}
for key in ['astroML','yu']:
self.theta[key],self.w[key]= self.get_angular_corr(whos=key)
self.plot()
def get_angular_corr(self,whos='yu'):
if whos == 'yu': return self.ac_yu()
elif whos == 'astroML': return self.ac_astroML()
else: raise ValueError()
def ac_astroML(self):
'''from two_point_angular() in astroML/correlation.py'''
from astroML.correlation import two_point,ra_dec_to_xyz,angular_dist_to_euclidean_dist
# 3d project
data = np.asarray(ra_dec_to_xyz(self.gal_ra, self.gal_dec), order='F').T
data_R = np.asarray(ra_dec_to_xyz(self.ran_ra, self.ran_dec), order='F').T
# convert spherical bins to cartesian bins
bins = 10 ** np.linspace(np.log10(1. / 60.), np.log10(6), 16)
bins_transform = angular_dist_to_euclidean_dist(bins)
w= two_point(data, bins_transform, method='landy-szalay',data_R=data_R)
bin_centers = 0.5 * (bins[1:] + bins[:-1])
return bin_centers, w
def ac_yu(self):
from kdcount import correlate
from kdcount import sphere
abin = sphere.AngularBinning(np.logspace(-4, -2.6, 10))
D = sphere.points(self.gal_ra, self.gal_dec)
R = sphere.points(self.ran_ra, self.ran_dec) #weights=wt_array
DD = correlate.paircount(D, D, abin, np=self.ncores)
DR = correlate.paircount(D, R, abin, np=self.ncores)
RR = correlate.paircount(R, R, abin, np=self.ncores)
r = D.norm / R.norm
w= (DD.sum1 - 2 * r * DR.sum1 + r ** 2 * RR.sum1) / (r ** 2 * RR.sum1)
return abin.angular_centers,w
def plot(self,name='wtheta.png'):
fig,ax=plt.subplots()
for key,col,mark in zip(['yu','astroML'],['g','b'],['o']*2):
print "%s: theta,w" % key,self.theta[key],self.w[key]
add_scatter(ax,self.theta[key], self.w[key], c=col,m=mark,lab=key,alpha=0.5)
t = np.array([0.01, 10])
plt.plot(t, 10 * (t / 0.01) ** -0.8, ':k', lw=1)
ax.legend(loc='upper right',scatterpoints=1)
xlab=ax.set_xlabel(r'$\theta$ (deg)')
ylab=ax.set_ylabel(r'$\hat{w}(\theta)$')
ax.set_xscale('log')
ax.set_yscale('log')
plt.savefig(name, bbox_extra_artists=[xlab,ylab], bbox_inches='tight',dpi=150)
plt.close()
print "wrote: %s" % name
def ac_unit_test():
'''angular correlation func unit test'''
qran= QuickRandoms(ramin=243.,ramax=246.,dcmin=7.,dcmax=10.,Nran=216000)
qran.get_randoms()
# subset
index= np.all((qran.ra >= 244.,qran.ra <= 244.5,\
qran.dec >= 8.,qran.dec <= 8.5),axis=0)
ra,dec= qran.ra[index],qran.dec[index]
# use these as Ducks for DesiRandoms
ran= DesiRandoms()
ran.ra,ran.dec= ra,dec
index= np.all((ran.ra >= 244.,ran.ra <= 244.25),axis=0)
ran.i_inbricks= np.where(index)[0]
index= np.all((index,ran.dec >= 8.1,ran.dec <= 8.4),axis=0)
ran.i_inimages= np.where(index)[0]
ran.plot()
# wtheta
ac= Angular_Correlator(ran.ra[ran.i_inimages],ran.dec[ran.i_inimages],ran.ra,ran.dec)
ac.compute()
ac.plot()
print 'finished unit_test'
if __name__ == '__main__':
#ac_unit_test()
#Nran=int(2.4e3*9.)
#ran= DesiRandoms(ramin=243.,ramax=246.,dcmin=7.,dcmax=10.,Nran=216000)
Nran=int(2.4e3*1.e2)
ran= DesiRandoms(ramin=120.,ramax=130.,dcmin=20.,dcmax=30.,Nran=Nran)
ran.get_randoms()
# save randoms if file not exist and plot
ran.save_randoms(fn='desi_randoms_qual.pickle')
ran.plot()
|
53984
|
from ..MetaDataObject.core.Simple import Simple
class Constant(Simple):
ext_code = {
'mgr': '1', # модуль менеджера Константы
'obj': '0', # модуль менеджера значения Константы
}
@classmethod
def get_decode_header(cls, header_data):
return header_data[0][1][1][1][1]
|
54030
|
from trajminer import TrajectoryData
from trajminer.preprocessing import TrajectorySegmenter
data = TrajectoryData(attributes=['poi', 'hour', 'rating'],
data=[[['Bakery', 8, 8.6], ['Work', 9, 8.9],
['Restaurant', 12, 7.7], ['Bank', 12, 5.6],
['Work', 13, 8.9], ['Home', 19, 0]],
[['Home', 8, 0], ['Mall', 10, 9.3],
['Home', 19, 0], ['Pub', 21, 9.5]]],
tids=[20, 24],
labels=[1, 2])
class TestTrajectorySegmenter(object):
def test_missing(self):
assert True
def test_ignore_missing(self):
assert True
def test_strict_no_thresholds(self):
segmenter = TrajectorySegmenter(attributes=data.get_attributes(),
thresholds=None, mode='strict',
n_jobs=1)
print(segmenter.fit_transform(data))
assert True # TO-DO
def test_strict_subset_thresholds(self):
segmenter = TrajectorySegmenter(attributes=data.get_attributes(),
thresholds=None, mode='strict',
n_jobs=1)
print(segmenter.fit_transform(data))
assert True # TO-DO
def test_any_no_thresholds(self):
segmenter = TrajectorySegmenter(attributes=data.get_attributes(),
thresholds=None, mode='any',
n_jobs=1)
print(segmenter.fit_transform(data))
assert True # TO-DO
def test_any_subset_thresholds(self):
segmenter = TrajectorySegmenter(attributes=data.get_attributes(),
thresholds=None, mode='any',
n_jobs=1)
print(segmenter.fit_transform(data))
assert True # TO-DO
|
54077
|
from django import template
import logging
from django.conf import settings
from django.template.defaultfilters import stringfilter
from django_cradmin import css_icon_map
register = template.Library()
log = logging.getLogger(__name__)
@register.simple_tag
@stringfilter
def cradmin_icon(iconkey):
"""
Returns the css class for an icon configured with the
given key in ``DJANGO_CRADMIN_CSS_ICON_MAP``.
"""
iconmap = getattr(settings, 'DJANGO_CRADMIN_CSS_ICON_MAP', css_icon_map.FONT_AWESOME)
icon_classes = iconmap.get(iconkey, '')
if not icon_classes:
log.warn('No icon named "%s" in settings.DJANGO_CRADMIN_ICONMAP.', iconkey)
return icon_classes
|
54079
|
from os.path import join, exists
import datatable as dt
from rs_datasets.data_loader import download_dataset
from rs_datasets.generic_dataset import Dataset, safe
class YooChoose(Dataset):
def __init__(self, path: str = None):
"""
:param path: folder which is used to download dataset to
if it does not contain dataset files.
If files are found, load them.
"""
super().__init__(path)
folder = join(self.data_folder, 'yoochoose')
if not exists(folder):
self._download(folder)
self.log = dt.fread(
join(folder, 'yoochoose-clicks.dat'),
columns=['session_id', 'ts', 'item_id', 'category']
).to_pandas()
self.purchases = dt.fread(
join(folder, 'yoochoose-buys.dat'),
columns=['session_id', 'ts', 'item_id', 'price', 'quantity']
).to_pandas()
self.test = dt.fread(
join(folder, 'yoochoose-test.dat'),
columns=['session_id', 'ts', 'item_id', 'category']
).to_pandas()
@safe
def _download(self, path):
self.logger.info('Downloading YooChoose Dataset...')
url = 'https://s3-eu-west-1.amazonaws.com/yc-rdata/yoochoose-data.7z'
download_dataset(url, join(self.data_folder, 'yoochoose.7z'))
|
54122
|
import types
import threading
import time
__all__ = 'suspend', 'suspending', 'start', 'Continuation',
_CONT_REQUEST = object()
@types.coroutine
def suspend(fn, *args):
"""Suspend the currently running coroutine and invoke FN with the continuation."""
cont = yield _CONT_REQUEST
fn(cont, *args)
cont_retval = yield
return cont_retval
class suspending:
"""Provide continuation to the code entering the context manager,
and suspend on exit.
async with corocc.suspending() as cont:
... # store cont somewhere, or call it
# if cont() was not invoked inside the async with block,
# suspension happens at this point
# invocation of cont() resumes coroutine here.
"""
__slots__ = ('_cont',)
@types.coroutine
def __aenter__(self):
cont = yield _CONT_REQUEST
self._cont = cont
return cont
@types.coroutine
def __aexit__(self, _t, v, _tb):
# if there is an exception, raise it immediately, don't wait
# until resumption
if v is not None:
raise v
self._cont.result = yield
class Continuation:
"""
Object that can be invoked to continue a suspended coroutine.
Continuations are one-shot, invoking a continuation more than once
results in a RuntimeError.
"""
# using __slots__ actually makes a noticable impact on performance
__slots__ = ('_driver', '_invoked_in', '_contval', '_coro_deliver',
'result')
def __cont(self, val, coro_deliver):
# Continue the coroutine, or store the intended continuation value and
# let the caller continue it. coro_deliver is coro.send if the
# coroutine resumes normally, or coro.throw if it resumes with an
# exception.
if self._invoked_in is not None:
raise RuntimeError("coroutine already resumed")
here = threading.current_thread()
self._invoked_in = here
driver = self._driver
if driver.step_thread is not here:
# resume the coroutine with the provided value
while driver.coro_running:
time.sleep(.0001)
driver.step(coro_deliver, val)
else:
# if cont() was invoked from inside suspend, do not step,
# just return to the current step and let it resume
self._contval = val
self._coro_deliver = coro_deliver
def __call__(self, value=None, __cont=__cont):
"""Continue the coroutine with the provided value, or None."""
__cont(self, value, self._driver.coro_send)
def throw(self, e, __cont=__cont):
"""Continue the coroutine with the provided exception."""
__cont(self, e, self._driver.coro_throw)
class _Driver:
__slots__ = ('coro', 'coro_send', 'coro_throw', 'resumefn',
'future', 'start_data', 'coro_running', 'step_thread')
def step(self, coro_deliver, contval):
# Run a step of the coroutine, i.e. execute it until a suspension or
# completion, whichever happens first.
here = self.step_thread = threading.current_thread()
while True:
if not self.resumefn(coro_deliver, contval):
return
cont = Continuation()
cont._driver = self
cont._invoked_in = None
self._resume_with_cont(cont)
if cont._invoked_in is not here:
# The continuation was not invoked, or was invoked in a
# different thread. This step is done, it's now up to cont to
# call us again. Set step_thread to a non-thread value, so
# that cont knows it has to call step() regardless of which
# thread it's invoked in.
self.step_thread = None
return
# The continuation was invoked immediately, so the suspension
# didn't really happen. Resume the coroutine with the provided
# value.
contval = cont._contval
coro_deliver = cont._coro_deliver
def _resume_with_cont(self, cont):
self.coro_running = True
try:
ret = self.coro_send(cont)
except StopIteration:
raise AssertionError("suspend didn't yield")
finally:
self.coro_running = False
if ret is _CONT_REQUEST:
raise RuntimeError("nested suspending() inside in the same coroutine "
"is not allowed")
@staticmethod
def resume_simple(coro_deliver, val):
# Resume the coroutine with VAL. coro_deliver is either
# self._coro.send or self._coro.throw.
#
# Return whether the coroutine can be further invoked, i.e. false if
# completed. Coroutine's result is ignored and exceptions raised by
# the coroutine are propagated to the caller.
try:
coro_deliver(val)
return True
except StopIteration:
return False
def resume_catching(self, coro_deliver, val):
# Like resume_simple, but if the coroutine completes, store result
# into self.future. If the coroutine execution raises, store
# exception into self.future.
try:
coro_deliver(val)
except StopIteration as e:
self.future.set_result(e.value)
return False
except Exception as e:
self.future.set_exception(e)
return False
return True
def start(coro, *, future=None, data=None):
"""
Start executing CORO, allowing it to suspend itself and continue
execution.
"""
d = _Driver()
d.coro = coro
# cached for efficiency
d.coro_send = coro.send
d.coro_throw = coro.throw
d.future = future
d.start_data = data
if future is None:
d.resumefn = d.resume_simple
else:
d.resumefn = d.resume_catching
d.coro_running = False
d.step(coro.send, None)
|
54123
|
import sys
from pathlib import Path
import os
import torch
from torch.optim import Adam
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from networks.critic import Critic
from networks.actor import NoisyActor, CategoricalActor, GaussianActor
base_dir = Path(__file__).resolve().parent.parent.parent
sys.path.append(str(base_dir))
from common.buffer import Replay_buffer as buffer
def get_trajectory_property(): #for adding terms to the memory buffer
return ["action"]
def weights_init_(m):
if isinstance(m, nn.Linear):
torch.nn.init.xavier_uniform_(m.weight, gain=1)
torch.nn.init.constant_(m.bias, 0)
def update_params(optim, loss, clip=False, param_list=False,retain_graph=False):
optim.zero_grad()
loss.backward(retain_graph=retain_graph)
if clip is not False:
for i in param_list:
torch.nn.utils.clip_grad_norm_(i, clip)
optim.step()
class SAC(object):
def __init__(self, args):
self.state_dim = args.obs_space
self.action_dim = args.action_space
self.gamma = args.gamma
self.tau = args.tau
self.action_continuous = args.action_continuous
self.batch_size = args.batch_size
self.hidden_size = args.hidden_size
self.actor_lr = args.a_lr
self.critic_lr = args.c_lr
self.alpha_lr = args.alpha_lr
self.buffer_size = args.buffer_capacity
self.policy_type = 'discrete' if (not self.action_continuous) else args.policy_type #deterministic or gaussian policy
self.device = 'cpu'
given_critic = Critic #need to set a default value
self.preset_alpha = args.alpha
if self.policy_type == 'deterministic':
self.tune_entropy = False
hid_layer = args.num_hid_layer
self.policy = NoisyActor(state_dim = self.state_dim, hidden_dim=self.hidden_size, out_dim=1,
num_hidden_layer=hid_layer).to(self.device)
self.policy_target = NoisyActor(state_dim = self.state_dim, hidden_dim=self.hidden_size, out_dim=1,
num_hidden_layer=hid_layer).to(self.device)
self.policy_target.load_state_dict(self.policy.state_dict())
self.q1 = given_critic(self.state_dim+self.action_dim, self.action_dim, self.hidden_size, hid_layer).to(self.device)
self.q1.apply(weights_init_)
self.q1_target = given_critic(self.state_dim+self.action_dim, self.action_dim, self.hidden_size, hid_layer).to(self.device)
self.q1_target.load_state_dict(self.q1.state_dict())
self.critic_optim = Adam(self.q1.parameters(), lr = self.critic_lr)
elif self.policy_type == 'discrete':
self.tune_entropy = args.tune_entropy
self.target_entropy_ratio = args.target_entropy_ratio
self.policy = CategoricalActor(self.state_dim, self.hidden_size, self.action_dim).to(self.device)
hid_layer = args.num_hid_layer
self.q1 = given_critic(self.state_dim, self.action_dim, self.hidden_size, hid_layer).to(self.device)
self.q1.apply(weights_init_)
self.q2 = given_critic(self.state_dim, self.action_dim, self.hidden_size, hid_layer).to(self.device)
self.q2.apply(weights_init_)
self.q1_target = given_critic(self.state_dim, self.action_dim, self.hidden_size, hid_layer).to(self.device)
self.q2_target = given_critic(self.state_dim, self.action_dim, self.hidden_size, hid_layer).to(self.device)
self.q1_target.load_state_dict(self.q1.state_dict())
self.q2_target.load_state_dict(self.q2.state_dict())
self.critic_optim = Adam(list(self.q1.parameters()) + list(self.q2.parameters()), lr=self.critic_lr)
elif self.policy_type == 'gaussian':
self.tune_entropy = args.tune_entropy
self.target_entropy_ratio = args.target_entropy_ratio
self.policy = GaussianActor(self.state_dim, self.hidden_size, 1, tanh = False).to(self.device)
#self.policy_target = GaussianActor(self.state_dim, self.hidden_size, 1, tanh = False).to(self.device)
hid_layer = args.num_hid_layer
self.q1 = given_critic(self.state_dim+self.action_dim, self.action_dim, self.hidden_size, hid_layer).to(self.device)
self.q1.apply(weights_init_)
self.critic_optim = Adam(self.q1.parameters(), lr = self.critic_lr)
self.q1_target = given_critic(self.state_dim+self.action_dim, self.action_dim, self.hidden_size, hid_layer).to(self.device)
self.q1_target.load_state_dict(self.q1.state_dict())
else:
raise NotImplementedError
self.eps = args.epsilon
self.eps_end = args.epsilon_end
self.eps_delay = 1 / (args.max_episodes * 100)
self.learn_step_counter = 0
self.target_replace_iter = args.target_replace
self.policy_optim = Adam(self.policy.parameters(), lr = self.actor_lr)
trajectory_property = get_trajectory_property()
self.memory = buffer(self.buffer_size, trajectory_property)
self.memory.init_item_buffers()
if self.tune_entropy:
self.target_entropy = -np.log(1./self.action_dim) * self.target_entropy_ratio
self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)
#self.alpha = self.log_alpha.exp()
self.alpha = torch.tensor([self.preset_alpha])
self.alpha_optim = Adam([self.log_alpha], lr=self.alpha_lr)
else:
self.alpha = torch.tensor([self.preset_alpha]) # coefficiency for entropy term
def choose_action(self, state, train = True):
state = torch.tensor(state, dtype=torch.float).view(1, -1)
if self.policy_type == 'discrete':
if train:
action, _, _, _ = self.policy.sample(state)
action = action.item()
self.add_experience({"action": action})
else:
_, _, _, action = self.policy.sample(state)
action = action.item()
return {'action': action}
elif self.policy_type == 'deterministic':
if train:
_,_,_,action = self.policy.sample(state)
action = action.item()
self.add_experience({"action": action})
else:
_,_,_,action = self.policy.sample(state)
action = action.item()
return {'action':action}
elif self.policy_type == 'gaussian':
if train:
action, _, _ = self.policy.sample(state)
action = action.detach().numpy().squeeze(1)
self.add_experience({"action": action})
else:
_, _, action = self.policy.sample(state)
action = action.item()
return {'action':action}
else:
raise NotImplementedError
def add_experience(self, output):
agent_id = 0
for k, v in output.items():
self.memory.insert(k, agent_id, v)
def critic_loss(self, current_state, batch_action, next_state, reward, mask):
with torch.no_grad():
next_state_action, next_state_pi, next_state_log_pi, _ = self.policy.sample(next_state)
#qf1_next_target, qf2_next_target = self.critic_target(next_state)
qf1_next_target = self.q1_target(next_state)
qf2_next_target = self.q2_target(next_state)
min_qf_next_target = next_state_pi * (torch.min(qf1_next_target, qf2_next_target) - self.alpha
* next_state_log_pi) # V function
min_qf_next_target = min_qf_next_target.sum(dim=1, keepdim=True)
next_q_value = reward + mask * self.gamma * (min_qf_next_target)
#qf1, qf2 = self.critic(current_state) # Two Q-functions to mitigate positive bias in the policy improvement step, [batch, action_num]
qf1 = self.q1(current_state)
qf2 = self.q2(current_state)
qf1 = qf1.gather(1, batch_action.long())
qf2 = qf2.gather(1, batch_action.long()) #[batch, 1] , pick the actin-value for the given batched actions
qf1_loss = torch.mean((qf1 - next_q_value).pow(2))
qf2_loss = torch.mean((qf2 - next_q_value).pow(2))
return qf1_loss, qf2_loss
def policy_loss(self, current_state):
with torch.no_grad():
#qf1_pi, qf2_pi = self.critic(current_state)
qf1_pi = self.q1(current_state)
qf2_pi = self.q2(current_state)
min_qf_pi = torch.min(qf1_pi, qf2_pi)
pi, prob, log_pi, _ = self.policy.sample(current_state)
inside_term = self.alpha.detach() * log_pi - min_qf_pi # [batch, action_dim]
policy_loss = ((prob * inside_term).sum(1)).mean()
return policy_loss, prob.detach(), log_pi.detach()
def alpha_loss(self, action_prob, action_logprob):
if self.tune_entropy:
entropies = -torch.sum(action_prob * action_logprob, dim=1, keepdim=True) #[batch, 1]
entropies = entropies.detach()
alpha_loss = -torch.mean(self.log_alpha * (self.target_entropy - entropies))
alpha_logs = self.log_alpha.exp().detach()
else:
alpha_loss = torch.tensor(0.).to(self.device)
alpha_logs = self.alpha.detach().clone()
return alpha_loss, alpha_logs
def learn(self):
data = self.memory.sample(self.batch_size)
transitions = {
"o_0": np.array(data['states']),
"o_next_0": np.array(data['states_next']),
"r_0": np.array(data['rewards']).reshape(-1, 1),
"u_0": np.array(data['action']),
"d_0": np.array(data['dones']).reshape(-1, 1),
}
obs = torch.tensor(transitions["o_0"], dtype=torch.float)
obs_ = torch.tensor(transitions["o_next_0"], dtype=torch.float)
action = torch.tensor(transitions["u_0"], dtype=torch.long).view(self.batch_size, -1)
reward = torch.tensor(transitions["r_0"], dtype=torch.float)
done = torch.tensor(transitions["d_0"], dtype=torch.float)
if self.policy_type == 'discrete':
qf1_loss, qf2_loss = self.critic_loss(obs, action, obs_, reward, (1-done))
policy_loss, prob, log_pi = self.policy_loss(obs)
alpha_loss, alpha_logs = self.alpha_loss(prob, log_pi)
qf_loss = qf1_loss + qf2_loss
update_params(self.critic_optim,qf_loss)
update_params(self.policy_optim, policy_loss)
if self.tune_entropy:
update_params(self.alpha_optim, alpha_loss)
self.alpha = self.log_alpha.exp().detach()
if self.learn_step_counter % self.target_replace_iter == 0:
#self.critic_target.load_state_dict(self.critic.state_dict())
self.q1_target.load_state_dict(self.q1.state_dict())
self.q2_target.load_state_dict(self.q2.state_dict())
self.learn_step_counter += 1
elif self.policy_type == 'deterministic':
current_q = self.q1(torch.cat([obs, action], 1))
target_next_action = self.policy_target(obs_)
target_next_q = self.q1_target(torch.cat([obs_, target_next_action], 1))
next_q_value = reward + (1-done) * self.gamma * target_next_q
qf_loss = F.mse_loss(current_q, next_q_value.detach())
self.critic_optim.zero_grad()
qf_loss.backward()
self.critic_optim.step()
_, _, _, current_action = self.policy.sample(obs)
qf_pi = self.q1(torch.cat([obs, current_action], 1))
policy_loss = -qf_pi.mean()
self.policy_optim.zero_grad()
policy_loss.backward()
self.policy_optim.step()
if self.learn_step_counter % self.target_replace_iter == 0:
for param, target_param in zip(self.q1.parameters(), self.q1_target.parameters()):
target_param.data.copy_(self.tau * param.data + (1.-self.tau) * target_param.data)
for param, target_param in zip(self.policy.parameters(), self.policy_target.parameters()):
target_param.data.copy_(self.tau * param.data + (1.-self.tau) * target_param.data)
elif self.policy_type == 'gaussian':
action = torch.tensor(transitions["u_0"], dtype=torch.float).view(self.batch_size, -1)
with torch.no_grad():
# next_action, next_action_logprob, _ = self.policy_target.sample(obs_)
next_action, next_action_logprob, _ = self.policy.sample(obs_)
target_next_q = self.q1_target(
torch.cat([obs_, next_action], 1)) - self.alpha * next_action_logprob
next_q_value = reward + (1 - done) * self.gamma * target_next_q
qf1 = self.q1(torch.cat([obs, action], 1))
qf_loss = F.mse_loss(qf1, next_q_value)
self.critic_optim.zero_grad()
qf_loss.backward()
self.critic_optim.step()
pi, log_pi, _ = self.policy.sample(obs)
qf_pi = self.q1(torch.cat([obs, pi], 1))
policy_loss = ((self.alpha * log_pi) - qf_pi).mean()
self.policy_optim.zero_grad()
policy_loss.backward()
self.policy_optim.step()
if self.tune_entropy:
alpha_loss = -(self.log_alpha * (log_pi + self.target_entropy).detach()).mean()
self.alpha_optim.zero_grad()
alpha_loss.backward()
self.alpha_optim.step()
self.alpha = self.log_alpha.exp()
else:
pass
if self.learn_step_counter % self.target_replace_iter == 0:
for param, target_param in zip(self.q1.parameters(), self.q1_target.parameters()):
target_param.data.copy_(self.tau * param.data + (1. - self.tau) * target_param.data)
# for param, target_param in zip(self.policy.parameters(), self.policy_target.parameters()):
# target_param.data.copy_(self.tau * param.data + (1.-self.tau) * target_param.data)
else:
raise NotImplementedError
def save(self, save_path, episode):
base_path = os.path.join(save_path, 'trained_model')
if not os.path.exists(base_path):
os.makedirs(base_path)
model_actor_path = os.path.join(base_path, "actor_" + str(episode) + ".pth")
torch.save(self.policy.state_dict(), model_actor_path)
def load(self, file):
self.policy.load_state_dict(torch.load(file))
|
54193
|
from numpy import ndarray, array
from electripy.physics.charges import PointCharge
class _ChargesSet:
"""
A _ChargesSet instance is a group of charges. The electric
field at a given point can be calculated as the sum of each
electric field at that point for every charge in the charge
set.
"""
def __init__(self, charges: list[PointCharge]) -> None:
self.charges = charges
def electric_field(self, point: ndarray) -> ndarray:
"""
Returns the electric field at the specified point.
"""
ef = array([0.0, 0.0])
for charge in self.charges:
ef += charge.electric_field(point)
return ef
def electric_force(self, charge: PointCharge) -> ndarray:
"""
Returns the force of the electric field exerted
on the charge.
"""
ef = self.electric_field(charge.position)
return ef * charge.charge
def __getitem__(self, index):
return self.charges[index]
class ChargeDistribution:
def __init__(self):
"""
There is one group for each charge in charges.
Each group is a two dimensional vector. The first element is
a charge, and the second element is the ChargeSet instance
containing all charges in charges except the charge itself.
"""
self.groups = []
self.charges_set = _ChargesSet([])
def add_charge(self, charge: PointCharge) -> None:
"""
Adds the charge to charges_set and updates the groups.
"""
self.charges_set.charges.append(charge)
self._update_groups(self.charges_set.charges)
def remove_charge(self, charge: PointCharge) -> None:
"""
Removes the charge to charges_set and updates the groups.
"""
self.charges_set.charges.remove(charge)
self._update_groups(self.charges_set.charges)
def _update_groups(self, charges: list[PointCharge]) -> None:
"""
Let X be a charge from the charge distribution. Computing X electric
force involves computing the electric force exerted on X by all
the other charges on the charge distribution.
This means that, in order to compute the electric force of X,
we need a two dimensional vector where the first component is
the charge X itself and the second component is a ChargeSet
instance cointaning all charges on the charge distribution except
X. This vector is called 'group'.
"""
self.groups = []
for charge in charges:
self.groups.append(
[
charge,
_ChargesSet([c for c in charges if c is not charge]),
]
)
def get_electric_forces(self) -> list[tuple[PointCharge, ndarray]]:
"""
Returns a list of electric forces. There is one electric force for
each charge in charges. Each electric force is a two dimensional
vector. The first element is the charge and the second element is
the electric force the other charges make on it.
"""
electric_forces = []
for group in self.groups:
electric_forces.append((group[0], group[1].electric_force(group[0])))
return electric_forces
def get_electric_field(self, position: ndarray) -> ndarray:
"""
Returns the electric force array at the given point.
"""
return self.charges_set.electric_field(position)
def __len__(self):
return len(self.charges_set.charges)
def __getitem__(self, index):
return self.charges_set[index]
|
54214
|
import os
import pathlib
import sys
import subprocess
sys.path.insert(1, str(pathlib.Path(__file__).parent.absolute())+"/../../../../parser")
#sys.path.insert(1, '/usr/workspace/wsa/laguna/fpchecker/FPChecker/parser')
from tokenizer import Tokenizer
source = "compute_inst.cu"
def setup_module(module):
THIS_DIR = os.path.dirname(os.path.abspath(__file__))
os.chdir(THIS_DIR)
def teardown_module(module):
cmd = ["make clean"]
cmdOutput = subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)
def test_1():
cmd = ["make"]
cmdOutput = subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)
# it should find one instrumented statement
numbwerOfTransformations = 0
fd = open(source, "r")
for l in fd:
if "_FPC_CHECK_D_(" in l:
numbwerOfTransformations = numbwerOfTransformations + 1
fd.close()
assert numbwerOfTransformations == 1
if __name__ == '__main__':
test_1()
|
54234
|
import multiprocessing as mp
import os
import subprocess
import time
import pytest
from solarforecastarbiter.io import fetch
def badfun():
raise ValueError
def bad_subprocess():
subprocess.run(['cat', '/nowaythisworks'], check=True, capture_output=True)
@pytest.mark.asyncio
@pytest.mark.parametrize('bad,err', [
(badfun, ValueError),
(bad_subprocess, subprocess.CalledProcessError)
])
async def test_cluster_error(bad, err):
pytest.importorskip("loky", reason="requires [fetch] packages")
with pytest.raises(err):
await fetch.run_in_executor(bad)
def getpid(): # pragma: no cover
return mp.current_process().pid
def longrunning(): # pragma: no cover
time.sleep(3)
@pytest.mark.asyncio
@pytest.mark.timeout(5, method='thread')
async def test_cluster_external_kill():
pytest.importorskip("loky", reason="requires [fetch] packages")
from loky.process_executor import TerminatedWorkerError
pid = await fetch.run_in_executor(getpid)
long = fetch.run_in_executor(longrunning)
os.kill(pid, 9)
with pytest.raises(TerminatedWorkerError):
await long
|
54290
|
import numpy as np
__copyright__ = 'Copyright (C) 2018 ICTP'
__author__ = '<NAME> <<EMAIL>>'
__credits__ = ["<NAME>", "<NAME>"]
def get_x(lon, clon, cone):
if clon >= 0.0 and lon >= 0.0 or clon < 0.0 and lon < 0.0:
return np.radians(clon - lon) * cone
elif clon >= 0.0:
if abs(clon - lon + 360.0) < abs(clon - lon):
return np.radians(clon - lon + 360) * cone
else:
return np.radians(clon - lon) * cone
elif abs(clon - lon - 360.0) < abs(clon - lon):
return np.radians(clon - lon - 360) * cone
else:
return np.radians(clon - lon) * cone
def grid_to_earth_uvrotate(proj, lon, lat, clon, clat, cone=None, plon=None,
plat=None):
if proj == 'NORMER':
return 1, 0
elif proj == 'ROTMER':
zphi = np.radians(lat)
zrla = np.radians(lon)
zrla = np.where(abs(lat) > 89.99999, 0.0, zrla)
if plat > 0.0:
pollam = plon + 180.0
polphi = 90.0 - plat
else:
pollam = plon
polphi = 90.0 + plat
if pollam > 180.0:
pollam = pollam - 360.0
polcphi = np.cos(np.radians(polphi))
polsphi = np.sin(np.radians(polphi))
zrlap = np.radians(pollam) - zrla
zarg1 = polcphi * np.sin(zrlap)
zarg2 = polsphi*np.cos(zphi) - polcphi*np.sin(zphi)*np.cos(zrlap)
znorm = 1.0/np.sqrt(zarg1**2+zarg2**2)
sindel = zarg1*znorm
cosdel = zarg2*znorm
return cosdel, sindel
else:
if np.isscalar(lon):
x = get_x(lon, clon, cone)
else:
c = np.vectorize(get_x, excluded=['clon', 'cone'])
x = c(lon, clon, cone)
xc = np.cos(x)
xs = np.sin(x)
if clat >= 0:
xs *= -1
return xc, xs
|
54293
|
import os
import shutil
def move_files(files, src_prefix, dst_prefix, app_name):
for file_name, attributes in files.items():
file_path = os.path.join(src_prefix, file_name)
dest_path = os.path.join(dst_prefix, file_name)
if attributes["static"]:
shutil.copy(file_path, dest_path)
else:
with open(file_path, "r") as file:
content = file.read()
with open(dest_path, "w") as file:
file.write(content.replace("{{ app_name }}", app_name))
def create_project(name):
project_path = os.path.join(os.getcwd(), name)
project_templates_path = os.path.join(project_path, "templates")
project_dupgee_path = os.path.join(project_path, "dupgee")
os.mkdir(project_path)
os.mkdir(project_templates_path)
os.mkdir(project_dupgee_path)
absolute_path = os.path.dirname(os.path.abspath(__file__))
base_path = os.path.join(absolute_path, "base")
dupgee_path = os.path.join(base_path, "dupgee")
base_files = {
"runner.py": {"static": False},
"urls.py": {"static": True},
"pages.py": {"static": True},
"__init__.py": {"static": True},
}
dupgee_files = {
"__init__.py": {"static": True},
"parsers.py": {"static": True},
"render.py": {"static": False},
"response.py": {"static": True},
"request.py": {"static": True},
"views.py": {"static": True},
"server.py": {"static": True},
"utils.py": {"static": True},
"wifi.py": {"static": True},
"matcher.py": {"static": False},
}
move_files(base_files, base_path, project_path, app_name=name)
move_files(dupgee_files, dupgee_path, project_dupgee_path, app_name=name)
with open(os.path.join(project_templates_path, "index.html"), "w") as f:
index_html = """<html lang="en">
<head>
<title>Dupgee Framework</title>
</head>
<body>
<h2>{{ name }}</h2>
</body>
</html>"""
f.write(index_html)
print(f"{name} project created at {project_path}")
|
54294
|
from setuptools import setup, find_packages
import os
setup_dir = os.path.dirname(__file__)
readme_path = os.path.join(setup_dir, 'README.rst')
version_path = os.path.join(setup_dir, 'keyfree/version.py')
requirements_path = os.path.join(setup_dir, "requirements.txt")
requirements_dev_path = os.path.join(setup_dir, "requirements-dev.txt")
__version__ = None
with open(version_path) as f:
code = compile(f.read(), version_path, 'exec')
exec(code)
with open(readme_path) as req_file:
readme = req_file.read()
with open(requirements_path) as req_file:
requirements = req_file.read().splitlines()
with open(requirements_dev_path) as req_file:
requirements_dev = req_file.read().splitlines()
setup(
name='keyfree',
version=__version__,
author='<NAME>',
author_email='<EMAIL>',
packages=find_packages(),
url='https://github.com/nickrw/keyfree',
description='An authentication proxy for Amazon Elasticsearch Service',
long_description=readme,
install_requires=requirements,
tests_require=requirements_dev,
package_data={'keyfree': ['requirements.txt', 'requirements-dev.txt']},
entry_points={
'console_scripts': ['keyfree-proxy-test=keyfree.proxy:main'],
},
license='MIT',
classifiers=[
'Development Status :: 4 - Beta',
'License :: OSI Approved :: MIT License',
'Intended Audience :: System Administrators',
'Intended Audience :: Developers',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 3',
'Environment :: No Input/Output (Daemon)',
'Topic :: Internet :: Proxy Servers',
'Topic :: Internet :: WWW/HTTP :: Indexing/Search',
'Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware',
],
)
|
54306
|
import numpy as np
import random
# Softmax function, optimized such that larger inputs are still feasible
# softmax(x + c) = softmax(x)
def softmax(x):
orig_shape = x.shape
x = x - np.max(x, axis = 1, keepdims = True)
exp_x = np.exp(x)
x = exp_x / np.sum(exp_x, axis = 1, keepdims = True)
assert x.shape == orig_shape
return x
# Implementation for the sigmoid function
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# Derivative of sigmoid function
def sigmoid_grad(sigmoid):
return sigmoid * (1 - sigmoid)
# Gradient checker for a function f
# f is a function that takes a single argument and outputs the cost and its gradients
# x is the point to check the gradient at
def gradient_checker(f, x):
rndstate = random.getstate()
random.setstate(rndstate)
cost, grad = f(x) # Evaluate function value at original point
epsilon = 1e-4 # Tiny shift to the input to compute approximated gradient with formula
# Iterate over all indexes in x
it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
while not it.finished:
i = it.multi_index
# Calculate J(theta_minus)
x_minus = np.copy(x)
x_minus[i] = x[i] - epsilon
random.setstate(rndstate)
f_minus = f(x_minus)[0]
# Calculate J(theta_plus)
x_plus = np.copy(x)
x_plus[i] = x[i] + epsilon
random.setstate(rndstate)
f_plus = f(x_plus)[0]
numgrad = (f_plus - f_minus) / (2 * epsilon)
# Compare gradients
reldiff = abs(numgrad - grad[i]) / max(1, abs(numgrad), abs(grad[i]))
if reldiff > 1e-5:
print "Gradient check failed."
print "First gradient error found at index %s" % str(i)
print "Your gradient: %f \t Numerical gradient: %f" % (
grad[i], numgrad)
return
it.iternext() # Step to next dimension
print "Gradient check passed!"
# Compute the forward and backward propagation for the NN model
def forward_backward_prop(data, labels, params, dimensions):
# Unpack the parameters
Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])
offset = 0
W1 = np.reshape(params[offset : offset + Dx * H], (Dx, H))
offset += Dx * H
b1 = np.reshape(params[offset : offset + 1 * H], (1, H))
offset += 1 * H
W2 = np.reshape(params[offset : offset + H * Dy], (H, Dy))
offset += H * Dy
b2 = np.reshape(params[offset : offset + 1 * Dy], (1, Dy))
# Forward propagation
a0 = data
z1 = np.dot(a0, W1) + b1
a1 = sigmoid(z1)
z2 = np.dot(a1, W2) + b2
a2 = softmax(z2)
cost = - np.sum(labels * np.log(a2))
# Backward propagation
delta1 = a2 - labels
dW2 = np.dot(a1.T, delta1)
db2 = np.sum(delta1, axis = 0, keepdims = True)
delta2 = np.multiply(np.dot(delta1, W2.T), sigmoid_grad(a1))
dW1 = np.dot(a0.T, delta2)
db1 = np.sum(delta2, axis = 0, keepdims = True)
### Stack gradients
grad = np.concatenate((dW1.flatten(), db1.flatten(),dW2.flatten(), db2.flatten()))
return cost, grad
# ************** IMPLEMENTATION TESTS **************
def test_softmax():
print "Running softmax tests..."
test1 = softmax(np.array([[1,2]]))
ans1 = np.array([0.26894142, 0.73105858])
assert np.allclose(test1, ans1, rtol=1e-05, atol=1e-06)
test2 = softmax(np.array([[1001,1002],[3,4]]))
ans2 = np.array([
[0.26894142, 0.73105858],
[0.26894142, 0.73105858]])
assert np.allclose(test2, ans2, rtol=1e-05, atol=1e-06)
test3 = softmax(np.array([[-1001,-1002]]))
ans3 = np.array([0.73105858, 0.26894142])
assert np.allclose(test3, ans3, rtol=1e-05, atol=1e-06)
print "Passed!\n"
def test_sigmoid():
print "Running sigmoid tests..."
x = np.array([[1, 2], [-1, -2]])
f = sigmoid(x)
g = sigmoid_grad(f)
f_ans = np.array([
[0.73105858, 0.88079708],
[0.26894142, 0.11920292]])
assert np.allclose(f, f_ans, rtol=1e-05, atol=1e-06)
g_ans = np.array([
[0.19661193, 0.10499359],
[0.19661193, 0.10499359]])
assert np.allclose(g, g_ans, rtol=1e-05, atol=1e-06)
print "Passed!\n"
def test_gradient_descent_checker():
# Test square function x^2, grad is 2 * x
quad = lambda x: (np.sum(x ** 2), x * 2)
print "Running gradient checker for quad function..."
gradient_checker(quad, np.array(123.456))
gradient_checker(quad, np.random.randn(3,))
gradient_checker(quad, np.random.randn(4,5))
print "Passed!\n"
# Test cube function x^3, grad is 3 * x^2
cube = lambda x: (np.sum(x ** 3), 3 * (x ** 2))
print "Running gradient checker for cube function..."
gradient_checker(cube, np.array(123.456))
gradient_checker(cube, np.random.randn(3,))
gradient_checker(cube, np.random.randn(4,5))
print "Passed!\n"
if __name__ == "__main__":
test_softmax()
test_sigmoid()
test_gradient_descent_checker()
|
54328
|
class CheckFileGenerationEnum:
GENERATED_SUCCESS = "generated_success"
GENERATED_EMPTY = "generated_empty"
NOT_GENERATED = "not_generated"
# try to find the internal value and return
def __getattr__(self, name):
if name in self:
return name
raise AttributeError
# prohibit any attempt to set any values
def __setattr__(self, key, value):
raise ValueError("No changes allowed.")
class JSONSchemasEnum:
WORKFLOW_SCHEMA = "workflow"
# sub-schemas
HEADER_SCHEMA = "header"
STEPS_SCHEMA = "steps"
STEP_SCHEMA = "step"
# try to find the internal value and return
def __getattr__(self, name):
if name in self:
return name
raise AttributeError
# prohibit any attempt to set any values
def __setattr__(self, key, value):
raise ValueError("No changes allowed.")
|
54385
|
import numpy as np
import pandas as pd
import unittest
from bdranalytics.sklearn.model_selection import GrowingWindow, IntervalGrowingWindow
def create_time_series_data_set(start_date=pd.datetime(year=2000, month=1, day=1), n_rows=100):
end_date = start_date + pd.Timedelta(days=n_rows-1)
ds = np.random.rand(n_rows)
X = pd.DataFrame(ds,
columns=['variable'],
index=pd.date_range(start_date, end_date))
y = np.random.randint(2, size=(n_rows,))
return X, y
class TestGrowingWindow(unittest.TestCase):
def test_n_splits(self):
assert GrowingWindow(4).get_n_splits(np.arange(15).reshape(3, 5)) == 4
def test_n_splits_returned(self):
assert len(list(GrowingWindow(4).split(
np.arange(15).reshape(3, 5), np.arange(3)))) == 4
def test_n_splits_testsize(self):
for train, test in GrowingWindow(4).split(np.arange(15).reshape(5, 3), np.arange(5)):
assert len(test) == 1
def test_n_splits_testsize2(self):
for i, (train, test) in zip(range(4), GrowingWindow(4).split(np.arange(15).reshape(5, 3), np.arange(5))):
assert len(train) == i+1
class TestIntervalGrowingWindow(unittest.TestCase):
def test_split_on_index(self):
X, y = create_time_series_data_set()
cv = IntervalGrowingWindow(
test_start_date=pd.datetime(year=2000, month=2, day=1),
test_end_date=pd.datetime(year=2000, month=3, day=1),
test_size='7D')
self.assertTrue(len(list(cv.split(X, y))) == 4)
def test_split_on_array(self):
X, y = create_time_series_data_set()
test_size_in_days = 7
cv = IntervalGrowingWindow(
timestamps=X.index.values,
test_start_date=pd.datetime(year=2000, month=2, day=1),
test_end_date=pd.datetime(year=2000, month=3, day=1),
test_size=pd.Timedelta(days=test_size_in_days))
self.assertTrue(len(list(cv.split(X, y))) == 4)
def test_split_test_size(self):
X, y = create_time_series_data_set()
test_size_in_days = 7
cv = IntervalGrowingWindow(
test_start_date=pd.datetime(year=2000, month=2, day=1),
test_end_date=pd.datetime(year=2000, month=3, day=1),
test_size=pd.Timedelta(days=test_size_in_days))
for _, test in cv.split(X, y):
self.assertTrue(len(test) == test_size_in_days)
def test_split_with_train_size(self):
X, y = create_time_series_data_set()
train_size_in_days = 14
cv = IntervalGrowingWindow(
test_start_date=pd.datetime(year=2000, month=2, day=1),
test_end_date=pd.datetime(year=2000, month=3, day=1),
test_size=pd.Timedelta(days=7),
train_size=pd.Timedelta(days=train_size_in_days))
for train, _ in cv.split(X, y):
self.assertTrue(len(train) == train_size_in_days)
def test_n_splits(self):
X, y = create_time_series_data_set()
cv = IntervalGrowingWindow(
test_start_date=pd.datetime(year=2000, month=2, day=1),
test_end_date=pd.datetime(year=2000, month=3, day=1),
test_size=pd.Timedelta(days=7))
self.assertTrue(cv.get_n_splits(X) == 4)
|
54386
|
import base64
class Pdf:
def __init__(self, fname=None, data=None, width='100%',
height='300px', border=False, log=None):
self.fname = fname
self.data = data
self.width = width
self.height = height
self.border = border
self.log = log
def save(self, fname):
with open(fname, 'wb') as f:
f.write(self.data)
def rasterize(self, to_file=None, scale=1):
return self.as_svg().rasterize(to_file=to_file, scale=scale)
def as_svg(self):
from .convert import pdf_to_svg
return pdf_to_svg(self)
def toDrawables(self, elements, **kwargs):
'''Integration with drawSvg.
Forwards its arguments to `latextools.convert.Svg.toDrawables`.
'''
svg = self.as_svg()
return svg.toDrawables(elements, **kwargs)
def _repr_html_(self):
if self.data is None and self.fname is None:
return '<span color="red">No PDF.</span>'
if self.data is None:
path = self.fname
else:
path = (b'data:application/pdf;base64,'
+ base64.b64encode(self.data)
).decode()
return (
f'''<iframe src="{path}"{' style="border:0"'*(not self.border)}
width="{self.width}" height="{self.height}">
No iframe support.
</iframe>''')
|
54451
|
from common import randstr, AES_CTR, xor_str
from random import randint
oracle_key = randstr(16)
oracle_nonce = randint(0, (1 << 64) - 1)
def encryption_oracle(data):
data = data.replace(';', '').replace('=', '')
data = "comment1=cooking%20MCs;userdata=" + data
data = data + ";comment2=%20like%20a%20pound%20of%20bacon"
return AES_CTR(data, oracle_key, oracle_nonce)
def decryption_oracle(data):
dec = AES_CTR(data, oracle_key, oracle_nonce)
return ';admin=true;' in dec
def main():
injection_string = ';admin=true;'
part1 = encryption_oracle('X' * len(injection_string))
part2 = encryption_oracle('Y' * len(injection_string))
part3 = xor_str('X' * len(injection_string), injection_string)
locationing = xor_str(part1, part2)
prefix_pos = locationing.index('\x01')
suffix_pos = prefix_pos + len(injection_string)
prefix = part1[:prefix_pos]
mid = part1[prefix_pos:suffix_pos]
suffix = part1[suffix_pos:]
attack = prefix + xor_str(mid, part3) + suffix
if decryption_oracle(attack):
print "[+] Admin access granted"
else:
print "[-] Attack failed"
if __name__ == '__main__':
main()
|
54454
|
def approve_new_user(sender, instance, created, *args, **kwarg):
if created:
instance.is_staff = True
instance.is_superuser = True
instance.save()
|
54458
|
import os
import math
import xls_cli.ansi as ansi
from xls_cli.grid import Grid
from getkey import getkey, keys
class Frame:
width, height = 0, 0
printable_window = "\x1B[2J"
title = "unititled"
grid = None
def __init__(self, title):
rows, columns = os.popen('stty size', 'r').read().split()
self.title = title
self.height = int(rows)
self.width = int(columns)
def render(self):
self.printable_window += self.draw_title_bar()
self.printable_window += self.draw_grid()
print(self.printable_window)
def loop(self):
while 1:
key = getkey()
if key == keys.UP:
self.grid.move_up()
self.refresh()
if key == keys.DOWN:
self.grid.move_down()
self.refresh()
if key == keys.RIGHT:
self.grid.move_right()
self.refresh()
if key == keys.LEFT:
self.grid.move_left()
self.refresh()
elif key == 'q':
quit()
def refresh(self):
self.printable_window = "\x1B[2J"
self.render()
def draw_title_bar(self):
title = "%s - %s" %("xls-cli", self.title)
return ansi.bg(title.center(self.width, " "), 28)
def draw_grid(self):
grid_to_string = "\n" + "-" * self.width + "\n"
for j in range(0, (len(self.grid.subgrid))):
row = []
for i in range(0, (len(self.grid.subgrid[0]) )):
text = "{:<20}".format(" " + str(self.grid.subgrid[j][i]))
if (j == self.grid.pos["y"] and i == self.grid.pos["x"]):
text = ansi.bg(text, 8)
row.append(text)
line_separator = "-" * self.width
grid_to_string += "%s\n%s\n" %("|".join(row), line_separator)
#grid_to_string += max(0, (self.grid.sheet.nrows - self.grid.max_rows)) * "\n"
return grid_to_string
|
54474
|
import os
from utils import load_json
from utils import print_err
from global_settings import SCENE_BUILDER_OUTPUT_DIR
class SceneBuilderConfig(object):
def __init__(
self,
input_scene_dir,
scene_builder_root,
output_dir_name,
rigid_mesh_db,
articulated_mesh_db,
articulated_mesh_default_tf_file,
enable_vrgym=False,
enable_physics=False,
enable_gazebo=False
):
self.input_scene_dir = input_scene_dir
self.scene_builder_root = scene_builder_root
self.output_dir_name = output_dir_name
self.output_dir = os.path.normpath("{}/{}/{}".format(scene_builder_root, SCENE_BUILDER_OUTPUT_DIR, output_dir_name))
self.rigid_mesh_db = rigid_mesh_db
self.articulated_mesh_db = articulated_mesh_db
self.articulated_mesh_default_tf = self.load_tf_(articulated_mesh_db, articulated_mesh_default_tf_file)
self.enable_vrgym = enable_vrgym
self.enable_physics = enable_physics
self.enable_gazebo = enable_gazebo
if self.output_dir_name is None:
self.output_dir_name = self.input_scene_dir.split('/')[-1]
def __str__(self):
ret = ""
ret += '#' * 50 + "\n"
ret += "# Scene Builder Configuration\n"
ret += '#' * 50 + "\n"
ret += "* Rigid mesh database: {}\n".format(self.rigid_mesh_db)
ret += "* Articulated mesh database: {}\n".format(self.articulated_mesh_db)
ret += '-' * 60 + '\n'
ret += "* Input scene dir: {}\n".format(self.input_scene_dir)
ret += "* scene_builder pkg root: {}\n".format(self.scene_builder_root)
ret += "* Output scene dir name: {}\n".format(self.output_dir_name)
ret += "* Output scene dir: {}\n".format(self.output_dir)
ret += '-' * 60 + '\n'
ret += "* Enable VRGym: {}\n".format(self.enable_vrgym)
ret += "* Enable physics: {}\n".format(self.enable_physics)
ret += "* Enable Gazebo: {}".format(self.enable_gazebo)
return ret
def load_tf_(self, mesh_db, tf_file):
interactive_cads = [
it for it in os.listdir(mesh_db)
if os.path.isdir(mesh_db + '/' + it)
]
tf = load_json(tf_file)
validate_data_format = lambda x, y: x in y and "scale" in y[x] and "tf" in y[x]
try:
assert( all([validate_data_format(it, tf) for it in interactive_cads]) )
except:
for it in interactive_cads:
if not validate_data_format(it, tf):
print_err("Interactive CAD `{}` was not shown in the transformation file `{}`".format(it, tf_file))
raise
return tf
|
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
|
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)
|
54544
|
import random
import cocotb
from cocotb.decorators import coroutine
from cocotb.result import TestFailure, ReturnValue
from cocotb.triggers import RisingEdge, Edge
from cocotblib.misc import log2Up, BoolRandomizer, assertEquals, waitClockedCond, randSignal
class Apb3:
def __init__(self, dut, name, clk = None):
self.clk = clk
self.PADDR = dut.__getattr__(name + "_PADDR")
self.PSEL = dut.__getattr__(name + "_PSEL")
self.PENABLE = dut.__getattr__(name + "_PENABLE")
self.PREADY = dut.__getattr__(name + "_PREADY")
self.PWRITE = dut.__getattr__(name + "_PWRITE")
self.PWDATA = dut.__getattr__(name + "_PWDATA")
self.PRDATA = dut.__getattr__(name + "_PRDATA")
def idle(self):
self.PSEL <= 0
@coroutine
def delay(self, cycle):
for i in range(cycle):
yield RisingEdge(self.clk)
@coroutine
def write(self, address, data, sel = 1):
self.PADDR <= address
self.PSEL <= sel
self.PENABLE <= False
self.PWRITE <= True
self.PWDATA <= data
yield RisingEdge(self.clk)
self.PENABLE <= True
yield waitClockedCond(self.clk, lambda : self.PREADY == True)
randSignal(self.PADDR)
self.PSEL <= 0
randSignal(self.PENABLE)
randSignal(self.PWRITE)
randSignal(self.PWDATA)
@coroutine
def writeMasked(self, address, data, mask, sel = 1):
readThread = self.read(address,sel)
yield readThread
yield self.write(address,(readThread.retval & ~mask) | (data & mask),sel)
@coroutine
def read(self, address, sel=1):
self.PADDR <= address
self.PSEL <= sel
self.PENABLE <= False
self.PWRITE <= False
randSignal(self.PWDATA)
yield RisingEdge(self.clk)
self.PENABLE <= True
yield waitClockedCond(self.clk, lambda: self.PREADY == True)
randSignal(self.PADDR)
self.PSEL <= 0
randSignal(self.PENABLE)
randSignal(self.PWRITE)
raise ReturnValue(int(self.PRDATA))
@coroutine
def readAssert(self, address, data, sel=1):
readThread = self.read(address,sel)
yield readThread
assertEquals(int(readThread.retval), data," APB readAssert failure")
@coroutine
def readAssertMasked(self, address, data, mask, sel=1):
readThread = self.read(address,sel)
yield readThread
assertEquals(int(readThread.retval) & mask, data," APB readAssert failure")
@coroutine
def pull(self, address, dataValue, dataMask, sel=1):
while True:
readThread = self.read(address, sel)
yield readThread
if (int(readThread.retval) & dataMask) == dataValue:
break
|
54547
|
import base64
from ...base import BaseParser, datetime_to_string, string_to_datetime
class Image(BaseParser):
def __init__(self, d=None, **kwargs):
BaseParser.__init__(self, d, **kwargs)
self.image_location = None
@property
def product_id(self):
return self._dict.get('product_id')
# No product_id setter since that value shouldn't be modified.
@property
def position(self):
return self._dict.get('position')
@position.setter
def position(self, val):
self._dict['position'] = int(val)
@property
def created_at(self):
return string_to_datetime(self._dict.get('created_at'))
@created_at.setter
def created_at(self, val):
self._dict['created_at'] = datetime_to_string(val)
@property
def updated_at(self):
return string_to_datetime(self._dict.get('updated_at'))
@updated_at.setter
def updated_at(self, val):
self._dict['updated_at'] = datetime_to_string(val)
@property
def src(self):
return self._dict.get('src')
@src.setter
def src(self, val):
self._dict['src'] = val
def attach(self, f):
"""
Attach an image file instead of using a url.
:param f: Path to image file.
:return:
"""
with open(f, 'rb') as f:
encoded = base64.b64encode(f.read())
self._dict['attachment'] = encoded
self.image_location = f
def __repr__(self):
return '<Image id={} src={} attachment={}>'.format(self.id, self.src, self.image_location)
|
54566
|
import datetime
import utils
import glob
import os
import numpy as np
import pandas as pd
if __name__ == '__main__':
loaddir = "E:/Data/h5/"
labels = ['https', 'netflix']
max_packet_length = 1514
for label in labels:
print("Starting label: " + label)
savedir = loaddir + label + "/"
now = datetime.datetime.now()
savename = "payload_%s-%.2d%.2d_%.2d%.2d" % (label, now.day, now.month, now.hour, now.minute)
filelist = glob.glob(loaddir + label + '*.h5')
# Try only one of each file
fullname = filelist[0]
# for fullname in filelist:
load_dir, filename = os.path.split(fullname)
print("Loading: {0}".format(filename))
df = utils.load_h5(load_dir, filename)
packets = df['bytes'].values
payloads = []
labels = []
filenames = []
for packet in packets:
if len(packet) == max_packet_length:
# Extract the payload from the packet should have length 1460
payload = packet[54:]
p = np.fromstring(payload, dtype=np.uint8)
payloads.append(p)
labels.append(label)
filenames.append(filename)
d = {'filename': filenames, 'bytes': payloads, 'label': labels}
dataframe = pd.DataFrame(data=d)
key = savename.split('-')[0]
dataframe.to_hdf(savedir + savename + '.h5', key=key, mode='w')
# utils.saveextractedheaders(loaddir, savedir, savename, num_headers=headersize)
print("Done with label: " + label)
|
54587
|
import utils
import vss
from crypto import G1, G2, add, neg, multiply, random_scalar, check_pairing
w3 = utils.connect()
contract = utils.deploy_contract('DKG')
def test_add():
a = multiply(G1, 5)
b = multiply(G1, 10)
s = add(a, b)
assert contract.bn128_add([a[0], a[1], b[0], b[1]]) == list(s)
def test_multiply():
assert G1 == (1, 2)
assert contract.bn128_multiply([1, 2, 5]) == list(multiply(G1, 5))
def test_check_pairing():
P1 = multiply(G1, 5)
Q1 = G2
Q2 = multiply(neg(G2), 5)
P2 = G1
assert check_pairing(P1, Q1, P2, Q2)
def test_verify_decryption_key():
sk1, sk2 = random_scalar(), random_scalar()
pk1, pk2 = multiply(G1, sk1), multiply(G1, sk2)
shared_key = vss.shared_key(sk1, pk2)
chal, resp = vss.shared_key_proof(sk1, pk2)
assert vss.dleq_verify(G1, pk1, pk2, shared_key, chal, resp)
assert contract.verify_decryption_key(
shared_key,
[chal, resp],
pk1,
pk2
)
def test_verify_sk_knowledge():
sk = random_scalar()
pk = multiply(G1, sk)
addr = w3.eth.accounts[0]
proof = vss.prove_sk_knowledge(sk, pk, addr)
assert vss.verify_sk_knowledge(pk, proof[0], proof[1], addr)
print("sk", sk)
print("pk", pk)
print("account", addr)
print("proof", proof)
assert contract.verify_sk_knowledge(pk, proof)
|
54600
|
from drf_yasg.utils import (
swagger_auto_schema as schema,
swagger_serializer_method as schema_serializer_method,
)
from .yasg import (
BananasSimpleRouter as BananasRouter,
BananasSwaggerSchema as BananasSchema,
)
__all__ = (
"schema",
"schema_serializer_method",
"BananasRouter",
"BananasSchema",
)
|
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
}
|
54617
|
import base64
import secrets
import cryptography.hazmat.primitives.ciphers
import cryptography.hazmat.primitives.ciphers.algorithms
import cryptography.hazmat.primitives.ciphers.modes
import cryptography.hazmat.backends
'''
This module provides AES GCM based payload protection.
Flow:
1. aes_gcm_generate_key() to get JWT AES 256 GCM key
2. Deliver the key to a Javascript app, also store AES key on the server
3. Import the key in the Javascript
window.crypto.subtle.importKey(
"jwk",
jwt_aes_key,
{ name: "AES-GCM" },
false,
["encrypt", "decrypt"]
)
.then(function(key){
... use_the_key_here ...
})
.catch(function(err){
console.error(err);
});
4. Encrypt the payload in Javascript
const iv = window.crypto.getRandomValues(new Uint8Array(12));
window.crypto.subtle.encrypt(
{
name: "AES-GCM",
iv: iv,
// Optionally provide additionalData: ,
tagLength: 128,
},
key, //from importKey above
plaintext
)
.then(function(ciphertext){
axios.post('/api/...',
concatUint8ArrayAndArrayBuffer(iv, ciphertext),
)
}
5. Submit the payload to the server, don't send AES key with it!
5. Decrypt the payload on the server side
plaintext = aes_gcm_decrypt(key = key_from_generate, ciphertext)
'''
def aes_gcm_decrypt(key: bytes, ciphertext: bytes, associated_data: bytes = None) -> bytes:
'''
Decrypt the ciphertext that is encrypted by AES GCM.
'''
iv = ciphertext[:12]
message = ciphertext[12:-16]
tag = ciphertext[-16:]
# Construct a Cipher object, with the key, iv, and additionally the
# GCM tag used for authenticating the message.
decryptor = cryptography.hazmat.primitives.ciphers.Cipher(
cryptography.hazmat.primitives.ciphers.algorithms.AES(key),
cryptography.hazmat.primitives.ciphers.modes.GCM(iv, tag),
backend=cryptography.hazmat.backends.default_backend()
).decryptor()
# We put associated_data back in or the tag will fail to verify
# when we finalize the decryptor.
if associated_data is not None:
decryptor.authenticate_additional_data(associated_data)
# Decryption gets us the authenticated plaintext.
# If the tag does not match an InvalidTag exception will be raised.
return decryptor.update(message) + decryptor.finalize()
def aes_gcm_generate_key(key: bytes = None) -> dict:
'''
Generate JWT AES 256 GCM key.
'''
if key is None:
key = secrets.token_bytes(256 // 8)
# JWT key
return {
"kty": "oct",
"k": base64.urlsafe_b64encode(key).decode('ascii').rstrip('='),
"alg": "A256GCM",
"ext": True,
}
|
54658
|
import pytest
from django.contrib.auth import get_user_model
from django.template import Context, Template
from proposals.models import AdditionalSpeaker, TalkProposal
def render_template(template_string, context_data=None):
context_data = context_data or {}
return Template(template_string).render(Context(context_data))
@pytest.fixture
def talk_proposals(talk_proposal, user, another_user):
proposal_0 = TalkProposal.objects.create(
submitter=another_user, title='Concrete construct saturation',
)
proposal_1 = talk_proposal
AdditionalSpeaker.objects.create(user=another_user, proposal=proposal_1)
user_3 = get_user_model().objects.create_user(
email='<EMAIL>', password='19',
speaker_name='<NAME>',
)
proposal_2 = TalkProposal.objects.create(
submitter=user_3, title='Render-farm smart-meta-rain-ware',
)
AdditionalSpeaker.objects.create(user=another_user, proposal=proposal_2)
AdditionalSpeaker.objects.create(user=user, proposal=proposal_2)
return [
proposal_0, # Proposal without additional speakers.
proposal_1, # Proposal with one additional speaker.
proposal_2, # Proposal with two additional speakers.
]
def test_speaker_names_display(talk_proposals, parser):
result = render_template(
'{% load proposals %}'
'<ul>'
'{% for proposal in proposals %}'
'<li>{{ proposal|speaker_names_display }}</li>'
'{% endfor %}'
'</ul>', {'proposals': talk_proposals},
)
actual = parser.arrange(parser.parse(text=result, create_parent=False))
expected = parser.arrange("""
<ul>
<li>Misaki Mei</li>
<li>User and Misaki Mei</li>
<li>Somebody Somewhere, Misaki Mei and User</li>
</ul>
""")
assert actual == expected
|
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
|
54714
|
def howmanyfingersdoihave():
ear.pauseListening()
sleep(1)
fullspeed()
i01.moveHead(49,74)
i01.moveArm("left",75,83,79,24)
i01.moveArm("right",65,82,71,24)
i01.moveHand("left",74,140,150,157,168,92)
i01.moveHand("right",89,80,98,120,114,0)
sleep(2)
i01.moveHand("right",0,80,98,120,114,0)
i01.mouth.speakBlocking("ten")
sleep(.1)
i01.moveHand("right",0,0,98,120,114,0)
i01.mouth.speakBlocking("nine")
sleep(.1)
i01.moveHand("right",0,0,0,120,114,0)
i01.mouth.speakBlocking("eight")
sleep(.1)
i01.moveHand("right",0,0,0,0,114,0)
i01.mouth.speakBlocking("seven")
sleep(.1)
i01.moveHand("right",0,0,0,0,0,0)
i01.mouth.speakBlocking("six")
sleep(.5)
i01.setHeadSpeed(.70,.70)
i01.moveHead(40,105)
i01.moveArm("left",75,83,79,24)
i01.moveArm("right",65,82,71,24)
i01.moveHand("left",0,0,0,0,0,180)
i01.moveHand("right",0,0,0,0,0,0)
sleep(0.1)
i01.mouth.speakBlocking("and five makes eleven")
sleep(0.7)
i01.setHeadSpeed(0.7,0.7)
i01.moveHead(40,50)
sleep(0.5)
i01.setHeadSpeed(0.7,0.7)
i01.moveHead(49,105)
sleep(0.7)
i01.setHeadSpeed(0.7,0.8)
i01.moveHead(40,50)
sleep(0.7)
i01.setHeadSpeed(0.7,0.8)
i01.moveHead(49,105)
sleep(0.7)
i01.setHeadSpeed(0.7,0.7)
i01.moveHead(90,85)
sleep(0.7)
i01.mouth.speakBlocking("eleven")
i01.moveArm("left",70,75,70,20)
i01.moveArm("right",60,75,65,20)
sleep(1)
i01.mouth.speakBlocking("that doesn't seem right")
sleep(2)
i01.mouth.speakBlocking("I think I better try that again")
i01.moveHead(40,105)
i01.moveArm("left",75,83,79,24)
i01.moveArm("right",65,82,71,24)
i01.moveHand("left",140,168,168,168,158,90)
i01.moveHand("right",87,138,109,168,158,25)
sleep(2)
i01.moveHand("left",10,140,168,168,158,90)
i01.mouth.speakBlocking("one")
sleep(.1)
i01.moveHand("left",10,10,168,168,158,90)
i01.mouth.speakBlocking("two")
sleep(.1)
i01.moveHand("left",10,10,10,168,158,90)
i01.mouth.speakBlocking("three")
sleep(.1)
i01.moveHand("left",10,10,10,10,158,90)
i01.mouth.speakBlocking("four")
sleep(.1)
i01.moveHand("left",10,10,10,10,10,90)
i01.mouth.speakBlocking("five")
sleep(.1)
i01.setHeadSpeed(0.65,0.65)
i01.moveHead(53,65)
i01.moveArm("right",48,80,78,11)
i01.setHandSpeed("left", 1.0, 1.0, 1.0, 1.0, 1.0, 1.0)
i01.setHandSpeed("right", 1.0, 1.0, 1.0, 1.0, 1.0, 1.0)
i01.moveHand("left",10,10,10,10,10,90)
i01.moveHand("right",10,10,10,10,10,25)
sleep(1)
i01.mouth.speakBlocking("and five makes ten")
sleep(.5)
i01.mouth.speakBlocking("there that's better")
i01.moveHead(95,85)
i01.moveArm("left",75,83,79,24)
i01.moveArm("right",40,70,70,10)
sleep(0.5)
i01.mouth.speakBlocking("inmoov has ten fingers")
sleep(0.5)
i01.moveHead(90,90)
i01.setHandSpeed("left", 0.8, 0.8, 0.8, 0.8, 0.8, 0.8)
i01.setHandSpeed("right", 0.8, 0.8, 0.8, 0.8, 0.8, 0.8)
i01.moveHand("left",140,140,140,140,140,60)
i01.moveHand("right",140,140,140,140,140,60)
sleep(1.0)
i01.setArmSpeed("right", 1.0, 1.0, 1.0, 1.0)
i01.setArmSpeed("left", 1.0, 1.0, 1.0, 1.0)
i01.moveArm("left",5,90,30,11)
i01.moveArm("right",5,90,30,11)
sleep(0.5)
relax()
sleep(0.5)
ear.resumeListening()
|
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) )
|
54747
|
from functools import partial
from os import path
from .obj import load_obj, save_obj
from .off import load_off, save_off
def load_mesh(filename):
loaders = {
'obj': load_obj,
'off': partial(load_off, no_colors=True),
}
ext = path.splitext(filename)[1].lower()[1:]
if ext not in loaders:
raise IOError("No loader for %s extension known, available file formats are: %s" % (ext, list(loaders.keys())))
return loaders[ext](filename)
def save_mesh(filename, verts, tris, *args, **kw):
writers = {
'obj': save_obj,
'off': save_off,
}
ext = path.splitext(filename)[1].lower()[1:]
if ext not in writers:
raise IOError("No known writer for %s extension known, available file formats are: %s" % (ext, list(loaders.keys())))
return writers[ext](filename, verts, tris, *args, **kw)
|
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": {}},
}
|
54805
|
import functools
import itertools
import operator
import numpy as np
from qecsim.model import StabilizerCode, cli_description
from qecsim.models.rotatedplanar import RotatedPlanarPauli
@cli_description('Rotated planar (rows INT >= 3, cols INT >= 3)')
class RotatedPlanarCode(StabilizerCode):
r"""
Implements a rotated planar mixed boundary code defined by its lattice size.
In addition to the members defined in :class:`qecsim.model.StabilizerCode`, it provides several lattice methods as
described below.
Lattice methods:
* Get size: :meth:`size`.
* Get plaquette type: :meth:`is_x_plaquette`, :meth:`is_z_plaquette`, :meth:`is_virtual_plaquette`.
* Get and test bounds: :meth:`site_bounds`, :meth:`is_in_site_bounds`, :meth:`is_in_plaquette_bounds`.
* Resolve a syndrome to plaquettes: :meth:`syndrome_to_plaquette_indices`.
* Construct a Pauli operator on the lattice: :meth:`new_pauli`.
Indices:
* Indices are in the format (x, y).
* Qubit sites (vertices) are indexed by (x, y) coordinates with the origin at the lower left qubit.
* Stabilizer plaquettes are indexed by (x, y) coordinates such that the lower left corner of the plaquette is on the
qubit site at (x, y).
* X-type stabilizer plaquette indices satisfy (x-y) % 2 == 1.
* Z-type stabilizer plaquette indices satisfy (x-y) % 2 == 0.
For example, qubit site indices on a 3 x 3 lattice:
::
(0,2)-----(1,2)-----(2,2)
| | |
| | |
| | |
(0,1)-----(1,1)-----(2,1)
| | |
| | |
| | |
(0,0)-----(1,0)-----(2,0)
For example, stabilizer plaquette types and indices on a 3 x 3 lattice:
::
-------
/ Z \
| (0,2) |
+---------+---------+-----
| X | Z | X \
| (0,1) | (1,1) |(2,1) |
| | | /
-----+---------+---------+-----
/ X | Z | X |
|(-1,0)| (0,0) | (1,0) |
\ | | |
-----+---------+---------+
| Z |
\ (1,-1)/
-------
"""
MIN_SIZE = (3, 3)
def __init__(self, rows, columns):
"""
Initialise new rotated planar code.
:param rows: Number of rows in lattice.
:type rows: int
:param columns: Number of columns in lattice.
:type columns: int
:raises ValueError: if (rows, columns) smaller than (3, 3) in either dimension.
:raises TypeError: if any parameter is of an invalid type.
"""
min_rows, min_cols = self.MIN_SIZE
try: # paranoid checking for CLI. (operator.index ensures the parameter can be treated as an int)
if operator.index(rows) < min_rows or operator.index(columns) < min_cols:
raise ValueError('{} minimum size is {}.'.format(type(self).__name__, self.MIN_SIZE))
except TypeError as ex:
raise TypeError('{} invalid parameter type'.format(type(self).__name__)) from ex
self._size = rows, columns
# < StabilizerCode interface methods >
@property
@functools.lru_cache()
def n_k_d(self):
"""See :meth:`qecsim.model.StabilizerCode.n_k_d`"""
# n = r*c, k = 1, d = min(r, c)
rows, cols = self.size
return rows * cols, 1, min(rows, cols)
@property
def label(self):
"""See :meth:`qecsim.model.StabilizerCode.label`"""
return 'Rotated planar {}x{}'.format(*self.size)
@property
@functools.lru_cache()
def stabilizers(self):
"""See :meth:`qecsim.model.StabilizerCode.stabilizers`"""
return np.array([self.new_pauli().plaquette(i).to_bsf() for i in self._plaquette_indices])
@property
@functools.lru_cache()
def logical_xs(self):
"""See :meth:`qecsim.model.StabilizerCode.logical_xs`"""
return np.array([self.new_pauli().logical_x().to_bsf()])
@property
@functools.lru_cache()
def logical_zs(self):
"""See :meth:`qecsim.model.StabilizerCode.logical_zs`"""
return np.array([self.new_pauli().logical_z().to_bsf()])
# </ StabilizerCode interface methods >
@property
def size(self):
"""
Size of the lattice in format (rows, columns), e.g. (5, 5).
:rtype: 2-tuple of int
"""
return self._size
@classmethod
def is_x_plaquette(cls, index):
"""
Return True if the plaquette index specifies an X-type plaquette, irrespective of lattice bounds.
:param index: Index in the format (x, y).
:type index: 2-tuple of int
:return: If the index specifies an X-type plaquette.
:rtype: bool
"""
x, y = index
return (x - y) % 2 == 1
@classmethod
def is_z_plaquette(cls, index):
"""
Return True if the plaquette index specifies an Z-type plaquette, irrespective of lattice bounds.
:param index: Index in the format (x, y).
:type index: 2-tuple of int
:return: If the index specifies an Z-type plaquette.
:rtype: bool
"""
return not cls.is_x_plaquette(index)
@property
def site_bounds(self):
"""
Maximum x and y value that an index coordinate can take.
:rtype: 2-tuple of int
"""
# max_row, max_col
rows, cols = self.size
return cols - 1, rows - 1 # max_x, max_y
def is_in_site_bounds(self, index):
"""
Return True if the site index is within lattice bounds inclusive.
:param index: Index in the format (x, y).
:type index: 2-tuple of int
:return: If the index is within lattice bounds inclusive.
:rtype: bool
"""
x, y = index
max_site_x, max_site_y = self.site_bounds
return 0 <= x <= max_site_x and 0 <= y <= max_site_y
@functools.lru_cache(maxsize=2 ** 14) # O(n) per code, so for 101x101 code
def is_in_plaquette_bounds(self, index):
"""
Return True if the plaquette index is within lattice bounds inclusive.
:param index: Index in the format (x, y).
:type index: 2-tuple of int
:return: If the index is within lattice bounds inclusive.
:rtype: bool
"""
x, y = index
max_site_x, max_site_y = self.site_bounds
# derive min and max x bounds allowing for boundary plaquettes
min_x = -1 if y % 2 == 0 else 0
if max_site_x % 2 == 0: # even max_site_x (i.e. odd number of columns)
max_x = max_site_x - 1 if y % 2 == 0 else max_site_x
else:
max_x = max_site_x if y % 2 == 0 else max_site_x - 1
# derive min and max y bounds allowing for boundary plaquettes
min_y = 0 if x % 2 == 0 else -1
if max_site_y % 2 == 0: # even max_site_y (i.e. odd number of rows)
max_y = max_site_y if x % 2 == 0 else max_site_y - 1
else: # odd max_site_y (i.e. even number of rows)
max_y = max_site_y - 1 if x % 2 == 0 else max_site_y
# evaluate in bounds
return min_x <= x <= max_x and min_y <= y <= max_y
def is_virtual_plaquette(self, index):
"""
Return True if the plaquette index specifies a virtual plaquette
(i.e. index is on the boundary but not within lattice bounds).
:param index: Index in the format (x, y).
:type index: 2-tuple of int
:return: If the index specifies a virtual plaquette.
:rtype: bool
"""
x, y = index
max_site_x, max_site_y = self.site_bounds
# index is on boundary but not within lattice bounds.
return (x == -1 or x == max_site_x or y == -1 or y == max_site_y) and not self.is_in_plaquette_bounds(index)
@property
@functools.lru_cache()
def _plaquette_indices(self):
"""
Return a list of the plaquette indices of the lattice.
Notes:
* Each index is in the format (x, y).
* Indices are in order of increasing type, y, x. (Z-type first)
:return: List of indices in the format (x, y).
:rtype: list of 2-tuple of int
"""
max_site_x, max_site_y = self.site_bounds
z_plaquette_indices, x_plaquette_indices = [], []
for y in range(-1, max_site_y + 2):
for x in range(-1, max_site_x + 2):
index = x, y
if self.is_in_plaquette_bounds(index):
if self.is_z_plaquette(index):
z_plaquette_indices.append(index)
else:
x_plaquette_indices.append(index)
return list(itertools.chain(z_plaquette_indices, x_plaquette_indices))
def syndrome_to_plaquette_indices(self, syndrome):
"""
Returns the indices of the plaquettes associated with the non-commuting stabilizers identified by the syndrome.
:param syndrome: Binary vector identifying commuting and non-commuting stabilizers by 0 and 1 respectively.
:type syndrome: numpy.array (1d)
:return: Set of plaquette indices.
:rtype: set of 2-tuple of int
"""
return set(tuple(index) for index in np.array(self._plaquette_indices)[syndrome.nonzero()])
def __eq__(self, other):
if type(other) is type(self):
return self._size == other._size
return NotImplemented
def __hash__(self):
return hash(self._size)
def __repr__(self):
return '{}({!r}, {!r})'.format(type(self).__name__, *self.size)
def ascii_art(self, syndrome=None, pauli=None, plaquette_labels=None, site_labels=None):
"""
Return ASCII art style lattice showing primal lattice lines with syndrome bits and Pauli operators as given.
Notes:
* Optional plaquette_labels override syndrome.
* Optional site_labels override pauli.
:param syndrome: Syndrome (optional) as binary vector.
:type syndrome: numpy.array (1d)
:param pauli: Rotated planar Pauli (optional)
:type pauli: RotatedPlanarPauli
:param plaquette_labels: Dictionary of plaquette indices as (x, y) to single-character labels (optional).
:type plaquette_labels: dict of (int, int) to char
:param site_labels: Dictionary of site indices as (x, y) to single-character labels (optional).
:type site_labels: dict of (int, int) to char
:return: ASCII art style lattice.
:rtype: str
"""
# See https://unicode-table.com/en/blocks/box-drawing/ for box-drawing unicode characters
max_site_x, max_site_y = self.site_bounds
syndrome_indices = set() if syndrome is None else self.syndrome_to_plaquette_indices(syndrome)
pauli = self.new_pauli() if pauli is None else pauli
plaquette_labels = {} if plaquette_labels is None else plaquette_labels
site_labels = {} if site_labels is None else site_labels
# Build row templates
# e.g. (where @=plaquette, o=site, .=virtual_plaquette):
#
# . /-@-\ . /-@-\ . . :plaquette_row_top_even
# o---o---o---o---o-\ :site_row_top_even
# . |#@#| @ |#@#| @ |#@ :plaquette_row_odd
# /-o---o---o---o---o-/ :site_row_odd
# @#| @ |#@#| @ |#@#| . :plaquette_row_even
# \-o---o---o---o---o-\ :t_site_row_even
# . |#@#| @ |#@#| @ |#@ :plaquette_row_odd
# /-o---o---o---o---o-/ :site_row_odd
# @#| @ |#@#| @ |#@#| . :plaquette_row_even
# \-o---o---o---o---o :site_row_bottom
# . . \-@-/ . \-@-/ . :plaquette_row_bottom
#
# e.g (if top row odd):
#
# . . /-@-\ . /-@-\ . :plaquette_row_top_odd
# /-o---o---o---o---o :site_row_top_odd
#
# Common chars
c_dot = chr(0x00B7)
c_dash = chr(0x2500)
c_bar = chr(0x2502)
c_angle_nw = chr(0x250C)
c_angle_ne = chr(0x2510)
c_angle_sw = chr(0x2514)
c_angle_se = chr(0x2518)
c_shade = chr(0x2591)
# Common char sequences
cs_pn = c_angle_nw + c_dash + '{}' + c_dash + c_angle_ne # '/-{}-\'
cs_pnw = c_angle_nw + c_dash # '/-'
cs_pw = '{}' + c_shade # ' #'
cs_psw = c_angle_sw + c_dash # '\-'
cs_pne = c_dash + c_angle_ne # '-\'
cs_pe = c_shade + '{}' # '# '
cs_pse = c_dash + c_angle_se # '-/'
cs_ps = c_angle_sw + c_dash + '{}' + c_dash + c_angle_se # '\-{}-/'
cs_pbulkx = c_bar + c_shade + '{}' + c_shade # '|#{}#'
cs_pbulkz = c_bar + ' {} ' # '| {} '
cs_sbulk = '{}' + c_dash * 3 # '{}---'
# booleans to control placement of boundary plaquettes
odd_rows = max_site_y % 2 == 0
odd_cols = max_site_x % 2 == 0
if odd_rows:
# . /-@-\ . /-@-\ . .
t_plaquette_row_top = ('{} ' + cs_pn + ' ') * ((max_site_x + 1) // 2) + ('{} {}' if odd_cols else '{}')
# o---o---o---o---o-\
t_site_row_top = ' ' + cs_sbulk * max_site_x + '{}' + (cs_pne if odd_cols else ' ')
else:
# . . /-@-\ . /-@-\ .
t_plaquette_row_top = '{} {}' + (' ' + cs_pn + ' {}') * (max_site_x // 2) + ('' if odd_cols else ' {}')
# /-o---o---o---o---o
t_site_row_top = cs_pnw + cs_sbulk * max_site_x + '{}' + (cs_pne if not odd_cols else ' ')
# |#@#| @ |#@#| @ |#@
t_plaquette_row_odd = ('{} ' + ''.join(([cs_pbulkx, cs_pbulkz] * max_site_x)[:max_site_x])
+ c_bar + (cs_pe if odd_cols else ' {}'))
# /-o---o---o---o---o-/
t_site_row_odd = cs_pnw + cs_sbulk * max_site_x + '{}' + (cs_pse if odd_cols else cs_pne)
# @#| @ |#@#| @ |#@#| .
t_plaquette_row_even = (cs_pw + ''.join(([cs_pbulkz, cs_pbulkx] * max_site_x)[:max_site_x])
+ c_bar + (cs_pe if not odd_cols else ' {}'))
# \-o---o---o---o---o-\
t_site_row_even = cs_psw + cs_sbulk * max_site_x + '{}' + (cs_pne if odd_cols else cs_pse)
# \-o---o---o---o---o
t_site_row_bottom = cs_psw + cs_sbulk * max_site_x + '{}' + (cs_pse if not odd_cols else ' ')
# . . \-@-/ . \-@-/ .
t_plaquette_row_bottom = '{} {}' + (' ' + cs_ps + ' {}') * (max_site_x // 2) + ('' if odd_cols else ' {}')
# Parameter extraction functions
def _site_parameters(y):
indices = [i for i in ((x, y) for x in range(max_site_x + 1))]
parameters = []
for i in indices:
if i in site_labels:
parameters.append(site_labels[i])
else:
op = pauli.operator(i)
parameters.append(c_dot if op == 'I' else op)
return parameters
def _plaquette_parameters(y):
indices = [i for i in ((x, y) for x in range(-1, max_site_x + 1))]
parameters = []
for i in indices:
is_z_plaquette = self.is_z_plaquette(i)
is_virtual_plaquette = self.is_virtual_plaquette(i)
if is_virtual_plaquette:
parameters.append(plaquette_labels.get(i, ' '))
elif i in plaquette_labels:
parameters.append(plaquette_labels[i])
elif i in syndrome_indices:
parameters.append('Z' if is_z_plaquette else 'X')
elif i[0] == -1 or i[0] == max_site_x:
parameters.append(c_bar)
elif i[1] == -1 or i[1] == max_site_y:
parameters.append(c_dash)
else:
parameters.append(' ' if is_z_plaquette else c_shade)
return parameters
# Append templates to text with parameters
text = []
# top rows
text.append(t_plaquette_row_top.format(*_plaquette_parameters(max_site_y)))
text.append(t_site_row_top.format(*_site_parameters(max_site_y)))
# middle rows
for y in range(max_site_y - 1, 0, -1):
if y % 2 == 0:
text.append(t_plaquette_row_even.format(*_plaquette_parameters(y)))
text.append(t_site_row_even.format(*_site_parameters(y)))
else:
text.append(t_plaquette_row_odd.format(*_plaquette_parameters(y)))
text.append(t_site_row_odd.format(*_site_parameters(y)))
# bottom rows
text.append(t_plaquette_row_even.format(*_plaquette_parameters(0)))
text.append(t_site_row_bottom.format(*_site_parameters(0)))
text.append(t_plaquette_row_bottom.format(*_plaquette_parameters(-1)))
return '\n'.join(text)
def new_pauli(self, bsf=None):
"""
Convenience constructor of planar Pauli for this code.
Notes:
* For performance reasons, the new Pauli is a view of the given bsf. Modifying one will modify the other.
:param bsf: Binary symplectic representation of Pauli. (Optional. Defaults to identity.)
:type bsf: numpy.array (1d)
:return: Rotated planar Pauli
:rtype: RotatedPlanarPauli
"""
return RotatedPlanarPauli(self, bsf)
|
54817
|
import nose.tools as nt
import numpy as np
import theano
import theano.tensor as T
import treeano
import treeano.nodes as tn
from treeano.sandbox.nodes import lrn
fX = theano.config.floatX
def ground_truth_normalizer(bc01, k, n, alpha, beta):
"""
This code is adapted from pylearn2.
https://github.com/lisa-lab/pylearn2/blob/master/LICENSE.txt
"""
def ground_truth_normalize_row(row, k, n, alpha, beta):
assert row.ndim == 1
out = np.zeros(row.shape)
for i in range(row.shape[0]):
s = k
tot = 0
for j in range(max(0, i - n // 2),
min(row.shape[0], i + n // 2 + 1)):
tot += 1
sq = row[j] ** 2.
assert sq > 0.
assert s >= k
assert alpha > 0.
s += alpha * sq
assert s >= k
assert tot <= n
assert s >= k
s = s ** beta
out[i] = row[i] / s
return out
c01b = bc01.transpose(1, 2, 3, 0)
out = np.zeros(c01b.shape)
for r in range(out.shape[1]):
for c in range(out.shape[2]):
for x in range(out.shape[3]):
out[:, r, c, x] = ground_truth_normalize_row(
row=c01b[:, r, c, x],
k=k, n=n, alpha=alpha, beta=beta)
out_bc01 = out.transpose(3, 0, 1, 2)
return out_bc01
def _test_localresponse_normalization_fn(fn, shape=(3, 4, 5, 6), **kwargs):
vw = treeano.VariableWrapper("foo", variable=T.tensor4(), shape=shape)
new_kwargs = dict(
# use a big value of alpha so mistakes involving alpha show up strong
alpha=1.5,
k=2,
beta=0.75,
n=5,
)
new_kwargs.update(kwargs)
fn = theano.function([vw.variable], [fn(vw, **new_kwargs)])
x = np.random.randn(*shape).astype(fX)
res, = fn(x)
ans = ground_truth_normalizer(x, **new_kwargs)
np.testing.assert_allclose(ans, res, rtol=1e-5)
def test_local_response_normalization_2d_v1():
_test_localresponse_normalization_fn(
lrn.local_response_normalization_2d_v1)
def test_local_response_normalization_2d_v2():
_test_localresponse_normalization_fn(
lrn.local_response_normalization_2d_v2)
def test_local_response_normalization_2d_pool():
_test_localresponse_normalization_fn(
lrn.local_response_normalization_2d_pool)
def test_local_response_normalization_2d_pool():
_test_localresponse_normalization_fn(
lrn.local_response_normalization_pool)
def test_local_response_normalization_2d_node_shape():
shape = (3, 4, 5, 6)
network = tn.SequentialNode(
"s",
[tn.InputNode("i", shape=shape),
lrn.LocalResponseNormalization2DNode("lrn")]
).network()
fn = network.function(["i"], ["s"])
x = np.random.randn(*shape).astype(fX)
res = fn(x)[0].shape
np.testing.assert_equal(shape, res)
def test_local_response_normalization_node_shape():
for ndim in [2, 3, 4, 5, 6]:
shape = (3,) * ndim
network = tn.SequentialNode(
"s",
[tn.InputNode("i", shape=shape),
lrn.LocalResponseNormalizationNode("lrn")]
).network()
fn = network.function(["i"], ["s"])
x = np.random.randn(*shape).astype(fX)
res = fn(x)[0].shape
np.testing.assert_equal(shape, res)
|
54832
|
from PySide2.QtGui import QValidator
class RegValidator(QValidator):
def __init__(self, max_value):
super().__init__()
self.max_value = max_value
def validate(self, text, pos):
if text == '':
return QValidator.Acceptable
try:
value = int(text, 8)
if value <= self.max_value:
return QValidator.Acceptable
else:
return QValidator.Invalid
except:
return QValidator.Invalid
|
54846
|
import typing
import torch
import torch.nn as nn
import torch.nn.functional as F
from .net_sphere import *
class ResCBAMLayer(nn.Module):
"""
CBAM+Res model
"""
def __init__(self, in_planes, feature_size):
super(ResCBAMLayer, self).__init__()
self.in_planes = in_planes
self.feature_size = feature_size
self.ch_AvgPool = nn.AvgPool3d(feature_size, feature_size)
self.ch_MaxPool = nn.MaxPool3d(feature_size, feature_size)
self.ch_Linear1 = nn.Linear(in_planes, in_planes // 4, bias=False)
self.ch_Linear2 = nn.Linear(in_planes // 4, in_planes, bias=False)
self.ch_Softmax = nn.Softmax(1)
self.sp_Conv = nn.Conv3d(2, 1, kernel_size=3, stride=1, padding=1, bias=False)
self.sp_Softmax = nn.Softmax(1)
def forward(self, x):
x_ch_avg_pool = self.ch_AvgPool(x).view(x.size(0), -1)
x_ch_max_pool = self.ch_MaxPool(x).view(x.size(0), -1)
# x_ch_avg_linear = self.ch_Linear2(self.ch_Linear1(x_ch_avg_pool))
a = self.ch_Linear1(x_ch_avg_pool)
x_ch_avg_linear = self.ch_Linear2(a)
x_ch_max_linear = self.ch_Linear2(self.ch_Linear1(x_ch_max_pool))
ch_out = (self.ch_Softmax(x_ch_avg_linear + x_ch_max_linear).view(x.size(0), self.in_planes, 1, 1, 1)) * x
x_sp_max_pool = torch.max(ch_out, 1, keepdim=True)[0]
x_sp_avg_pool = torch.sum(ch_out, 1, keepdim=True) / self.in_planes
sp_conv1 = torch.cat([x_sp_max_pool, x_sp_avg_pool], dim=1)
sp_out = self.sp_Conv(sp_conv1)
sp_out = self.sp_Softmax(sp_out.view(x.size(0), -1)).view(x.size(0), 1, x.size(2), x.size(3), x.size(4))
out = sp_out * x + x
return out
def make_conv3d(in_channels: int, out_channels: int, kernel_size: typing.Union[int, tuple], stride: int,
padding: int, dilation=1, groups=1,
bias=True) -> nn.Module:
"""
produce a Conv3D with Batch Normalization and ReLU
:param in_channels: num of in in channels
:param out_channels: num of out channels
:param kernel_size: size of kernel int or tuple
:param stride: num of stride
:param padding: num of padding
:param bias: bias
:param groups: groups
:param dilation: dilation
:return: conv3d module
"""
module = nn.Sequential(
nn.Conv3d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation,
groups=groups,
bias=bias),
nn.BatchNorm3d(out_channels),
nn.ReLU())
return module
def conv3d_same_size(in_channels, out_channels, kernel_size, stride=1,
dilation=1, groups=1,
bias=True):
"""
keep the w,h of inputs same as the outputs
:param in_channels: num of in in channels
:param out_channels: num of out channels
:param kernel_size: size of kernel int or tuple
:param stride: num of stride
:param dilation: Spacing between kernel elements
:param groups: Number of blocked connections from input channels to output channels.
:param bias: If True, adds a learnable bias to the output
:return: conv3d
"""
padding = kernel_size // 2
return make_conv3d(in_channels, out_channels, kernel_size, stride,
padding, dilation, groups,
bias)
def conv3d_pooling(in_channels, kernel_size, stride=1,
dilation=1, groups=1,
bias=False):
"""
pooling with convolution
:param in_channels:
:param kernel_size:
:param stride:
:param dilation:
:param groups:
:param bias:
:return: pooling-convolution
"""
padding = kernel_size // 2
return make_conv3d(in_channels, in_channels, kernel_size, stride,
padding, dilation, groups,
bias)
class ResidualBlock(nn.Module):
"""
a simple residual block
"""
def __init__(self, in_channels, out_channels):
super(ResidualBlock, self).__init__()
self.my_conv1 = make_conv3d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
self.my_conv2 = make_conv3d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
self.conv3 = make_conv3d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)
def forward(self, inputs):
out1 = self.conv3(inputs)
out = self.my_conv1(inputs)
out = self.my_conv2(out)
out = out + out1
return out
|
54861
|
import re
import sys
from notebook.notebookapp import main
from qulab.utils import ShutdownBlocker
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
with ShutdownBlocker('jupyter-notebook'):
sys.exit(main())
|
54885
|
from copy import deepcopy
import pytest
from catenets.datasets import load
from catenets.experiment_utils.tester import evaluate_treatments_model
from catenets.models.jax import FLEXTE_NAME, OFFSET_NAME, FlexTENet, OffsetNet
LAYERS_OUT = 2
LAYERS_R = 3
PENALTY_L2 = 0.01 / 100
PENALTY_ORTHOGONAL_IHDP = 0
MODEL_PARAMS = {
"n_layers_out": LAYERS_OUT,
"n_layers_r": LAYERS_R,
"penalty_l2": PENALTY_L2,
"penalty_orthogonal": PENALTY_ORTHOGONAL_IHDP,
"n_layers_out_t": LAYERS_OUT,
"n_layers_r_t": LAYERS_R,
"penalty_l2_t": PENALTY_L2,
}
PARAMS_DEPTH: dict = {"n_layers_r": 2, "n_layers_out": 2}
PARAMS_DEPTH_2: dict = {
"n_layers_r": 2,
"n_layers_out": 2,
"n_layers_r_t": 2,
"n_layers_out_t": 2,
}
PENALTY_DIFF = 0.01
PENALTY_ORTHOGONAL = 0.1
ALL_MODELS = {
OFFSET_NAME: OffsetNet(penalty_l2_p=PENALTY_DIFF, **PARAMS_DEPTH),
FLEXTE_NAME: FlexTENet(
penalty_orthogonal=PENALTY_ORTHOGONAL, penalty_l2_p=PENALTY_DIFF, **PARAMS_DEPTH
),
}
models = list(ALL_MODELS.keys())
@pytest.mark.slow
@pytest.mark.parametrize("dataset, pehe_threshold", [("twins", 0.4), ("ihdp", 3)])
@pytest.mark.parametrize("model_name", models)
def test_model_sanity(dataset: str, pehe_threshold: float, model_name: str) -> None:
model = deepcopy(ALL_MODELS[model_name])
X_train, W_train, Y_train, Y_train_full, X_test, Y_test = load(dataset)
score = evaluate_treatments_model(model, X_train, Y_train, Y_train_full, W_train)
print(f"Evaluation for model jax.{model_name} on {dataset} = {score['str']}")
assert score["raw"]["pehe"][0] < pehe_threshold
def test_model_score() -> None:
model = OffsetNet()
X_train, W_train, Y_train, Y_train_full, X_test, Y_test = load("ihdp")
model.fit(X_train[:10], Y_train[:10], W_train[:10])
result = model.score(X_test, Y_test)
assert result > 0
with pytest.raises(ValueError):
model.score(X_train, Y_train) # Y_train has just one outcome
|
54886
|
import os
from functools import partial
# pymel
import pymel.core as pm
# mgear
import mgear
from mgear.maya import shifter, skin, pyqt, utils
GUIDE_UI_WINDOW_NAME = "guide_UI_window"
GUIDE_DOCK_NAME = "Guide_Components"
##############################
# CLASS
##############################
class Guide_UI(object):
def __init__(self):
# Remove existing window
if pm.window(GUIDE_UI_WINDOW_NAME, exists=True):
print "deleting win"
pm.deleteUI(GUIDE_UI_WINDOW_NAME)
if pm.dockControl(GUIDE_DOCK_NAME, exists=True):
print "deleting dock"
pm.deleteUI(GUIDE_DOCK_NAME)
panelWeight = 200
scrollHight = 600
# Create Window and main tab
self.ui_window = pm.window(
GUIDE_UI_WINDOW_NAME, width=panelWeight, title="Guide Tools",
sizeable=True)
self.ui_topLevelColumn = pm.columnLayout(
adjustableColumn=True, columnAlign="center")
#
pm.columnLayout()
pm.rowLayout(numberOfColumns=1, columnWidth=[(1, panelWeight)])
pm.button(label="Settings", w=panelWeight, h=30,
bgc=[.042, .351, .615],
command=partial(self.inspectSettings))
pm.setParent('..')
pm.rowLayout(numberOfColumns=3, columnWidth=[
(1, (panelWeight / 3) - 1),
(2, (panelWeight / 3) - 1),
(3, (panelWeight / 3) - 1)])
pm.button(label="Dupl.", w=(panelWeight / 3) - 1, h=23,
bgc=[.311, .635, 0], command=partial(self.duplicate, False))
pm.button(label="Dupl. Sym", w=(panelWeight / 3) - 1, h=23,
bgc=[.465, .785, .159],
command=partial(self.duplicate, True))
pm.button(label="Extr. Ctl", w=(panelWeight / 3) - 1, h=23,
bgc=[.835, .792, .042],
command=partial(self.extractControls))
pm.setParent('..')
pm.rowLayout(numberOfColumns=1, columnWidth=[(1, panelWeight)])
pm.button(label="Build from selection", w=panelWeight, h=30,
bgc=[.912, .427, .176],
command=partial(self.buildFromSelection))
pm.setParent('..')
self.ui_tabs = pm.tabLayout(
width=panelWeight, innerMarginWidth=5, innerMarginHeight=5)
pm.tabLayout(self.ui_tabs, q=True, width=True)
#
self.ui_compColumn = pm.columnLayout(adj=True, rs=3)
self.ui_compFrameLayout = pm.frameLayout(
height=scrollHight, collapsable=False, borderVisible=False,
labelVisible=False)
self.ui_compList_Scroll = pm.scrollLayout(hst=0)
self.ui_compList_column = pm.columnLayout(
columnWidth=panelWeight, adj=True, rs=2)
pm.separator()
# List of components
# doGrouping = 1 < len(shifter.COMPONENTS_DIRECTORIES.keys())
compDir = shifter.getComponentDirectories()
trackLoadComponent = []
for path, comps in compDir.iteritems():
pm.text(align="center", label=os.path.basename(path))
pm.separator()
for comp_name in comps:
if comp_name in trackLoadComponent:
pm.displayWarning(
"Custom component name: %s, already in default "
"components. Names should be unique. This component is"
" not loaded" % comp_name)
continue
else:
trackLoadComponent.append(comp_name)
if not os.path.exists(os.path.join(path,
comp_name, "__init__.py")):
continue
module = shifter.importComponentGuide(comp_name)
reload(module)
image = os.path.join(path, comp_name, "icon.jpg")
buttonSize = 25
textDesc = "Name: " + module.NAME + "\nType:: " + \
module.TYPE + "\n===========\nAuthor: " + \
module.AUTHOR + "\nWeb: " + module.URL + \
"\nEmail: " + module.EMAIL + \
"\n===========\nDescription:\n" + module.DESCRIPTION
pm.rowLayout(numberOfColumns=2,
columnWidth=([1, buttonSize]),
adjustableColumn=2,
columnAttach=([1, "both", 0], [2, "both", 5]))
pm.symbolButton(ann=textDesc,
width=buttonSize,
height=buttonSize,
bgc=[0, 0, 0],
ebg=False, i=image,
command=partial(self.drawComp, module.TYPE))
pm.columnLayout(columnAlign="center")
pm.text(align="center", width=panelWeight * .6,
label=module.TYPE, ann=textDesc, fn="plainLabelFont")
pm.setParent(self.ui_compList_column)
pm.separator()
# Display the window
pm.tabLayout(self.ui_tabs, edit=True,
tabLabelIndex=([1, "Components"]))
allowedAreas = ['right', 'left']
pm.dockControl(GUIDE_DOCK_NAME, area='right', content=self.ui_window,
allowedArea=allowedAreas, width=panelWeight, s=True)
def drawComp(self, compType, *args):
guide = shifter.guide.Rig()
if pm.selected():
parent = pm.selected()[0]
else:
parent = None
guide.drawNewComponent(parent, compType)
# @utils.one_undo
@classmethod
def buildFromSelection(self, *args):
logWin = pm.window(title="Shifter Build Log", iconName='Shifter Log')
pm.columnLayout(adjustableColumn=True)
pm.cmdScrollFieldReporter(width=800, height=500, clr=True)
pm.button(label='Close', command=(
'import pymel.core as pm\npm.deleteUI(\"' + logWin +
'\", window=True)'))
pm.setParent('..')
pm.showWindow(logWin)
mgear.logInfos()
rg = shifter.Rig()
rg.buildFromSelection()
@classmethod
def duplicate(self, sym, *args):
oSel = pm.selected()
if oSel:
root = oSel[0]
guide = shifter.guide.Rig()
guide.duplicate(root, sym)
else:
mgear.log("Select one component root to edit properties",
mgear.sev_error)
return
@classmethod
def inspectSettings(self, *args):
oSel = pm.selected()
if oSel:
root = oSel[0]
else:
pm.displayWarning(
"please select one object from the componenet guide")
return
comp_type = False
guide_root = False
while root:
if pm.attributeQuery("comp_type", node=root, ex=True):
comp_type = root.attr("comp_type").get()
break
elif pm.attributeQuery("ismodel", node=root, ex=True):
guide_root = root
break
root = root.getParent()
pm.select(root)
if comp_type:
guide = shifter.importComponentGuide(comp_type)
pyqt.showDialog(guide.componentSettings)
elif guide_root:
module_name = "mgear.maya.shifter.guide"
guide = __import__(module_name, globals(), locals(), ["*"], -1)
pyqt.showDialog(guide.guideSettings)
else:
pm.displayError(
"The selected object is not part of component guide")
@classmethod
def inspectProperties(self, *args):
modeSet = ["FK", "IK", "IK/FK"]
rotOrderSet = ["XYZ", "YZX", "ZXY", "XZY", "YXZ", "ZYX"]
guideModeSet = ["Final", "WIP"]
# apply changes
def applyCloseGuide(root, *args):
if pm.attributeQuery("mode", node=root, ex=True):
root.attr("mode").set(guideModeSet.index(pMode.getValue()))
pm.select(root, r=True)
pm.deleteUI(window, window=True)
def skinLoad(root, *args):
startDir = root.attr("skin").get()
filePath = pm.fileDialog2(
dialogStyle=2,
fileMode=1,
startingDirectory=startDir,
fileFilter='mGear skin (*%s)' % skin.FILE_EXT)
if not filePath:
return
if not isinstance(filePath, basestring):
filePath = filePath[0]
root.attr("skin").set(filePath)
def applyCloseComp(root, *args):
newName = pName.getText()
newSide = pSide.getValue()
newIndex = pIndex.getValue1()
if pm.attributeQuery("mode", node=root, ex=True):
root.attr("mode").set(modeSet.index(pMode.getValue()))
if pm.attributeQuery("default_rotorder", node=root, ex=True):
root.attr("default_rotorder").set(
rotOrderSet.index(pRotOrder.getValue()))
guide = shifter.guide.Rig()
guide.updateProperties(root, newName, newSide, newIndex)
pm.select(root, r=True)
pm.deleteUI(window, window=True)
if pm.window("compProperties", exists=True):
pm.deleteUI("compProperties")
oSel = pm.selected()
if oSel:
root = oSel[0]
else:
mgear.log(
"Select one root Guide or component to edit properties",
mgear.sev_error)
return
if pm.attributeQuery("comp_type", node=root, ex=True):
# property window constructor
customAttr = pm.listAttr(root, ud=True)
window = pm.window(title=root.name())
pm.columnLayout(adjustableColumn=True, cal="right")
for attr in customAttr:
if attr == "comp_name":
fl = pm.formLayout()
oriVal = root.attr("comp_name").get()
pName = pm.textFieldGrp(label="comp_name")
pm.setParent('..')
pm.formLayout(fl, e=True, af=(pName, "left", 0))
pName.setText(oriVal)
elif attr == "comp_side":
sideSet = ["C", "L", "R"]
fl = pm.formLayout()
pSide = pm.optionMenu(label="comp_side")
pSide.addMenuItems(sideSet)
pSide.setWidth(120)
pm.setParent('..')
pm.formLayout(fl, e=1, af=(pSide, "left", 90))
oriVal = root.attr("comp_side").get()
pSide.setValue(oriVal)
elif attr == "mode":
fl = pm.formLayout()
pMode = pm.optionMenu(label="mode")
pMode.addMenuItems(modeSet)
pMode.setWidth(120)
pm.setParent('..')
pm.formLayout(fl, e=1, af=(pMode, "left", 115))
oriVal = root.attr("mode").get()
pMode.setValue(modeSet[oriVal])
elif attr == "default_rotorder":
fl = pm.formLayout()
pRotOrder = pm.optionMenu(label="default_rotorder")
pRotOrder.addMenuItems(rotOrderSet)
pRotOrder.setWidth(140)
pm.setParent('..')
pm.formLayout(fl, e=1, af=(pRotOrder, "left", 60))
oriVal = root.attr("default_rotorder").get()
pRotOrder.setValue(rotOrderSet[oriVal])
elif attr == "comp_index":
fl = pm.formLayout()
oriVal = root.attr("comp_index").get()
pIndex = pm.intFieldGrp(v1=oriVal, label="comp_index")
pm.setParent('..')
pm.formLayout(fl, e=True, af=(pIndex, "left", 0))
else:
editable = True
if attr == "comp_type":
editable = False
pm.columnLayout(cal="right")
pm.attrControlGrp(attribute=root.attr(
attr), po=True, en=editable)
pm.setParent('..')
pm.button(label='Apply', command=partial(
applyCloseComp, root), h=100)
pm.setParent('..')
pm.showWindow(window)
elif pm.attributeQuery("ismodel", node=root, ex=True):
# property window constructor
customAttr = pm.listAttr(root, ud=True)
window = pm.window(title=root.name())
pm.columnLayout(adjustableColumn=True, cal="right")
for attr in customAttr:
if attr.split("_")[-1] not in ["r", "g", "b"]:
if attr == "mode":
fl = pm.formLayout()
pMode = pm.optionMenu(label="mode")
pMode.addMenuItems(guideModeSet)
pMode.setWidth(120)
pm.setParent('..')
pm.formLayout(fl, e=1, af=(pMode, "left", 115))
oriVal = root.attr("mode").get()
pMode.setValue(guideModeSet[oriVal])
elif attr == "skin":
pm.columnLayout(cal="right")
pm.attrControlGrp(attribute=root.attr(attr), po=True)
pm.setParent('..')
pm.button(label='Load Skin ',
command=partial(skinLoad, root))
else:
pm.columnLayout(cal="right")
pm.attrControlGrp(attribute=root.attr(attr), po=True)
pm.setParent('..')
pm.button(label='Apply', command=partial(
applyCloseGuide, root), h=50)
pm.setParent('..')
pm.showWindow(window)
else:
mgear.log(
"Select a root Guide or component to edit properties",
mgear.sev_error)
return
def extractControls(self, *args):
oSel = pm.selected()
try:
cGrp = pm.PyNode("controllers_org")
except TypeError:
cGrp = False
mgear.log(
"Not controller group in the scene or the group is not unique",
mgear.sev_error)
for x in oSel:
try:
old = pm.PyNode(cGrp.name() + "|" +
x.name().split("|")[-1] + "_controlBuffer")
pm.delete(old)
except TypeError:
pass
new = pm.duplicate(x)[0]
pm.parent(new, cGrp, a=True)
pm.rename(new, x.name() + "_controlBuffer")
toDel = new.getChildren(type="transform")
pm.delete(toDel)
try:
pm.sets("rig_controllers_grp", remove=new)
except TypeError:
pass
|
54897
|
from bgheatmaps.heatmaps import heatmap
from bgheatmaps.planner import plan
from bgheatmaps.slicer import get_structures_slice_coords
|
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)
|
54979
|
import random
from task_widgets.task_base.intro_hint import IntroHint
from utils import import_kv
from .calculation import ModeOperandsCalculation
import_kv(__file__)
class IntroHintNumbersCalculation(IntroHint):
pass
class NumbersCalculation(ModeOperandsCalculation):
FROM = 101
TO = 899
TASK_KEY = "numbers_calculation"
INTRO_HINT_CLASS = IntroHintNumbersCalculation
def calculate_operands(self):
self.first = self.first or random.randint(self.FROM, self.TO - 100)
self.result = self.result or random.randint(self.first + 100, self.TO)
self.second = self.second or self.result - self.first
def build_text(self):
text = None
if self.mode == 0:
self.correct_answer = self.result
text = "%s + %s = ?" % (self.first, self.second)
if self.mode == 1:
self.correct_answer = self.first
text = "? + %s = %s" % (self.second, self.result)
if self.mode == 2:
self.correct_answer = self.second
text = "%s + ? = %s" % (self.first, self.result)
return text
def get_next_variant(self):
return self.correct_answer + 10 * random.randint(-10, +10)
|
54997
|
from pprint import pprint
import asyncio
import netdev
import yaml
r1 = {
"device_type": "cisco_ios",
"host": "192.168.100.1",
"username": "cisco",
"password": "<PASSWORD>",
"secret": "cisco",
}
async def send_show(device, commands):
result = {}
if type(commands) == str:
commands = [commands]
try:
async with netdev.create(**device) as ssh:
for cmd in commands:
output = await ssh.send_command(cmd)
result[cmd] = output
return result
except netdev.exceptions.TimeoutError as error:
print(error)
except netdev.exceptions.DisconnectError as error:
print(error)
if __name__ == "__main__":
output = asyncio.run(send_show(r1, ["sh ip int br", "sh clock"]))
pprint(output, width=120)
|
55025
|
import unittest
from kivy3.loaders import OBJLoader
class OBJLoaderTest(unittest.TestCase):
pass
if __name__ == '__main__':
unittest.main()
|
55048
|
from random import choice
TRID_CSET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
def gen_trid(length=12):
return ''.join(choice(TRID_CSET) for _i in range(length))
|
55077
|
from pathlib import Path
from boucanpy.core import logger
from boucanpy.cli.base import BaseCommand
from boucanpy.db.models import models
class DbTruncate(BaseCommand):
name = "db-truncate"
aliases = ["truncate"]
description = "truncate db"
add_log_level = True
add_debug = True
@classmethod
def parser(cls, parser):
parser.add_argument("-c", "--confirm", action="store_true", help="seed data")
return parser
async def run(self):
self.db_register()
failed = []
if self.option("confirm"):
for class_name, model in models.items():
for item in self.session().query(model).all():
logger.warning(f"run@db_truncate.py - Deleting {item}")
try:
self.session().delete(item)
self.session().commit()
except Exception as e:
failed.append((item, e))
else:
logger.warning("run@db_truncate.py - You must confirm to drop data")
if len(failed) > 0:
logger.warning("run@db_truncate.py - Encountered errors")
for f in failed:
print("Failed:", item[0])
print("Error", item[1])
|
55080
|
import os
path = ''
if not path:
eixt(1)
for root, dirs, files in os.walk(path):
for f in files:
if f == 'readme.md':
src = os.path.join(root, f)
# print(src)
dst = os.path.join(root, 'README.md')
os.rename(src, dst)
|
55110
|
from vedacore.misc import build_from_cfg, registry
def build_loss(cfg):
return build_from_cfg(cfg, registry, 'loss')
|
55148
|
from main.save_and_get import Abrufen
import config
example1 = Abrufen(config.bucket_name, config.subdir4rss, 'example1')
example2 = Abrufen(config.bucket_name, config.subdir4rss, 'example2')
|
55161
|
import os
from AppKit import NSApp, NSImage
import vanilla
from mojo.UI import CurrentGlyphWindow, UpdateCurrentGlyphView,\
StatusInteractivePopUpWindow
from fontParts.world import CurrentGlyph
resourcesDirectory = os.path.dirname(__file__)
resourcesDirectory = os.path.dirname(resourcesDirectory)
resourcesDirectory = os.path.dirname(resourcesDirectory)
resourcesDirectory = os.path.join(resourcesDirectory, "resources")
imageCache = {}
def getImage(name):
if name not in imageCache:
imagePath = os.path.join(resourcesDirectory, name + ".pdf")
image = NSImage.alloc().initWithContentsOfFile_(imagePath)
image.setTemplate_(True)
imageCache[name] = image
return imageCache[name]
def getActiveGlyphWindow():
window = CurrentGlyphWindow()
# there is no glyph window
if window is None:
return None
# the editor is not the first responder
if not window.getGlyphView().isFirstResponder():
return None
return window
# ---------------
# Base Controller
# ---------------
class BaseActionWindowController(object):
def __init__(self):
glyphWindow = getActiveGlyphWindow()
if glyphWindow is None:
return
self.w = ActionWindow(
(1, 1),
centerInView=CurrentGlyphWindow().getGlyphView()
)
self.w.responderWillBecomeFirstCallback = self.responderWillBecomeFirstCallback
# There is probably a better way to set
# the escape key to close the window but
# I am lazy so I'm using a hidden button.
self.w._closeButton = vanilla.ImageButton(
(0, 0, 0, 0),
bordered=False,
callback=self._closeButtonCallback
)
self.w._closeButton.bind("\u001B", [])
# Build the interface
self.metrics = dict(
margin=15,
iconPadding=5,
iconButtonWidth=30,
iconButtonHeight=30,
groupPadding=15,
)
rules = self.buildInterface(self.w)
if rules is not None:
self.w.addAutoPosSizeRules(rules, self.metrics)
# Bind close.
self.w.bind("close", self.windowCloseCallback)
# Go
self.w.open()
def _closeButtonCallback(self, sender):
self.w.responderWillBecomeFirstCallback = None
self.w.close()
def buildInterface(self):
pass
def windowCloseCallback(self, sender):
pass
def responderWillBecomeFirstCallback(self, responder):
pass
# ------
# Window
# ------
class TSActionNSWindow(StatusInteractivePopUpWindow.nsWindowClass):
def makeFirstResponder_(self, responder):
value = super(TSActionNSWindow, self).makeFirstResponder_(responder)
if value:
delegate = self.delegate()
if delegate is not None and delegate.responderWillBecomeFirstCallback is not None:
delegate.responderWillBecomeFirstCallback(responder)
return responder
class ActionWindow(StatusInteractivePopUpWindow):
nsWindowClass = TSActionNSWindow
# -------------
# Action Button
# -------------
class IconButton(vanilla.ImageButton):
def __init__(self, imageName, actionName="Quick Action", actionCallback=None, closesWindow=True):
super(IconButton, self).__init__(
"auto",
callback=self.performAction,
imageObject=getImage(imageName),
bordered=False
)
self.actionName = actionName
self.actionCallback = actionCallback
self.closesWindow = closesWindow
button = self.getNSButton()
button.setToolTip_(actionName)
def performAction(self, sender):
if self.actionCallback is not None:
glyph = CurrentGlyph()
glyph.prepareUndo(self.actionName)
self.actionCallback(glyph)
glyph.performUndo()
glyph.changed()
UpdateCurrentGlyphView()
if self.closesWindow:
window = self.getNSButton().window().delegate()
window.close()
|
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)
|
55326
|
from django.contrib import admin
from thing.models import APIKey, BlueprintInstance, Campaign, Character, CharacterConfig, Corporation, \
Alliance, APIKeyFailure, Asset, AssetSummary, BlueprintComponent, Blueprint, CorpWallet, \
TaskState, CharacterDetails, Contract, UserProfile, Transaction, JournalEntry, Colony, Pin, BlueprintProduct, \
IndustryJob, SkillPlan
class APIKeyAdmin(admin.ModelAdmin):
list_display = ('id', 'user', 'name', 'key_type', 'corporation', 'valid')
raw_id_fields = ('characters', 'corp_character', 'corporation')
search_fields = ['characters__name', 'corporation__name']
class BlueprintInstanceAdmin(admin.ModelAdmin):
list_display = ('blueprint', 'original', 'material_level', 'productivity_level')
class CharacterAdmin(admin.ModelAdmin):
fieldsets = [
('Character information', {
'fields': ['name', 'corporation']
}),
]
list_display = ('id', 'name', 'corporation')
raw_id_fields = ('corporation',)
search_fields = ['name']
class CharacterDetailsAdmin(admin.ModelAdmin):
raw_id_fields = ('character',)
class CharacterConfigAdmin(admin.ModelAdmin):
raw_id_fields = ('character',)
class CampaignAdmin(admin.ModelAdmin):
prepopulated_fields = {'slug': ('title',)}
class AllianceAdmin(admin.ModelAdmin):
list_display = ('id', 'name', 'short_name')
class APIKeyFailureAdmin(admin.ModelAdmin):
list_display = ('user', 'keyid', 'fail_time')
class AssetAdmin(admin.ModelAdmin):
list_display = ('character', 'system', 'station', 'item', 'quantity')
raw_id_fields = ('character',)
class AssetSummaryAdmin(admin.ModelAdmin):
list_display = ('character', 'system', 'station', 'total_items', 'total_value')
raw_id_fields = ('character',)
class BlueprintComponentAdmin(admin.ModelAdmin):
list_display = ('blueprint', 'activity', 'item', 'count', 'consumed')
list_filter = ('activity',)
class BlueprintProductAdmin(admin.ModelAdmin):
list_display = ('blueprint', 'activity', 'item', 'count')
list_filter = ('activity',)
class BlueprintAdmin(admin.ModelAdmin):
list_display = ('name',)
class CorpWalletAdmin(admin.ModelAdmin):
list_display = ('corporation', 'description', 'balance')
raw_id_fields = ('corporation',)
class TaskStateAdmin(admin.ModelAdmin):
list_display = ('keyid', 'url', 'state', 'mod_time', 'next_time', 'parameter')
class ContractAdmin(admin.ModelAdmin):
list_display = ('contract_id', 'date_issued', 'date_expired', 'date_completed')
raw_id_fields = ('character', 'corporation', 'issuer_char', 'issuer_corp')
class UserProfileAdmin(admin.ModelAdmin):
list_display = ('user', 'last_seen', 'can_add_keys')
class TransactionAdmin(admin.ModelAdmin):
list_display = ('transaction_id', 'date', 'character', 'corp_wallet', 'other_char', 'other_corp', 'item')
class JournalEntryAdmin(admin.ModelAdmin):
list_display = ('date', 'character', 'corp_wallet', 'ref_type', 'amount', 'owner1_id', 'owner2_id', 'reason')
raw_id_fields = ('character', 'corp_wallet', 'tax_corp')
class ColonyAdmin(admin.ModelAdmin):
list_display = ('character', 'system', 'planet', 'planet_type', 'last_update', 'level', 'pins')
list_filter = ('level', 'planet_type')
raw_id_fields = ('character',)
class PinAdmin(admin.ModelAdmin):
list_display = ('pin_id', 'colony', 'type', 'expires')
class IndustryJobAdmin(admin.ModelAdmin):
list_display = ('character', 'activity', 'blueprint', 'product', 'status')
list_filter = ('activity', 'status')
raw_id_fields = ('character', 'corporation')
class SkillPlanAdmin(admin.ModelAdmin):
list_display = ('name', 'user', 'visibility')
list_filter = ('visibility',)
admin.site.register(APIKey, APIKeyAdmin)
admin.site.register(Character, CharacterAdmin)
admin.site.register(CharacterConfig, CharacterConfigAdmin)
admin.site.register(BlueprintInstance, BlueprintInstanceAdmin)
admin.site.register(Campaign, CampaignAdmin)
admin.site.register(Corporation)
admin.site.register(Alliance, AllianceAdmin)
admin.site.register(APIKeyFailure, APIKeyFailureAdmin)
admin.site.register(Asset, AssetAdmin)
admin.site.register(AssetSummary, AssetSummaryAdmin)
admin.site.register(BlueprintComponent, BlueprintComponentAdmin)
admin.site.register(BlueprintProduct, BlueprintProductAdmin)
admin.site.register(Blueprint, BlueprintAdmin)
admin.site.register(CorpWallet, CorpWalletAdmin)
admin.site.register(TaskState, TaskStateAdmin)
admin.site.register(CharacterDetails, CharacterDetailsAdmin)
admin.site.register(Contract, ContractAdmin)
admin.site.register(UserProfile, UserProfileAdmin)
admin.site.register(Transaction, TransactionAdmin)
admin.site.register(JournalEntry, JournalEntryAdmin)
admin.site.register(Colony, ColonyAdmin)
admin.site.register(Pin, PinAdmin)
admin.site.register(IndustryJob, IndustryJobAdmin)
admin.site.register(SkillPlan, SkillPlanAdmin)
|
55330
|
from domain.exceptions.application_error import ApplicationError
class ContainerNotFound(ApplicationError):
def __init__(self, additional_message: str = '', container_name: str = ''):
super().__init__("Container Name Not Found ", additional_message + '{}'.format(container_name))
class JobNotStarted(ApplicationError):
def __init__(self, additional_message: str = '', container_name: str = ''):
super().__init__("Job Not Started ", additional_message + '{}'.format(container_name))
class ListIndexOutOfRange(ApplicationError):
def __init__(self, additional_message: str = '', container_id: str = ''):
super().__init__("The running container has no RepoTag please kill to proceed ",
additional_message + '{}'.format(container_id))
|
55331
|
import numpy as np
from numpy.testing import assert_equal
import scipy.sparse as sp
import tensorflow as tf
from .math import (sparse_scalar_multiply, sparse_tensor_diag_matmul,
_diag_matmul_py, _diag_matmul_transpose_py)
from .convert import sparse_to_tensor
class MathTest(tf.test.TestCase):
def test_sparse_scalar_multiply(self):
a = [[0, 2, 3], [0, 1, 0]]
a = sp.coo_matrix(a)
a = sparse_to_tensor(a)
a = sparse_scalar_multiply(a, 2)
a = tf.sparse_tensor_to_dense(a)
expected = [[0, 4, 6], [0, 2, 0]]
with self.test_session():
self.assertAllEqual(a.eval(), expected)
def test_sparse_tensor_diag_matmul(self):
a = [[2, 3, 0], [1, 0, 2], [0, 3, 0]]
a = sp.coo_matrix(a)
a = sparse_to_tensor(a)
diag = [2, 0.5, 3]
diag = tf.constant(diag)
b = sparse_tensor_diag_matmul(a, diag)
b = tf.sparse_tensor_to_dense(b)
expected = [[4, 6, 0], [0.5, 0, 1], [0, 9, 0]]
with self.test_session():
self.assertAllEqual(b.eval(), expected)
b = sparse_tensor_diag_matmul(a, diag, transpose=True)
b = tf.sparse_tensor_to_dense(b)
expected = [[4, 1.5, 0], [2, 0, 6], [0, 1.5, 0]]
with self.test_session():
self.assertAllEqual(b.eval(), expected)
def test_diag_matmul_py(self):
indices = np.array([[0, 0], [0, 1], [1, 0], [1, 2], [2, 1]])
values = np.array([2, 3, 1, 2, 3])
diag = np.array([2, 0.5, 3])
result = _diag_matmul_py(indices, values, diag)
expected = [4, 6, 0.5, 1, 9]
assert_equal(result, expected)
def test_diag_matmul_transpose_py(self):
indices = np.array([[1, 0], [0, 0], [0, 1], [1, 2], [2, 1]])
values = np.array([1, 2, 3, 2, 3])
diag = np.array([2, 0.5, 3])
result = _diag_matmul_transpose_py(indices, values, diag)
expected = [2, 4, 1.5, 6, 1.5]
assert_equal(result, expected)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.