id stringlengths 1 265 | text stringlengths 6 5.19M | dataset_id stringclasses 7
values |
|---|---|---|
3228792 | import unittest
from programy.utils.logging.ylogger import YLogger
from programy.utils.logging.ylogger import YLoggerSnapshot
from programy.context import ClientContext
from programytest.aiml_tests.client import TestClient
from programy.config.bot.bot import BotConfiguration
from programy.bot import Bot
from programy.config.brain.brain import BrainConfiguration
from programy.brain import Brain
from programy.context import ClientContext
class YLoggerTests(unittest.TestCase):
def test_ylogger(self):
client_context = ClientContext(TestClient(), "testid")
snapshot = YLoggerSnapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(str(snapshot), "Critical(0) Fatal(0) Error(0) Exception(0) Warning(0) Info(0), Debug(0)")
YLogger.reset_snapshot()
YLogger.critical(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(str(snapshot), "Critical(1) Fatal(0) Error(0) Exception(0) Warning(0) Info(0), Debug(0)")
YLogger.fatal(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(str(snapshot), "Critical(1) Fatal(1) Error(0) Exception(0) Warning(0) Info(0), Debug(0)")
YLogger.error(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(str(snapshot), "Critical(1) Fatal(1) Error(1) Exception(0) Warning(0) Info(0), Debug(0)")
YLogger.exception(client_context, "Test Message", Exception("Test error"))
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(str(snapshot), "Critical(1) Fatal(1) Error(1) Exception(1) Warning(0) Info(0), Debug(0)")
YLogger.warning(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(str(snapshot), "Critical(1) Fatal(1) Error(1) Exception(1) Warning(1) Info(0), Debug(0)")
YLogger.info(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(str(snapshot), "Critical(1) Fatal(1) Error(1) Exception(1) Warning(1) Info(1), Debug(0)")
YLogger.debug(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(str(snapshot), "Critical(1) Fatal(1) Error(1) Exception(1) Warning(1) Info(1), Debug(1)")
def test_format_message_with_client(self):
client = TestClient()
msg = YLogger.format_message(client, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[testclient] - Test Message", msg)
def test_format_message_with_client_and_bot(self):
client = TestClient()
config = BotConfiguration()
config._section_name = "testbot"
bot = Bot(config, client)
msg = YLogger.format_message(bot, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[testclient] [testbot] - Test Message", msg)
def test_format_message_with_bot(self):
config = BotConfiguration()
config._section_name = "testbot"
bot = Bot(config)
msg = YLogger.format_message(bot, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[] [testbot] - Test Message", msg)
def test_format_message_with_client_and_bot_and_brain(self):
client = TestClient()
bot_config = BotConfiguration()
bot_config._section_name = "testbot"
bot = Bot(bot_config, client)
brain_config = BrainConfiguration()
brain_config._section_name = "testbrain"
brain = Brain(bot, brain_config)
msg = YLogger.format_message(brain, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[testclient] [testbot] [testbrain] - Test Message", msg)
def test_format_message_with_client_and_bot_and_brain(self):
brain_config = BrainConfiguration()
brain_config._section_name = "testbrain"
brain = Brain(None, brain_config)
msg = YLogger.format_message(brain, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[] [] [testbrain] - Test Message", msg)
def test_format_message_with_client_context(self):
client = TestClient()
bot_config = BotConfiguration()
bot_config._section_name = "testbot"
bot = Bot(bot_config, client)
brain_config = BrainConfiguration()
brain_config._section_name = "testbrain"
brain = Brain(bot, brain_config)
client_context = ClientContext(client, "testuser")
client_context._bot = bot
client_context._brain = brain
msg = YLogger.format_message(client_context, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[testclient] [testbot] [testbrain] [testuser] - Test Message", msg)
| StarcoderdataPython |
36543 | <reponame>thoughteer/edera
"""
This module declares all custom exception classes.
"""
import edera.helpers
class Error(Exception):
"""
The base class for all exceptions within Edera.
"""
class ExcusableError(Error):
"""
The base class for all "excusable" errors.
They barely deserve a warning.
"""
class UndefinedParameterError(Error):
"""
You did not pass a required parameter.
"""
def __init__(self, name):
"""
Args:
name (String) - the name of the parameter
"""
Error.__init__(self, "parameter `%s` is undefined" % name)
class UnknownParameterError(Error):
"""
You passed an unknown parameter.
"""
def __init__(self, name):
"""
Args:
name (String) - the name of the parameter
"""
Error.__init__(self, "passed unknown parameter `%s`" % name)
class ValueQualificationError(Error):
"""
You passed an invalid value the a qualifier.
"""
def __init__(self, value, explanation):
"""
Args:
value (Any) - the invalid value
explanation (String) - what's gone wrong
"""
Error.__init__(self, "value %r was not qualified: %s" % (value, explanation))
class LockAcquisitionError(ExcusableError):
"""
We failed to acquire a lock for a key.
"""
def __init__(self, key):
"""
Args:
key (String) - the key
"""
ExcusableError.__init__(self, "lock for key `%s` has been already acquired" % key)
class LockRetentionError(ExcusableError):
"""
We failed to retain a lock.
"""
def __init__(self, key):
"""
Args:
key (String) - the key of the lock
"""
ExcusableError.__init__(self, "lock for key `%s` was lost" % key)
class RequisiteConformationError(Error):
"""
You used an invalid object as a requisite for a task.
"""
def __init__(self, requisite):
"""
Args:
requisite (Any) - the invalid object
"""
Error.__init__(self, "cannot conform %r" % requisite)
class CircularDependencyError(Error):
"""
You provided a graph with a cycle.
Attributes:
cycle (List[Any]) - the detected cycle
"""
def __init__(self, cycle):
"""
Args:
cycle (List[Any]) - the detected cycle
"""
message = "circular dependency detected: %s ..." % edera.helpers.render(cycle)
Error.__init__(self, message)
self.cycle = cycle
class TargetVerificationError(Error):
"""
Execution of your task didn't make its target come true.
Attributes:
task (Task) - the broken task
"""
def __init__(self, task):
"""
Args:
task (Task) - the broken task
"""
message = "target %r of task %r is false after execution" % (task.target, task)
Error.__init__(self, message)
self.task = task
class InvocationError(Error):
"""
The base class for all invocation errors within invokers.
"""
class ExcusableInvocationError(ExcusableError):
"""
The base class for all excusable invocation errors within invokers.
"""
class MasterSlaveInvocationError(InvocationError):
"""
Some of the slave workers failed for some reason.
Attributes:
failed_slaves (List[Worker]) - failed slave workers
"""
def __init__(self, failed_slaves):
"""
Args:
failed_slaves (List[Worker]) - failed slave workers
"""
message = "some of the slaves failed: %s" % edera.helpers.render(failed_slaves)
InvocationError.__init__(self, message)
self.failed_slaves = failed_slaves
class ExcusableMasterSlaveInvocationError(ExcusableInvocationError):
"""
Some of the slave workers stopped for some good reason.
Attributes:
stopped_slaves (List[Worker]) - stopped slave workers
"""
def __init__(self, stopped_slaves):
"""
Args:
stopped_slaves (List[Worker]) - stopped slave workers
"""
message = "some of the slaves stopped: %s" % edera.helpers.render(stopped_slaves)
ExcusableInvocationError.__init__(self, message)
self.stopped_slaves = stopped_slaves
class WorkflowExecutionError(Error):
"""
There were inexcusable errors during execution.
Attributes:
failed_tasks (List[Task]) - failed tasks
"""
def __init__(self, failed_tasks):
"""
Args:
failed_tasks (List[Task]) - failed tasks
"""
message = "some of the tasks failed: %s" % edera.helpers.render(failed_tasks)
Error.__init__(self, message)
self.failed_tasks = failed_tasks
class ExcusableWorkflowExecutionError(ExcusableError):
"""
There were excusable (and no inexcusable) errors during execution.
Attributes:
stopped_tasks (List[Task]) - stopped tasks
"""
def __init__(self, stopped_tasks):
"""
Args:
stopped_tasks (List[Task]) - stopped tasks
"""
message = "some of the tasks stopped: %s" % edera.helpers.render(stopped_tasks)
ExcusableError.__init__(self, message)
self.stopped_tasks = stopped_tasks
class WorkflowNormalizationError(Error):
"""
You described a workflow that cannot be normalized.
"""
class WorkflowTestificationError(Error):
"""
You provided an invalid test/stub definition.
"""
class StorageOperationError(Error):
"""
We failed to operate your storage.
"""
class MonitorInconsistencyError(ExcusableError):
"""
A checkpoint is no longer valid.
This might happen when you run multiple instances of $MonitorWatcher at the same time.
But it's totally fine, should be ignored.
"""
class ConsumptionError(Error):
"""
The consumer could not accept an element.
"""
| StarcoderdataPython |
3353621 | # -*- coding: utf-8 -*-
from __future__ import absolute_import
import six
from collections import OrderedDict
def join(strings, indent=0):
joiner = ' \\\n{}'.format(' ' * indent) if indent else ' '
return joiner.join(str(_).strip() for _ in strings if _)
class OptionsDict(OrderedDict):
def add_option(self, option_key, *values):
for value in values:
if not value or value is NotImplemented:
continue
value = '\'{}\''.format(value)
self.setdefault(option_key, []).append(value)
def options(self, indent=0):
return join((
'{} {}'.format('--' + option_key if option_key else option_key, value).strip()
for option_key in self
for value in self[option_key]
),
indent=indent
)
def __str__(self):
return self.options()
@six.python_2_unicode_compatible
class Curl(object):
"""
Polymorphic class that takes various request objects and translates them
to viable curl commands.
"""
__registry__ = {}
SUPPORTED_TYPES = ()
def __new__(cls, request, *args, **kwargs):
"""
Args:
request: A "request" object from a supported library.
Specifically one of:
- django.http.request.HttpRequest
- requests.models.[Response, Request, PreparedRequest]
- urllib.Request
"""
if cls is Curl:
for new_class, instance_check in cls.__registry__.items():
if isinstance(request, instance_check):
return super(Curl, new_class).__new__(new_class)
else:
raise TypeError('request of type {} is not of supported class type {}'.format(
type(request),
[_ for _ in cls.__registry__.values()],
))
else:
return super(Curl, cls).__new__(cls)
def __init__(self, request):
self.request = request
self._options = OptionsDict()
def __str__(self):
return self.curl()
@property
def __headers__(self):
'''Wrapper to make headers in the correct format'''
for header, value in self.headers:
yield '{}: {}'.format(header, value)
@property
def options(self):
if not self._options:
self._options.add_option('', self.absolute_uri)
self._options.add_option('request', self.method)
self._options.add_option('header', *self.__headers__)
self._options.add_option('data', self.data)
return self._options
@property
def headers(self):
return NotImplemented
@property
def method(self):
return NotImplemented
@property
def absolute_uri(self):
return NotImplemented
@property
def data(self):
return NotImplemented
def curl(self, verbose=False, indent=0):
"""
Returns(str): string that can be run as a curl command
"""
verbosity = '-' + 'v' * verbose if verbose else ''
options = self.options.options(indent=indent)
return join(('curl', verbosity, options), indent=indent)
@classmethod
def register(cls):
cls.__registry__[cls] = cls.SUPPORTED_TYPES
| StarcoderdataPython |
3281739 | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
'EndpointElasticsearchSettings',
'EndpointKafkaSettings',
'EndpointKinesisSettings',
'EndpointMongodbSettings',
'EndpointS3Settings',
]
@pulumi.output_type
class EndpointElasticsearchSettings(dict):
@staticmethod
def __key_warning(key: str):
suggest = None
if key == "endpointUri":
suggest = "endpoint_uri"
elif key == "serviceAccessRoleArn":
suggest = "service_access_role_arn"
elif key == "errorRetryDuration":
suggest = "error_retry_duration"
elif key == "fullLoadErrorPercentage":
suggest = "full_load_error_percentage"
if suggest:
pulumi.log.warn(f"Key '{key}' not found in EndpointElasticsearchSettings. Access the value via the '{suggest}' property getter instead.")
def __getitem__(self, key: str) -> Any:
EndpointElasticsearchSettings.__key_warning(key)
return super().__getitem__(key)
def get(self, key: str, default = None) -> Any:
EndpointElasticsearchSettings.__key_warning(key)
return super().get(key, default)
def __init__(__self__, *,
endpoint_uri: str,
service_access_role_arn: str,
error_retry_duration: Optional[int] = None,
full_load_error_percentage: Optional[int] = None):
"""
:param str endpoint_uri: Endpoint for the Elasticsearch cluster.
:param str service_access_role_arn: Amazon Resource Name (ARN) of the IAM Role with permissions to write to the Elasticsearch cluster.
:param int error_retry_duration: Maximum number of seconds for which DMS retries failed API requests to the Elasticsearch cluster. Defaults to `300`.
:param int full_load_error_percentage: Maximum percentage of records that can fail to be written before a full load operation stops. Defaults to `10`.
"""
pulumi.set(__self__, "endpoint_uri", endpoint_uri)
pulumi.set(__self__, "service_access_role_arn", service_access_role_arn)
if error_retry_duration is not None:
pulumi.set(__self__, "error_retry_duration", error_retry_duration)
if full_load_error_percentage is not None:
pulumi.set(__self__, "full_load_error_percentage", full_load_error_percentage)
@property
@pulumi.getter(name="endpointUri")
def endpoint_uri(self) -> str:
"""
Endpoint for the Elasticsearch cluster.
"""
return pulumi.get(self, "endpoint_uri")
@property
@pulumi.getter(name="serviceAccessRoleArn")
def service_access_role_arn(self) -> str:
"""
Amazon Resource Name (ARN) of the IAM Role with permissions to write to the Elasticsearch cluster.
"""
return pulumi.get(self, "service_access_role_arn")
@property
@pulumi.getter(name="errorRetryDuration")
def error_retry_duration(self) -> Optional[int]:
"""
Maximum number of seconds for which DMS retries failed API requests to the Elasticsearch cluster. Defaults to `300`.
"""
return pulumi.get(self, "error_retry_duration")
@property
@pulumi.getter(name="fullLoadErrorPercentage")
def full_load_error_percentage(self) -> Optional[int]:
"""
Maximum percentage of records that can fail to be written before a full load operation stops. Defaults to `10`.
"""
return pulumi.get(self, "full_load_error_percentage")
@pulumi.output_type
class EndpointKafkaSettings(dict):
def __init__(__self__, *,
broker: str,
topic: Optional[str] = None):
"""
:param str broker: Kafka broker location. Specify in the form broker-hostname-or-ip:port.
:param str topic: Kafka topic for migration. Defaults to `kafka-default-topic`.
"""
pulumi.set(__self__, "broker", broker)
if topic is not None:
pulumi.set(__self__, "topic", topic)
@property
@pulumi.getter
def broker(self) -> str:
"""
Kafka broker location. Specify in the form broker-hostname-or-ip:port.
"""
return pulumi.get(self, "broker")
@property
@pulumi.getter
def topic(self) -> Optional[str]:
"""
Kafka topic for migration. Defaults to `kafka-default-topic`.
"""
return pulumi.get(self, "topic")
@pulumi.output_type
class EndpointKinesisSettings(dict):
@staticmethod
def __key_warning(key: str):
suggest = None
if key == "messageFormat":
suggest = "message_format"
elif key == "serviceAccessRoleArn":
suggest = "service_access_role_arn"
elif key == "streamArn":
suggest = "stream_arn"
if suggest:
pulumi.log.warn(f"Key '{key}' not found in EndpointKinesisSettings. Access the value via the '{suggest}' property getter instead.")
def __getitem__(self, key: str) -> Any:
EndpointKinesisSettings.__key_warning(key)
return super().__getitem__(key)
def get(self, key: str, default = None) -> Any:
EndpointKinesisSettings.__key_warning(key)
return super().get(key, default)
def __init__(__self__, *,
message_format: Optional[str] = None,
service_access_role_arn: Optional[str] = None,
stream_arn: Optional[str] = None):
"""
:param str message_format: Output format for the records created. Defaults to `json`. Valid values are `json` and `json_unformatted` (a single line with no tab).
:param str service_access_role_arn: Amazon Resource Name (ARN) of the IAM Role with permissions to write to the Kinesis data stream.
:param str stream_arn: Amazon Resource Name (ARN) of the Kinesis data stream.
"""
if message_format is not None:
pulumi.set(__self__, "message_format", message_format)
if service_access_role_arn is not None:
pulumi.set(__self__, "service_access_role_arn", service_access_role_arn)
if stream_arn is not None:
pulumi.set(__self__, "stream_arn", stream_arn)
@property
@pulumi.getter(name="messageFormat")
def message_format(self) -> Optional[str]:
"""
Output format for the records created. Defaults to `json`. Valid values are `json` and `json_unformatted` (a single line with no tab).
"""
return pulumi.get(self, "message_format")
@property
@pulumi.getter(name="serviceAccessRoleArn")
def service_access_role_arn(self) -> Optional[str]:
"""
Amazon Resource Name (ARN) of the IAM Role with permissions to write to the Kinesis data stream.
"""
return pulumi.get(self, "service_access_role_arn")
@property
@pulumi.getter(name="streamArn")
def stream_arn(self) -> Optional[str]:
"""
Amazon Resource Name (ARN) of the Kinesis data stream.
"""
return pulumi.get(self, "stream_arn")
@pulumi.output_type
class EndpointMongodbSettings(dict):
@staticmethod
def __key_warning(key: str):
suggest = None
if key == "authMechanism":
suggest = "auth_mechanism"
elif key == "authSource":
suggest = "auth_source"
elif key == "authType":
suggest = "auth_type"
elif key == "docsToInvestigate":
suggest = "docs_to_investigate"
elif key == "extractDocId":
suggest = "extract_doc_id"
elif key == "nestingLevel":
suggest = "nesting_level"
if suggest:
pulumi.log.warn(f"Key '{key}' not found in EndpointMongodbSettings. Access the value via the '{suggest}' property getter instead.")
def __getitem__(self, key: str) -> Any:
EndpointMongodbSettings.__key_warning(key)
return super().__getitem__(key)
def get(self, key: str, default = None) -> Any:
EndpointMongodbSettings.__key_warning(key)
return super().get(key, default)
def __init__(__self__, *,
auth_mechanism: Optional[str] = None,
auth_source: Optional[str] = None,
auth_type: Optional[str] = None,
docs_to_investigate: Optional[str] = None,
extract_doc_id: Optional[str] = None,
nesting_level: Optional[str] = None):
"""
:param str auth_mechanism: Authentication mechanism to access the MongoDB source endpoint. Defaults to `default`.
:param str auth_source: Authentication database name. Not used when `auth_type` is `no`. Defaults to `admin`.
:param str auth_type: Authentication type to access the MongoDB source endpoint. Defaults to `password`.
:param str docs_to_investigate: Number of documents to preview to determine the document organization. Use this setting when `nesting_level` is set to `one`. Defaults to `1000`.
:param str extract_doc_id: Document ID. Use this setting when `nesting_level` is set to `none`. Defaults to `false`.
:param str nesting_level: Specifies either document or table mode. Defaults to `none`. Valid values are `one` (table mode) and `none` (document mode).
"""
if auth_mechanism is not None:
pulumi.set(__self__, "auth_mechanism", auth_mechanism)
if auth_source is not None:
pulumi.set(__self__, "auth_source", auth_source)
if auth_type is not None:
pulumi.set(__self__, "auth_type", auth_type)
if docs_to_investigate is not None:
pulumi.set(__self__, "docs_to_investigate", docs_to_investigate)
if extract_doc_id is not None:
pulumi.set(__self__, "extract_doc_id", extract_doc_id)
if nesting_level is not None:
pulumi.set(__self__, "nesting_level", nesting_level)
@property
@pulumi.getter(name="authMechanism")
def auth_mechanism(self) -> Optional[str]:
"""
Authentication mechanism to access the MongoDB source endpoint. Defaults to `default`.
"""
return pulumi.get(self, "auth_mechanism")
@property
@pulumi.getter(name="authSource")
def auth_source(self) -> Optional[str]:
"""
Authentication database name. Not used when `auth_type` is `no`. Defaults to `admin`.
"""
return pulumi.get(self, "auth_source")
@property
@pulumi.getter(name="authType")
def auth_type(self) -> Optional[str]:
"""
Authentication type to access the MongoDB source endpoint. Defaults to `password`.
"""
return pulumi.get(self, "auth_type")
@property
@pulumi.getter(name="docsToInvestigate")
def docs_to_investigate(self) -> Optional[str]:
"""
Number of documents to preview to determine the document organization. Use this setting when `nesting_level` is set to `one`. Defaults to `1000`.
"""
return pulumi.get(self, "docs_to_investigate")
@property
@pulumi.getter(name="extractDocId")
def extract_doc_id(self) -> Optional[str]:
"""
Document ID. Use this setting when `nesting_level` is set to `none`. Defaults to `false`.
"""
return pulumi.get(self, "extract_doc_id")
@property
@pulumi.getter(name="nestingLevel")
def nesting_level(self) -> Optional[str]:
"""
Specifies either document or table mode. Defaults to `none`. Valid values are `one` (table mode) and `none` (document mode).
"""
return pulumi.get(self, "nesting_level")
@pulumi.output_type
class EndpointS3Settings(dict):
@staticmethod
def __key_warning(key: str):
suggest = None
if key == "bucketFolder":
suggest = "bucket_folder"
elif key == "bucketName":
suggest = "bucket_name"
elif key == "compressionType":
suggest = "compression_type"
elif key == "csvDelimiter":
suggest = "csv_delimiter"
elif key == "csvRowDelimiter":
suggest = "csv_row_delimiter"
elif key == "datePartitionEnabled":
suggest = "date_partition_enabled"
elif key == "externalTableDefinition":
suggest = "external_table_definition"
elif key == "serviceAccessRoleArn":
suggest = "service_access_role_arn"
if suggest:
pulumi.log.warn(f"Key '{key}' not found in EndpointS3Settings. Access the value via the '{suggest}' property getter instead.")
def __getitem__(self, key: str) -> Any:
EndpointS3Settings.__key_warning(key)
return super().__getitem__(key)
def get(self, key: str, default = None) -> Any:
EndpointS3Settings.__key_warning(key)
return super().get(key, default)
def __init__(__self__, *,
bucket_folder: Optional[str] = None,
bucket_name: Optional[str] = None,
compression_type: Optional[str] = None,
csv_delimiter: Optional[str] = None,
csv_row_delimiter: Optional[str] = None,
date_partition_enabled: Optional[bool] = None,
external_table_definition: Optional[str] = None,
service_access_role_arn: Optional[str] = None):
"""
:param str bucket_folder: S3 Bucket Object prefix.
:param str bucket_name: S3 Bucket name.
:param str compression_type: Set to compress target files. Defaults to `NONE`. Valid values are `GZIP` and `NONE`.
:param str csv_delimiter: Delimiter used to separate columns in the source files. Defaults to `,`.
:param str csv_row_delimiter: Delimiter used to separate rows in the source files. Defaults to `\n`.
:param bool date_partition_enabled: Partition S3 bucket folders based on transaction commit dates. Defaults to `false`.
:param str external_table_definition: JSON document that describes how AWS DMS should interpret the data.
:param str service_access_role_arn: Amazon Resource Name (ARN) of the IAM Role with permissions to read from or write to the S3 Bucket.
"""
if bucket_folder is not None:
pulumi.set(__self__, "bucket_folder", bucket_folder)
if bucket_name is not None:
pulumi.set(__self__, "bucket_name", bucket_name)
if compression_type is not None:
pulumi.set(__self__, "compression_type", compression_type)
if csv_delimiter is not None:
pulumi.set(__self__, "csv_delimiter", csv_delimiter)
if csv_row_delimiter is not None:
pulumi.set(__self__, "csv_row_delimiter", csv_row_delimiter)
if date_partition_enabled is not None:
pulumi.set(__self__, "date_partition_enabled", date_partition_enabled)
if external_table_definition is not None:
pulumi.set(__self__, "external_table_definition", external_table_definition)
if service_access_role_arn is not None:
pulumi.set(__self__, "service_access_role_arn", service_access_role_arn)
@property
@pulumi.getter(name="bucketFolder")
def bucket_folder(self) -> Optional[str]:
"""
S3 Bucket Object prefix.
"""
return pulumi.get(self, "bucket_folder")
@property
@pulumi.getter(name="bucketName")
def bucket_name(self) -> Optional[str]:
"""
S3 Bucket name.
"""
return pulumi.get(self, "bucket_name")
@property
@pulumi.getter(name="compressionType")
def compression_type(self) -> Optional[str]:
"""
Set to compress target files. Defaults to `NONE`. Valid values are `GZIP` and `NONE`.
"""
return pulumi.get(self, "compression_type")
@property
@pulumi.getter(name="csvDelimiter")
def csv_delimiter(self) -> Optional[str]:
"""
Delimiter used to separate columns in the source files. Defaults to `,`.
"""
return pulumi.get(self, "csv_delimiter")
@property
@pulumi.getter(name="csvRowDelimiter")
def csv_row_delimiter(self) -> Optional[str]:
"""
Delimiter used to separate rows in the source files. Defaults to `\n`.
"""
return pulumi.get(self, "csv_row_delimiter")
@property
@pulumi.getter(name="datePartitionEnabled")
def date_partition_enabled(self) -> Optional[bool]:
"""
Partition S3 bucket folders based on transaction commit dates. Defaults to `false`.
"""
return pulumi.get(self, "date_partition_enabled")
@property
@pulumi.getter(name="externalTableDefinition")
def external_table_definition(self) -> Optional[str]:
"""
JSON document that describes how AWS DMS should interpret the data.
"""
return pulumi.get(self, "external_table_definition")
@property
@pulumi.getter(name="serviceAccessRoleArn")
def service_access_role_arn(self) -> Optional[str]:
"""
Amazon Resource Name (ARN) of the IAM Role with permissions to read from or write to the S3 Bucket.
"""
return pulumi.get(self, "service_access_role_arn")
| StarcoderdataPython |
3304617 | import logging
from os import environ
from os.path import join, relpath, splitext
from mergedeep import merge
import yaml
from envyaml import EnvYAML
from dagger.config_finder.config_finder import ConfigFinder
from dagger.pipeline.pipeline import Pipeline
from dagger.pipeline.task_factory import TaskFactory
import dagger.conf as conf
_logger = logging.getLogger("configFinder")
DAG_DIR = join(environ.get("AIRFLOW_HOME", "./"), "dags")
class ConfigProcessor:
def __init__(self, config_finder: ConfigFinder):
self._config_finder = config_finder
self._task_factory = TaskFactory()
def _load_yaml(self, yaml_path):
config_dict = EnvYAML(yaml_path).export()
config_dict = self.localize_params(config_dict)
return config_dict
def localize_params(self, config):
env_dependent_params = config.get("environments", {}).get(conf.ENV, {})
if env_dependent_params.get("deactivate"):
return None
merge(config, env_dependent_params)
return config
def process_pipeline_configs(self):
configs = self._config_finder.find_configs()
pipelines = []
for pipeline_config in configs:
pipeline_name = relpath(pipeline_config.directory, DAG_DIR).replace(
"/", "-"
)
config_path = join(pipeline_config.directory, pipeline_config.config)
_logger.info("Processing config: %s", config_path)
config_dict = self._load_yaml(config_path)
if config_dict:
pipeline = Pipeline(pipeline_config.directory, config_dict)
else:
_logger.info(f"{pipeline_name} pipeline is disabled in {conf.ENV} environment")
continue
for task_config in pipeline_config.job_configs:
task_name = splitext(task_config.config)[0]
task_config_path = join(pipeline_config.directory, task_config.config)
_logger.info("Processing task config: %s", task_config_path)
task_config = self._load_yaml(task_config_path)
if task_config:
task_type = task_config["type"]
pipeline.add_task(
self._task_factory.create_task(
task_type, task_name, pipeline_name, pipeline, task_config
)
)
else:
_logger.info(f"{task_name} job is disabled in {conf.ENV} environment")
pipelines.append(pipeline)
return pipelines
| StarcoderdataPython |
3333933 | # Generated by Django 3.0.5 on 2021-01-08 17:32
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("api", "0009_auto_20210108_1550"),
]
operations = [
migrations.AlterField(
model_name="device",
name="device_id",
field=models.CharField(max_length=40, unique=True),
),
]
| StarcoderdataPython |
3231408 | def display_board(board):
print(board[7]+'|'+board[8]+'|'+board[9])
print('-|-|-')
print(board[4]+'|'+board[5]+'|'+board[6])
print('-|-|-')
print(board[1]+'|'+board[2]+'|'+board[3])
def player_input():
marker = ''
while marker != 'X' and marker != 'O':
marker = input('player 1, chose X or O: ')
player1 = marker
if player1 == 'X':
player2 = 'O'
else:
player2 = 'X'
return(player1,player2)
def place_marker(board, marker, position):
board[position] = marker
def win_check(board, mark):
return ((board[1]==mark and board[2]==mark and board[3]==mark) or
(board[4]==mark and board[5]==mark and board[6]==mark) or
(board[7]==mark and board[8]==mark and board[9]==mark) or
(board[1]==mark and board[4]==mark and board[7]==mark) or
(board[2]==mark and board[5]==mark and board[8]==mark) or
(board[3]==mark and board[6]==mark and board[9]==mark) or
(board[1]==mark and board[5]==mark and board[9]==mark) or
(board[3]==mark and board[5]==mark and board[7]==mark))
import random
def choose_first():
if random.randint(0,1) == 0:
return 'Player 1'
else:
return 'Player 2'
def space_check(board, position):
return board[position] == ' '
def full_board_check(board):
for i in range(1,10):
if space_check(board, i):
return False
return True
def player_choice(board):
position = 0
while position not in [1,2,3,4,5,6,7,8,9] or not space_check(board, position):
position = int(input('Chose your position from 1-9: '))
return position
def replay():
response = input('Do you want to play again? Enter Yes or No:')
if response.lower()[0] == 'y':
return True
elif response.lower()[0] == 'n':
return False
print('Welcome to <NAME>!')
print('The board is in the format of a number pad')
print('7|8|9')
print('-|-|-')
print('4|5|6')
print('-|-|-')
print('1|2|3')
while True:
brd = [' ']*10
player1_marker, player2_marker = player_input()
turn = choose_first()
print(turn+' will go first.')
play_game = input('Are you ready? Yes or No :')
if play_game.lower()[0]=='y':
game_on = True
else:
game_on = False
while game_on:
if turn == 'Player 1':
# Player1's turn.
display_board(brd)
position = player_choice(brd)
place_marker(brd,player1_marker,position)
if win_check(brd, player1_marker):
display_board(brd)
print('Player 1 has won the game!')
game_on = False
else:
if full_board_check(brd):
display_board(brd)
print('The game is a draw!')
break
else:
turn = 'Player 2'
else:
# Player2's turn.
display_board(brd)
position = player_choice(brd)
place_marker(brd, player2_marker, position)
if win_check(brd, player2_marker):
display_board(brd)
print('Player 2 has won the game!')
game_on = False
else:
if full_board_check(brd):
display_board(brd)
print('The game is a draw!')
break
else:
turn = 'Player 1'
if not replay():
break | StarcoderdataPython |
3234553 | <filename>edacom.py
#!/usr/bin/env python
"""
Runs on one Raspberry Pi inside each of the beamformer control boxes, to send pointing commands to the eight
beamformers connected to that box.
On startup, it:
-Checks that the hostname (as reported by 'hostname -A') is either 'eda1com or 'eda2com', and exits if not.
-Uses the integer (1 or 2) in the hostname to determine whether this box is connected to the first
eight beamformers (0-8), or the second eight beamformers (9-F).
-Starts a Pyro4 daemon on port 19987 to listen for (and execute) remote procedure calls over the network.
On exit (eg, with a control-C or a 'kill' command), it:
-Stops the Pyro4 daemon
-Exits.
"""
import atexit
import logging
from logging import handlers
import optparse
import signal
import subprocess
import sys
import threading
import time
# noinspection PyUnresolvedReferences
import RPi.GPIO as GPIO
import astropy
import astropy.time
import astropy.units
from astropy.time import Time
from astropy.coordinates import SkyCoord, EarthLocation
if sys.version_info.major == 2:
# noinspection PyUnresolvedReferences
STR_CLASS = basestring
else:
STR_CLASS = str
# set up the logging
LOGLEVEL_CONSOLE = logging.DEBUG # Logging level for console messages (INFO, DEBUG, ERROR, CRITICAL, etc)
LOGLEVEL_LOGFILE = logging.DEBUG # Logging level for logfile
LOGLEVEL_REMOTE = logging.INFO
LOGFILE = "/tmp/edacom.log"
class MWALogFormatter(logging.Formatter):
def format(self, record):
return "%s: time %10.6f - %s" % (record.levelname, time.time(), record.getMessage())
mwalf = MWALogFormatter()
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
fh = handlers.RotatingFileHandler(LOGFILE, maxBytes=1000000000,
backupCount=5) # 1 Gb per file, max of five old log files
fh.setLevel(LOGLEVEL_LOGFILE)
fh.setFormatter(mwalf)
ch = logging.StreamHandler()
ch.setLevel(LOGLEVEL_CONSOLE)
ch.setFormatter(mwalf)
# rh = handlers.SysLogHandler(address=('mw-gw', 514))
# rh.setLevel(LOGLEVEL_REMOTE)
# rh.setFormatter(mwalf)
# add the handlers to the logger
logger.addHandler(fh)
logger.addHandler(ch)
# logger.addHandler(rh)
import Pyro4
# noinspection PyUnresolvedReferences
sys.excepthook = Pyro4.util.excepthook
Pyro4.config.DETAILED_TRACEBACK = True
Pyro4.config.SERIALIZERS_ACCEPTED.add('pickle')
import pyslave
import pointing
TILEID = 99 # MWA tile ID for the EDA station
SLAVEPORT = 19987
STRICT = False
ONLYBFs = None
# ONLYBFs = ['E']
CPOS = (0.0, 0.0, 0.0) # Offset from geometric centre, in metres, to use as delay centre for pointing calculations
# IO pin allocations as (txdata, txclock, rxdata) for each of the 8 RxDOC cards in this box, numbered 1-8
IOPINS = {1:(29, 16, 40), 2:(26, 15, 38), 3:(24, 13, 37), 4:(23, 12, 36), 5:(22, 11, 35), 6:(21, 10, 33), 7:(19, 8, 32),
8:(18, 7, 31)}
# Timeout for PyController comms to the PointingSlave instance
PS_TIMEOUT = 60
SIGNAL_HANDLERS = {}
CLEANUP_FUNCTION = None
MWAPOS = EarthLocation.from_geodetic(lon="116:40:14.93", lat="-26:42:11.95", height=377.8)
def init():
"""Initialise IO pins for pointing comms with all 8 beamformers
"""
GPIO.setmode(GPIO.BOARD) # Use board connector pin numbers to specify I/O pins
GPIO.setwarnings(False)
for i in range(1, 9):
txdata, txclock, rxdata = IOPINS[i]
GPIO.setup(rxdata, GPIO.IN)
GPIO.setup(txdata, GPIO.OUT)
GPIO.setup(txclock, GPIO.OUT)
def get_hostname():
"""Returns the hostname, with domain stripped off. Used to work out whether this Raspberry Pi controls MWA
beamformers 0-8 (eda1com.mwa128t.org) or beamformers 9-F (eda2com.mwa128t.org).
"""
if sys.version_info.major == 2:
fqdn = subprocess.check_output(['hostname', '-A'], shell=False)
else:
fqdn = subprocess.check_output(['hostname', '-A'], shell=False).decode('UTF-8')
return fqdn.split('.')[0]
def point(starttime=0, bfnum=0, outstring='', results=None, resultlock=None):
"""
Called with the start time of the next observation (a unix timestamp), the beamformer number to point, and
the string containing the delay bits to write.
Waits until the specified time, then sends the bit string to the beamformer. The results are written to the
given dictionary, using the lock supplied - this is because 'point' is called in parallel for all eight
beamformers, using the same results dictionary, so that all eight beamformers are pointed at the same instant.
:param starttime: start time in seconds past the unix epoch,
:param bfnum: beamformer output number (1-8),
:param outstring: bit-string to send,
:param results: dictionary to store (temp, flag) returned from the beamformer,
:param resultlock: lock object to avoid conflicts writing to the results dict
:return:
"""
now = time.time()
if now < starttime:
logger.debug("bf %d is sleeping for %5.2f seconds" % (bfnum, starttime - now))
time.sleep(starttime - now)
temp, flags = send_bitstring(bfnum=bfnum, outstring=outstring)
with resultlock:
results[bfnum] = (temp, flags)
logger.info("bf %d bitstring sent." % bfnum)
def calc_azel(ra=0.0, dec=0.0, calctime=None):
"""
Takes RA and DEC in degrees, and calculates Az/El of target at the specified time
:param ra: Right Ascension (J2000) in degrees
:param dec: Declination (J2000) in degrees
:param calctime: Time (as a unix time stamp) for the conversion, or None to calculate for the current time.
:return: A tuple of (azimuth, elevation) in degrees
"""
# noinspection PyUnresolvedReferences
coords = SkyCoord(ra=ra, dec=dec, equinox='J2000', unit=(astropy.units.deg, astropy.units.deg))
if calctime is None:
azeltime = Time.now()
else:
azeltime = Time(calctime, format='unix', scale='utc')
coords.location = MWAPOS
coords.obstime = azeltime
cpos = coords.transform_to('altaz')
return cpos.az.deg, cpos.alt.deg
class PointingSlave(pyslave.Slave):
"""Subclass the pycontroller slave class so we can override the notify() method to point the EDA.
Any methods decorated with '@Pyro4.expose' are called remotely over the network, from the control
computer.
"""
def __init__(self, edanum=0, tileid=0, clientid=None, port=None):
"""
:param edanum: Either 1 or 2, used to determine which set of 8 beamformers we are pointing.
:param tileid: Which MWA tile number we are (used to ignore notify() calls not meant for us)
:param clientid: Pyro4 service name - eg eda1com
:param port: network port to listen on
"""
self.tileid = tileid
self.orig_tileid = tileid # Save the 'real' tile ID here, so we can change the 'current' one
self.edanum = edanum
self.offsets = pointing.getOffsets()
self.lastpointing = (None, None, None, None, None, None, None, None, None)
pyslave.Slave.__init__(self, clientid=clientid, rclass='pointing', port=port)
@Pyro4.expose
def stop_tracking(self):
"""Change the tileid that we recognise for notify() calls, so that we ignore any notify() calls
from pycontroller in response to MWA observations. EDA client code calls to notify() use a
tileid of 0, and are always recognised.
"""
self.tileid = -1
logger.info('Tracking disable, current tile ID set to None')
return True
@Pyro4.expose
def start_tracking(self):
"""Change the tileid that we recognise for notify() calls, so that we react to any notify() calls
from pycontroller in response to MWA observations. EDA client code calls to notify() use a
tileid of 0, and are always recognised.
"""
self.tileid = self.orig_tileid
logger.info('Tracking enabled, current tile ID restored to %d' % self.tileid)
return True
@Pyro4.expose
def onlybfs(self, bfids=None):
"""If called with bfids=None, enables all dipoles on all MWA beamformers. If bfids is a list of
single hex digits, or a string of hex digits, enable all dipoles on those beamformers, and
disable them on all others.
The state is saved in a global variable, and lasts until the next call to onlybfs().
:param bfids: A list of hex digits (eg ['0', '4', 'A']), or a string of hex digits (eg '04A')
:return: False if there was an error parsing the bfids argument, True if successful.
"""
global ONLYBFs
if bfids is None:
logger.info('Enabling all channels')
ONLYBFs = None
elif (type(bfids) == list) or (isinstance(bfids, STR_CLASS)):
onlybfs = []
for bfid in bfids:
if (isinstance(bfid, STR_CLASS)) and (len(bfid) == 1):
if bfid.upper() in pointing.HEXD:
onlybfs.append(bfid.upper())
else:
logger.critical("Invalid BFID code: %s" % bfid)
return False
else:
logger.critical("Invalid BFID: %s" % bfid)
return False
logger.info("Enabling only beamformers %s" % onlybfs)
ONLYBFs = onlybfs
@Pyro4.expose
def set_cpos(self, cpos=None):
"""Sets the position of the EDA centre used for delay calculations, relative to the geometric centre.
If cpos is not None, it must be a tuple of three floats, used as an offset from the geometrical
EDA centre (0,0,0) in the units used in the locations file), in metres.
The state is saved in a global variable, and lasts until the next call to set_cpos().
:param cpos: A tuple of three floats (offsets E/W, N/S and up/down), or None.
:return: False if there was an error parsing the cpos argument, True if successful.
"""
global CPOS
if cpos is None:
CPOS = (0.0, 0.0, 0.0)
else:
if (type(cpos) == tuple) and (len(cpos) == 3):
ok = True
for element in cpos:
if (type(element) != float) and (type(element) != int):
ok = False
if ok:
CPOS = cpos
return True
else:
logger.error('Invalid item in argument for set_cpos(%s) call' % cpos)
return False
else:
logger.error('Invalid argument to set_cpos(%s)' % cpos)
return False
@Pyro4.expose
def is_tracking(self):
"""Returns True if we are tracking MWA observations, False otherwise."""
return self.tileid == self.orig_tileid
@Pyro4.expose
def get_status(self):
"""Returns a status object. This is a tuple of:
istracking (True or False),
ONLYBFs (global variable, None for all beamformers enabled, or a list of hex digit if only some are enabled)
CPOS (global flag containing offset centre for delay calculations)
self.tileid (None if not tracking, otherwise the MWA tile ID that the EDA is mirroring,
self.lastpointing - the last pointing status.
The 'lastpointing' status is itself a tuple, of:
starttime (in GPS seconds or unix timestamp) - when the pointing took place
obsid (in GPS seconds) for this observation
xra
xdec
xaz
xel
xdelays (a list of 16 raw delay values, overriding az/el/ra/dec)
offcount (how many dipoles were disabled, using onlybfs or because the required delay values couldn't be met)
ok (True or False) - whether the pointing was successful
"""
return (self.is_tracking(), ONLYBFs, CPOS, self.tileid, self.lastpointing)
@Pyro4.expose
def notify(self, obsid=None, starttime=None, stoptime=None, clientid=None, rclass=None, values=None):
"""Called remotely by the master object when registered tile properties change.
This takes the az/el pointing direction, converts to a list of 256 tuples for
the 256 AAVS antennae (x,y), and calls the point() function in parallel in eight
seperate threads. Each thread waits until the specified observation start time,
sends the new delays to its MWA beamformer, and returns True or False. If all eight
tiles point OK, the OK flag returned by this function is True.
Note that while RA/Dec/Az/El/Delays are passed individually for both X and Y polarisation, the
current code ignores the Y pol data, and uses the X pol data to set both the X and Y delay values.
:param obsid: The MWA observation ID (time in GPS seconds) for the new observation.
:param starttime: The time the new observation should start, either in GPS seconds or
seconds since the Unix epoch (defined when the client is registered).
:param stoptime: The time the new observation should stop, in the same timescale (GPS seconds
or Unix epoch seconds) as the starttime parameter.
:param clientid: Arbitrary client name string, should match this client's ID.
:param rclass: Registration class - either 'pointing', 'freq', 'atten', or 'obs'. Defines
what sort of notification messages we should be sent. Should match registrion
class of this client.
:param values: The actual data for the new observation, as a dictionary where
tile_id is the key. The value is a dictionary with polarisation ('X' or 'Y') as
the key, and a tuple of (ra, dec, az, el, rawdelays) as value.
Eg: values={0:{'X':(12.0, -26.0, None, None, None), 'Y':(12.0, -26.0, None, None, None)}}
:return: A tuple of (clientid, obsid, starttime, resdict) where 'resdict' is a dictionary with tileid
as a key, and tuples of (BFtemperature,ok) as a value, and the other items are defined above.
"""
assert rclass == 'pointing'
assert clientid == self.clientid
if self.tileid in values.keys():
xra, xdec, xaz, xel, xdelays = values[self.tileid]['X']
elif 0 in values.keys():
logger.info('Manual pointing command received - tile 0 information')
xra, xdec, xaz, xel, xdelays = values[0]['X']
elif self.tileid < 0:
logger.info('Not pointing - MWA tracking disabled, will only point when given tileid=0')
return self.clientid, obsid, starttime, {self.tileid:(999, False)} # Tuple of clientid, tileid, starttime, temperature in deg C, and a 'pointing OK' boolean
else:
logger.warning('Not pointing - tileid of %s not in tileset: %s' % (self.tileid, values.keys()))
return self.clientid, obsid, starttime, {self.tileid:(999, False)} # Tuple of clientid, tileid, starttime, temperature in deg C, and a 'pointing OK' boolean
if xdelays and (type(xdelays) == dict): # If delays is a dict, they are EDA delays, so use them. If a list, they are normal MWA tile delays
logger.info("Received raw delays to send to beamformers")
idelays = xdelays
else:
if (xra is not None) and (xdec is not None):
logger.info("Received RA/Dec=%s/%s for target at obsid=%s, time=%s, calculating Az/El" % (xra, xdec, obsid, starttime))
az, el = calc_azel(ra=xra, dec=xdec, calctime=(starttime + ((starttime - stoptime) / 2)))
xaz = az
xel = el
else:
logger.info("Received Az/el for obsid=%s, time %s: az=%s, el=%s" % (obsid, starttime, xaz, xel))
logger.info("New pointing for obsid=%s, time %s: az=%s, el=%s" % (obsid, starttime, xaz, xel))
if ONLYBFs is not None:
clipdelays = False
else:
clipdelays = True
idelays, diagnostics = pointing.calc_delays(offsets=self.offsets, az=xaz, el=xel, strict=STRICT,
verbose=True, clipdelays=clipdelays, cpos=CPOS)
if diagnostics is not None:
delays, delayerrs, sqe, maxerr, offcount = diagnostics
if offcount > 0:
logger.warning('Elevation low - %d dipoles disabled because delays were too large to reach in hardware.' % offcount)
if idelays is None:
logger.error("Error calculating delays for az=%s, el=%s" % (xaz, xel))
return self.clientid, obsid, starttime, {self.tileid:(999, False)}
if ONLYBFs is None:
offcount = 0
for bfid in pointing.HEXD:
for dipid in pointing.HEXD:
if idelays[bfid][dipid] == 16: # disabled
offcount += 1
else:
offcount = 0
logger.warning(
"Only some first stage beamformer enabled (%s), other %d dipoles are disabled!" % (ONLYBFs, offcount))
for bfid in pointing.HEXD:
for dipid in pointing.HEXD:
if bfid in ONLYBFs:
if (idelays[bfid][dipid] < -16) or (idelays[bfid][dipid] > 15):
idelays[bfid][dipid] = 16 # Disabled
offcount += 1
else:
idelays[bfid][dipid] = 16 # Disabled
offcount += 1
offset = 0
if self.edanum == 2:
offset = 8
comthreads = [] # Used to store the thread objects that are actually communicating with the beamformers
results = {}
resultlock = threading.RLock()
for bfnum in range(1, 9):
bfid = hex(bfnum - 1 + offset)[-1].upper() # Translate input 1-8 on edanum=1 or edanum=2 to a hex bfid in the idelays dict ('0' to 'F')
tiledelays = [idelays[bfid][hexd] + 16 for hexd in pointing.HEXD] # raw idelays values range from -16 to +15, so need to add 16 before we send them to the beamformer
logger.info("bfnum=%d, delays=%s" % (bfnum, tiledelays))
outstring = gen_bitstring(tiledelays, tiledelays)
newthread = threading.Thread(target=point,
name='com%s' % bfnum,
kwargs={'starttime':starttime,
'bfnum':bfnum,
'outstring':outstring,
'results':results,
'resultlock':resultlock})
newthread.start()
comthreads.append(newthread)
for t in comthreads:
t.join()
numok = 0
sumtemp = 0.0
for bfnum in range(1, 9):
temp, flags = results[bfnum]
logger.debug('Port %d: Flags=%d, Temp=%4.1f' % (bfnum, flags, temp))
if flags == 128:
numok += 1
sumtemp += temp
logger.info(
"Pointed these tiles without error: %s" % [bfnum for bfnum in range(1, 9) if results[bfnum][1] == 128])
if numok < 8:
logger.error("Errors in tiles: %s" % [(bfnum, results[bfnum]) for bfnum in range(1, 9) if results[bfnum][1] != 128])
self.lastpointing = (starttime, obsid, xra, xdec, xaz, xel, xdelays, offcount, (numok == 8))
if numok:
avgtemp = sumtemp / numok
else:
avgtemp = 0.0
return self.clientid, obsid + self.edanum, starttime, {self.tileid:(avgtemp, (numok == 8))}
def gen_bitstring(xdelays, ydelays):
"""Given two arrays of 16 integers, representing the xdelays and ydelays, return
a string containing 253 characters, each '1' or '0', representing the bit stream
to be sent to the beamformer.
Format is:
8 zeroes
4 ones
20 zeroes
6 blocks of 17 bits, each containing a 16-bit number containing the packed 6-bit
x delay values, followed by a '1' bit
6 blocks of 17 bits, each containing a 16-bit number containing the packed 6-bit
y delay values, followed by a '1' bit
16 bits of checksum (the twelve 16-bit packed delay words XORed together)
A '1' bit to mark the end of the 13th 16-bit word
These 253 bits are returned as a string with 253 '1' and '0' characters.
After those bits are clocked out, a further 24 clock pulses should be sent, and
24 bits of data (16 bits containing a 12-bit signed temperature, and 8 bits of
flags) will be received.
"""
outlist = ['0' * 8, '1' * 4, '0' * 20]
dwords = []
for val in (xdelays + ydelays):
if (val < 0) or (val > 63):
return # Each delay value must fit in 6 bits
else:
dwords.append('{0:06b}'.format(val))
dstring = ''.join(dwords)
checksum = 0
for i in range(0, 12 * 16, 16):
checksum = checksum ^ int(dstring[i:i + 16], 2)
outlist.append(dstring[i:i + 16] + '1')
outlist.append('{0:016b}'.format(checksum))
return ''.join(outlist) # 253 bits of output data
def send_bitstring(bfnum, outstring, bittime=0.00002):
"""Given a string of 253 '1' or '0' characters, clock them out using the TXDATA and TXCLOCK
pins, then clock in 24 bits of temp and flag data from the RXDATA pin.
bittime is the total time to take to send one but, in seconds.
bfnum is the beamformer number, from 1-8, used to find the correct IO pin numbers
in the IOPINS dict.
"""
txdata, txclock, rxdata = IOPINS[bfnum]
for bit in outstring:
GPIO.output(txdata, {'1':1, '0':0}[bit])
time.sleep(bittime / 4) # wait for data bit to settle
GPIO.output(txclock, 1) # Send clock high
time.sleep(bittime / 2) # Leave clock high for half the total bit transmit time
GPIO.output(txclock, 0) # Send clock low,so data is valid on both rising and falling edge
time.sleep(bittime / 4) # Leave data valid until the end of the bit transmit time
# While the temperature is 16 bits and the checksum is 8 bits, giving 24
# bits in total, we appear to have to clock an extra bit-time to complete the
# read-back operation. Once that's done, the checksum is the final (right-
# most) 8 bits, and the temperature is 13 bits (signed plus 12-bits). Both
# values are most-significant-bit first (chronologically).
GPIO.output(txdata, 0)
inbits = []
for i in range(25): # Read in temp data
time.sleep(bittime / 4)
GPIO.output(txclock, 1)
time.sleep(bittime / 4)
inbits.append({True:'1', False:'0'}[GPIO.input(rxdata)])
time.sleep(bittime / 4)
GPIO.output(txclock, 0)
time.sleep(bittime / 4)
rawtemp = int(''.join(inbits[:17]), 2) # Convert the first 16 bits to a temperature
temp = 0.0625 * (rawtemp & 0xfff) # 12 bits of value
if (rawtemp & 0x1000):
temp -= 256.0
flags = int(''.join(inbits[17:]), 2)
return temp, flags
def cleanup():
"""Called on program exit, to clean up GPIO pins and shut down the Pyro server gracefully, without
leaving hanging network ports.
"""
global pcs
logger.info("Cleaning up GPIO library")
GPIO.cleanup()
logger.info("Shutting down network Pyro4 daemon")
try:
pcs.exiting = True
pcs.pyro_daemon.shutdown()
except NameError:
pass # In test mode, there's no PySlave instance
# noinspection PyUnusedLocal
def SignalHandler(signum=None, frame=None):
"""Called when a signal is received thay would result in the programme exit, if the
RegisterCleanup() function has been previously called to set the signal handlers and
define an exit function using the 'atexit' module.
Note that exit functions registered by atexit are NOT called when the programme exits due
to a received signal, so we must trap signals where possible. The cleanup function will NOT
be called when signal 9 (SIGKILL) is received, as this signal cannot be trapped.
"""
print("Signal %d received." % signum)
sys.exit(-signum) # Called by signal handler, so exit with a return code indicating the signal received
def RegisterCleanup(func):
"""Traps a number of signals that would result in the program exit, to make sure that the
function 'func' is called before exit. The calling process must define its own cleanup
function - typically this would delete any facility controller objects, so that any
processes they have started will be stopped.
We don't need to trap signal 2 (SIGINT), because this is internally handled by the python
interpreter, generating a KeyboardInterrupt exception - if this causes the process to exit,
the function registered by atexit.register() will be called automatically.
"""
global SIGNAL_HANDLERS, CLEANUP_FUNCTION
CLEANUP_FUNCTION = func
for sig in [3, 15]:
SIGNAL_HANDLERS[sig] = signal.signal(sig, SignalHandler) # Register a signal handler
SIGNAL_HANDLERS[1] = signal.signal(1, signal.SIG_IGN)
# Register the passed CLEANUP_FUNCTION to be called on
# on normal programme exit, with no arguments.
atexit.register(CLEANUP_FUNCTION)
if __name__ == '__main__':
parser = optparse.OptionParser(usage="usage: %prog [options]")
parser.add_option("-n", "--nohostcheck", default=False, action="store_true", dest="nohostcheck",
help="Skip host name check before startup")
parser.add_option("-t", "--test", default=False, action="store_true", dest="test",
help="Test mode - send dummy delays, continuously")
(options, args) = parser.parse_args()
init()
calc_azel(ra=0.0, dec=-26.0) # Run the astropy function once on startup, to preload all the ephemeris data and save time later
RegisterCleanup(cleanup)
if options.nohostcheck:
edanum = 1
clientname = 'edaNmc'
else:
hostname = get_hostname()
clientname = hostname
try:
eda, edanum, func = hostname[:3], int(hostname[3]), hostname[4:]
assert eda == 'eda'
assert (func == 'mc') or (func == 'com')
except:
logger.critical("Invalid hostname %s - should be of the form 'edaNmc' or 'edaNcom', where N is an integer" % hostname)
sys.exit(-1)
if func != 'com':
logger.critical("Can't start communications/pointing process on an M&C device. Run on edaNcom host instead")
sys.exit(-2)
if options.test:
xdelays = list(range(0, 32, 2)) # 16 even delay values, [0, 2, 4, ..., 28, 30]
ydelays = list(range(1, 33, 2)) # 16 even delay values, [1, 3, 5, ..., 29, 31]
outstring = gen_bitstring(xdelays, ydelays)
while True:
for bfnum in range(1, 9):
temp, flags = send_bitstring(bfnum, outstring)
logger.info("bf %d bitstring sent, return flags=%d, temp=%4.1f." % (bfnum, flags, temp))
time.sleep(5)
else:
pcs = PointingSlave(edanum=edanum, tileid=TILEID, clientid=clientname, port=SLAVEPORT)
pcs.startup()
time.sleep(1)
while True:
time.sleep(10)
| StarcoderdataPython |
4809198 | # Copyright 2018 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import datetime
import logging
import os
import subprocess
import sys
import threading
import time
class TestWorkerThread(threading.Thread):
"""Runs ./test.py for a given (test, host) pair."""
def __init__(self, test, host, testPy, testPyArgs, errorLogsDir, callback):
if callback is None:
raise TypeError("`callback` cannot be None.")
threading.Thread.__init__(self)
self.daemon = True
self.test = test
self.host = host
self._testPy = testPy
self._testPyArgs = testPyArgs
self._errorLogsDir = errorLogsDir
self._callback = callback
def run(self):
cmd = [
'python', self._testPy, '--test', self.test, '--host', self.host,
'--cleanup'
]
if self._testPyArgs != None:
cmd += self._testPyArgs.split()
if self._errorLogsDir != None:
cmd += ['--error_logs_dir', os.path.join(self._errorLogsDir, self.test)]
# Pass down the current verbosity to ./test.py
level = logging.getLogger().getEffectiveLevel()
if level == logging.WARNING:
cmd += ['-v', '-1']
elif level == logging.INFO:
cmd += ['-v', '0']
elif level == logging.DEBUG:
cmd += ['-v', '1']
logging.info("Running command %s" % cmd)
success = False
details = []
try:
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
success = True
# Relevant output will be formatted by MultiTestController._PrintResult.
logging.debug("Command %s succeeded." % cmd)
details = self._ParseOutputForTestDetails(output)
except subprocess.CalledProcessError as e:
# Full output will be formatted by MultiTestController._PrintResult.
logging.debug("Failed %s failed." % cmd)
details = e.output.splitlines()
finally:
self._callback(self, success, details)
def _ParseOutputForTestDetails(self, output):
details = []
for line in output.splitlines():
if line.startswith("PASSED") or line.startswith("FAILED"):
details.append(line)
return details
class DisplayProgressThread(threading.Thread):
"""Prints and refreshed the current progress of a test run."""
def __init__(self, controller, interval=2):
"""Initializes the DisplayProgress thread.
Args:
controller: The controller from which to gather progress information.
interval: The refresh interval at which the thread will update stdout.
"""
threading.Thread.__init__(self)
self.daemon = True
self._controller = controller
self._interval = interval
self._abort = False
self._completedEvent = threading.Event()
def run(self):
c = self._controller
while not self._abort:
# It's possible to temporarily double-count a test that still has an
# active thread and just updated the _totalX value. This is not critical
# and just an FYI for users so it doesn't matter.
completed = c._totalTestsFailed + c._totalTestsPassed
running = len(c._activeTestThreads)
left = len(c._testsToRun) - completed - running
message = "%s tests running, %s left." % (running, left)
now = datetime.datetime.now().strftime('%H:%M:%S')
with c._printLock:
sys.stdout.write("[%s] %s\r" % (now, message))
sys.stdout.flush()
time.sleep(self._interval)
self._completedEvent.set()
def Stop(self):
"""Stops the run() loop and clears the last progress trace."""
self._abort = True
# Wait for the final run() iteration to finish
self._completedEvent.wait(self._interval * 2)
# Clear the current line (only has text if it's the progress line)
with self._controller._printLock:
sys.stdout.write("%s\r" % (' ' * 80))
sys.stdout.flush()
| StarcoderdataPython |
4835856 | <filename>pytorch/utils/util.py
import numpy as np
import torch
import torch.distributed as dist
from sklearn.metrics import confusion_matrix
class AverageMeter(object):
"""Computes and stores the average and current value"""
def __init__(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def accuracy(output, target, topk=(1,)):
"""Computes the accuracy over the k top predictions for the specified values of k"""
with torch.no_grad():
maxk = max(topk)
batch_size = target.size(0)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
res.append(correct_k.mul_(1.0 / batch_size))
return res
def reduce_tensor(tensor):
rt = tensor.clone()
dist.all_reduce(rt, op=dist.ReduceOp.SUM)
rt /= dist.get_world_size()
return rt
def partnet_metrics(num_classes, num_parts, objects, preds, targets):
"""
Args:
num_classes:
num_parts:
objects: [int]
preds:[(num_parts,num_points)]
targets: [(num_points)]
Returns:
"""
shape_iou_tot = [0.0] * num_classes
shape_iou_cnt = [0] * num_classes
part_intersect = [np.zeros((num_parts[o_l]), dtype=np.float32) for o_l in range(num_classes)]
part_union = [np.zeros((num_parts[o_l]), dtype=np.float32) + 1e-6 for o_l in range(num_classes)]
for obj, cur_pred, cur_gt in zip(objects, preds, targets):
cur_num_parts = num_parts[obj]
cur_pred = np.argmax(cur_pred[1:, :], axis=0) + 1
cur_pred[cur_gt == 0] = 0
cur_shape_iou_tot = 0.0
cur_shape_iou_cnt = 0
for j in range(1, cur_num_parts):
cur_gt_mask = (cur_gt == j)
cur_pred_mask = (cur_pred == j)
has_gt = (np.sum(cur_gt_mask) > 0)
has_pred = (np.sum(cur_pred_mask) > 0)
if has_gt or has_pred:
intersect = np.sum(cur_gt_mask & cur_pred_mask)
union = np.sum(cur_gt_mask | cur_pred_mask)
iou = intersect / union
cur_shape_iou_tot += iou
cur_shape_iou_cnt += 1
part_intersect[obj][j] += intersect
part_union[obj][j] += union
if cur_shape_iou_cnt > 0:
cur_shape_miou = cur_shape_iou_tot / cur_shape_iou_cnt
shape_iou_tot[obj] += cur_shape_miou
shape_iou_cnt[obj] += 1
msIoU = [shape_iou_tot[o_l] / shape_iou_cnt[o_l] for o_l in range(num_classes)]
part_iou = [np.divide(part_intersect[o_l][1:], part_union[o_l][1:]) for o_l in range(num_classes)]
mpIoU = [np.mean(part_iou[o_l]) for o_l in range(num_classes)]
# Print instance mean
mmsIoU = np.mean(np.array(msIoU))
mmpIoU = np.mean(mpIoU)
return msIoU, mpIoU, mmsIoU, mmpIoU
def IoU_from_confusions(confusions):
"""
Computes IoU from confusion matrices.
:param confusions: ([..., n_c, n_c] np.int32). Can be any dimension, the confusion matrices should be described by
the last axes. n_c = number of classes
:param ignore_unclassified: (bool). True if the the first class should be ignored in the results
:return: ([..., n_c] np.float32) IoU score
"""
# Compute TP, FP, FN. This assume that the second to last axis counts the truths (like the first axis of a
# confusion matrix), and that the last axis counts the predictions (like the second axis of a confusion matrix)
TP = np.diagonal(confusions, axis1=-2, axis2=-1)
TP_plus_FN = np.sum(confusions, axis=-1)
TP_plus_FP = np.sum(confusions, axis=-2)
# Compute IoU
IoU = TP / (TP_plus_FP + TP_plus_FN - TP + 1e-6)
# Compute mIoU with only the actual classes
mask = TP_plus_FN < 1e-3
counts = np.sum(1 - mask, axis=-1, keepdims=True)
mIoU = np.sum(IoU, axis=-1, keepdims=True) / (counts + 1e-6)
# If class is absent, place mIoU in place of 0 IoU to get the actual mean later
IoU += mask * mIoU
return IoU
def s3dis_metrics(num_classes, vote_logits, validation_proj, validation_labels):
Confs = []
for logits, proj, targets in zip(vote_logits, validation_proj, validation_labels):
preds = np.argmax(logits[:, proj], axis=0).astype(np.int32)
Confs += [confusion_matrix(targets, preds, np.arange(num_classes))]
# Regroup confusions
C = np.sum(np.stack(Confs), axis=0)
IoUs = IoU_from_confusions(C)
mIoU = np.mean(IoUs)
return IoUs, mIoU
def sub_s3dis_metrics(num_classes, validation_logits, validation_labels, val_proportions):
Confs = []
for logits, targets in zip(validation_logits, validation_labels):
preds = np.argmax(logits, axis=0).astype(np.int32)
Confs += [confusion_matrix(targets, preds, np.arange(num_classes))]
# Regroup confusions
C = np.sum(np.stack(Confs), axis=0).astype(np.float32)
# Rescale with the right number of point per class
C *= np.expand_dims(val_proportions / (np.sum(C, axis=1) + 1e-6), 1)
IoUs = IoU_from_confusions(C)
mIoU = np.mean(IoUs)
return IoUs, mIoU
def s3dis_part_metrics(num_classes, predictions, targets, val_proportions):
# Confusions for subparts of validation set
Confs = np.zeros((len(predictions), num_classes, num_classes), dtype=np.int32)
for i, (probs, truth) in enumerate(zip(predictions, targets)):
# Predicted labels
preds = np.argmax(probs, axis=0)
# Confusions
Confs[i, :, :] = confusion_matrix(truth, preds, np.arange(num_classes))
# Sum all confusions
C = np.sum(Confs, axis=0).astype(np.float32)
# Balance with real validation proportions
C *= np.expand_dims(val_proportions / (np.sum(C, axis=1) + 1e-6), 1)
# Objects IoU
IoUs = IoU_from_confusions(C)
# Print instance mean
mIoU = np.mean(IoUs)
return IoUs, mIoU
| StarcoderdataPython |
1623894 | # flake8: noqa
from .authorization_server import AuthorizationServer
from .resource_protector import ResourceProtector, current_credential
| StarcoderdataPython |
1782460 |
import bpy
from bpy import data as D
from bpy import context as C
from mathutils import *
from math import *
st = D.texts['shaderTrees.py'].as_module()
mat=st.Material(name='test')
mat.p4 = {
'KdColor': [1.0, 1.0, 1.0, 1.0],
'KaColor': [0.0, 0.0, 0.0, 0.0],
'KsColor': [0.0, 0.0, 0.0, 1.0],
'TextureColor': [1.0, 1.0, 1.0, 1.0],
'NsExponent': [50],
'tMin': [0.0],
'tMax': [0.0],
'tExpo': [0.6],
'bumpStrength': [1.0],
'ksIgnoreTexture': [0.0],
'reflectThruLights': [0.0],
'reflectThruKd': [0.0],
'textureMap': 'NO_MAP',
'bumpMap': 'NO_MAP',
'reflectionMap': 'NO_MAP',
'transparencyMap': 'NO_MAP',
'ReflectionColor': [1.0, 1.0, 1.0, 1.0],
'reflectionStrength': [0.0]
}
mat.write(depth=0)
bpy.context.object.active_material
for mat in C.active_object.material_slots:
print(mat.name)
for node in D.materials[mat.name].node_tree.nodes:
print('\t', node.type, node.name )
print('Done')
| StarcoderdataPython |
175337 | <filename>tests/qalpha_test.py
# Copyright 2020 Google LLC
#
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Test get_weight_scale function with auto and auto_po2 modes of quantizers.py."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import logging
from numpy.testing import assert_allclose
import pytest
from tensorflow.keras import backend as K
from qkeras import binary
from qkeras import get_weight_scale
from qkeras import ternary
# expected value if input is uniform distribution is:
# - alpha = m/2.0 for binary
# - alpha = (m+d)/2.0 for ternary
def test_binary_auto():
"""Test binary auto scale quantizer."""
np.random.seed(42)
N = 1000000
m_list = [1.0, 0.1, 0.01, 0.001]
for m in m_list:
x = np.random.uniform(-m, m, (N, 10)).astype(K.floatx())
x = K.constant(x)
quantizer = binary(alpha="auto")
q = K.eval(quantizer(x))
result = get_weight_scale(quantizer, q)
expected = m / 2.0
logging.info("expect %s", expected)
logging.info("result %s", result)
assert_allclose(result, expected, rtol=0.02)
def test_binary_auto_po2():
"""Test binary auto_po2 scale quantizer."""
np.random.seed(42)
N = 1000000
m_list = [1.0, 0.1, 0.01, 0.001]
for m in m_list:
x = np.random.uniform(-m, m, (N, 10)).astype(K.floatx())
x = K.constant(x)
quantizer_ref = binary(alpha="auto")
quantizer = binary(alpha="auto_po2")
q_ref = K.eval(quantizer_ref(x))
q = K.eval(quantizer(x))
ref = get_weight_scale(quantizer_ref, q_ref)
expected = np.power(2.0, np.round(np.log2(ref)))
result = get_weight_scale(quantizer, q)
assert_allclose(result, expected, rtol=0.0001)
def test_ternary_auto():
"""Test ternary auto scale quantizer."""
np.random.seed(42)
N = 1000000
m_list = [1.0, 0.1, 0.01, 0.001]
for m in m_list:
x = np.random.uniform(-m, m, (N, 10)).astype(K.floatx())
x = K.constant(x)
quantizer = ternary(alpha="auto")
q = K.eval(quantizer(x))
d = m/3.0
result = np.mean(get_weight_scale(quantizer, q))
expected = (m + d) / 2.0
assert_allclose(result, expected, rtol=0.02)
def test_ternary_auto_po2():
"""Test ternary auto_po2 scale quantizer."""
np.random.seed(42)
N = 1000000
m_list = [1.0, 0.1, 0.01, 0.001]
for m in m_list:
x = np.random.uniform(-m, m, (N, 10)).astype(K.floatx())
x = K.constant(x)
quantizer_ref = ternary(alpha="auto")
quantizer = ternary(alpha="auto_po2")
q_ref = K.eval(quantizer_ref(x))
q = K.eval(quantizer(x))
ref = get_weight_scale(quantizer_ref, q_ref)
expected = np.power(2.0, np.round(np.log2(ref)))
result = get_weight_scale(quantizer, q)
assert_allclose(result, expected, rtol=0.0001)
if __name__ == "__main__":
pytest.main([__file__])
| StarcoderdataPython |
1752836 | from __future__ import absolute_import, division, print_function
import inspect
import sys
from cfn_model.parser.PolicyDocumentParser import PolicyDocumentParser
from cfn_model.model.Policy import Policy
def lineno():
"""Returns the current line number in our program."""
return str(' - IamUserParser- line number: '+str(inspect.currentframe().f_back.f_lineno))
class IamUserParser:
"""
IAM User Parser
"""
@staticmethod
def parse(cfn_model, resource, debug=False):
"""
Parse iam user
:param resource:
:param debug:
:return:
"""
if debug:
print('parse'+lineno())
iam_user = resource
for policy in iam_user.policies:
if debug:
print('policy: '+str(policy)+lineno())
new_policy = Policy(debug=debug)
new_policy.policy_name = policy['PolicyName']
policy_document_parser =PolicyDocumentParser()
new_policy.policy_document=policy_document_parser.parse(policy['PolicyDocument'])
iam_user.policy_objects.append(new_policy)
for group_name in iam_user.groups:
if debug:
print('group_name: '+str(group_name)+lineno())
iam_user.group_names.append(group_name)
user_to_group_additions = cfn_model.resources_by_type('AWS::IAM::UserToGroupAddition')
if debug:
print('user_to_group_additions: '+str(user_to_group_additions)+lineno())
for user_to_group_addition in user_to_group_additions:
if IamUserParser.user_to_group_addition_has_username(user_to_group_addition.users,iam_user,debug=debug):
iam_user.group_names = user_to_group_addition.groupName
# # we need to figure out the story on resolving Refs i think for this to be real
return iam_user
def user_to_group_addition_has_username(addition_user_names, user_to_find, debug=False):
"""
???
:param user_to_find:
:param debug:
:return:
"""
if debug:
print('user_to_group_addition_has_username'+lineno())
print('user names: '+str(addition_user_names)+lineno())
print('user to find: '+str(user_to_find)+lineno())
for addition_user_name in addition_user_names:
if debug:
print('vars: '+str(vars(user_to_find))+lineno())
if hasattr(user_to_find,'userName'):
if addition_user_name == user_to_find.userName:
return True
if type(addition_user_name) == type(dict()):
if 'Ref' in addition_user_name:
if addition_user_name['Ref'] == user_to_find.logical_resource_id:
return True
return False | StarcoderdataPython |
3375782 | <filename>malinka/test/pwmtest.py
#!/usr/bin/env python
import sys
import time
import codecs
import struct
import sched
from threading import Timer
# import pigpio
from malinka.pwm.pigpioclock import Clock
#pi1 = pigpio.pi() # pi1 accesses the local Pi's gpios
clk = Clock(None)
s = sched.scheduler(time.time, time.sleep)
def print_time():
print "From print_time", time.time()
Timer(0.1, print_time, ()).start()
def print_some_times():
print time.time()
Timer(1, print_time, ()).start()
print time.time()
print_some_times()
# clk.set_hour(1)
# clk.debug_on = True
#
# delay = 1
# for k in range(10):
# for i in range(12):
# clk.set_hour(i)
# time.sleep(delay)
# for j in reversed(range(12)):
# clk.set_hour(j)
# time.sleep(delay)
#
# pi1.write(4, 0) # set gpio 4 low
# print pi1.read(4)
# pi1.write(4, 1) # set gpio 4 to high
# print pi1.read(4) # get level of gpio 4
| StarcoderdataPython |
45600 | import unittest
import tempfile
import numpy as np
import coremltools
import os
import shutil
import tensorflow as tf
from tensorflow.keras import backend as _keras
from tensorflow.keras import layers
from coremltools._deps import HAS_TF_2
from test_utils import generate_data, tf_transpose
class TensorFlowKerasTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
tf.keras.backend.set_learning_phase(False)
def setUp(self):
self.saved_model_dir = tempfile.mkdtemp()
_, self.model_file = tempfile.mkstemp(suffix='.h5', prefix=self.saved_model_dir)
def tearDown(self):
if os.path.exists(self.saved_model_dir):
shutil.rmtree(self.saved_model_dir)
def _get_tf_tensor_name(self, graph, name):
return graph.get_operation_by_name(name).outputs[0].name
def _test_model(self, model, data_mode='random_zero_mean', decimal=4, use_cpu_only=False, has_variables=True, verbose=False):
if not HAS_TF_2:
self._test_keras_model_tf1(model, data_mode, decimal, use_cpu_only, has_variables, verbose)
else:
self._test_keras_model_tf2(model, data_mode, decimal, use_cpu_only, has_variables, verbose)
def _test_keras_model_tf1(self, model, data_mode, decimal, use_cpu_only, has_variables, verbose):
graph_def_file = os.path.join(self.saved_model_dir, 'graph.pb')
frozen_model_file = os.path.join(self.saved_model_dir, 'frozen.pb')
core_ml_model_file = os.path.join(self.saved_model_dir, 'model.mlmodel')
input_shapes = {inp.op.name: inp.shape.as_list() for inp in model.inputs}
for name, shape in input_shapes.items():
input_shapes[name] = [dim if dim is not None else 1 for dim in shape]
output_node_names = [output.op.name for output in model.outputs]
tf_graph = _keras.get_session().graph
tf.reset_default_graph()
if has_variables:
with tf_graph.as_default():
saver = tf.train.Saver()
# note: if Keras backend has_variable is False, we're not making variables constant
with tf.Session(graph=tf_graph) as sess:
sess.run(tf.global_variables_initializer())
feed_dict = {}
for name, shape in input_shapes.items():
tensor_name = tf_graph.get_operation_by_name(name).outputs[0].name
feed_dict[tensor_name] = generate_data(shape, data_mode)
# run the result
fetches = [
tf_graph.get_operation_by_name(name).outputs[0] for name in output_node_names
]
result = sess.run(fetches, feed_dict=feed_dict)
# save graph definition somewhere
tf.train.write_graph(sess.graph, self.saved_model_dir, graph_def_file, as_text=False)
# freeze_graph() has been raising error with tf.keras models since no
# later than TensorFlow 1.6, so we're not using freeze_graph() here.
# See: https://github.com/tensorflow/models/issues/5387
output_graph_def = tf.graph_util.convert_variables_to_constants(
sess, # The session is used to retrieve the weights
tf_graph.as_graph_def(), # The graph_def is used to retrieve the nodes
output_node_names # The output node names are used to select the useful nodes
)
with tf.gfile.GFile(frozen_model_file, 'wb') as f:
f.write(output_graph_def.SerializeToString())
_keras.clear_session()
# convert to Core ML model format
core_ml_model = coremltools.converters.tensorflow.convert(
frozen_model_file,
inputs=input_shapes,
outputs=output_node_names,
use_cpu_only=use_cpu_only)
if verbose:
print('\nFrozen model saved at {}'.format(frozen_model_file))
print('\nCore ML model description:')
from coremltools.models.neural_network.printer import print_network_spec
print_network_spec(core_ml_model.get_spec(), style='coding')
core_ml_model.save(core_ml_model_file)
print('\nCore ML model saved at {}'.format(core_ml_model_file))
# transpose input data as Core ML requires
core_ml_inputs = {
name: tf_transpose(feed_dict[self._get_tf_tensor_name(tf_graph, name)])
for name in input_shapes
}
# run prediction in Core ML
core_ml_output = core_ml_model.predict(core_ml_inputs, useCPUOnly=use_cpu_only)
for idx, out_name in enumerate(output_node_names):
tf_out = result[idx]
if len(tf_out.shape) == 0:
tf_out = np.array([tf_out])
tp = tf_out.flatten()
coreml_out = core_ml_output[out_name]
cp = coreml_out.flatten()
self.assertTrue(tf_out.shape == coreml_out.shape)
for i in range(len(tp)):
max_den = max(1.0, tp[i], cp[i])
self.assertAlmostEqual(tp[i] / max_den, cp[i] / max_den, delta=10 ** -decimal)
def _test_keras_model_tf2(self, model, data_mode, decimal, use_cpu_only, has_variables, verbose):
core_ml_model_file = self.model_file.rsplit('.')[0] + '.mlmodel'
input_dict = {inp.op.name: inp.shape.as_list() for inp in model.inputs}
for name, shape in input_dict.items():
input_dict[name] = [dim if dim is not None else 1 for dim in shape]
output_list = ['Identity']
model.save(self.model_file)
# convert Keras model into Core ML model format
core_ml_model = coremltools.converters.tensorflow.convert(
filename=self.model_file,
inputs=input_dict,
outputs=output_list,
use_cpu_only=use_cpu_only)
if verbose:
print('\nKeras model saved at {}'.format(self.model_file))
print('\nCore ML model description:')
from coremltools.models.neural_network.printer import print_network_spec
print_network_spec(core_ml_model.get_spec(), style='coding')
core_ml_model.save(core_ml_model_file)
print('\nCore ML model saved at {}'.format(core_ml_model_file))
core_ml_inputs = {
name: generate_data(shape, data_mode) for name, shape in input_dict.items()
}
# run prediction and compare results
keras_output = model.predict(list(core_ml_inputs.values())[0])
core_ml_output = core_ml_model.predict(
core_ml_inputs, useCPUOnly=use_cpu_only)[output_list[0]]
if verbose:
print('\nPredictions', keras_output.shape, ' vs.', core_ml_output.shape)
print(keras_output.flatten()[:6])
print(core_ml_output.flatten()[:6])
np.testing.assert_array_equal(
keras_output.shape, core_ml_output.shape)
np.testing.assert_almost_equal(
keras_output.flatten(), core_ml_output.flatten(), decimal=decimal)
class SimpleLayerTests(TensorFlowKerasTests):
def test_dense_softmax(self):
model = tf.keras.Sequential()
model.add(layers.Dense(16, input_shape=(16,), activation=tf.nn.softmax))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
def test_dense_elu(self):
model = tf.keras.Sequential()
model.add(layers.Dense(16, input_shape=(16,), activation=tf.nn.elu))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model, decimal=2)
def test_dense_tanh(self):
model = tf.keras.Sequential()
model.add(layers.Dense(16, input_shape=(16,), activation=tf.nn.tanh))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
def test_housenet_random(self):
num_hidden = 2
num_features = 3
model = tf.keras.Sequential()
model.add(layers.Dense(num_hidden, input_dim=num_features))
model.add(layers.Activation(tf.nn.relu))
model.add(layers.Dense(1, input_dim=num_features))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
def test_tiny_conv2d_random(self):
input_dim = 10
input_shape = (input_dim, input_dim, 1)
num_kernels, kernel_height, kernel_width = 3, 5, 5
model = tf.keras.Sequential()
model.add(layers.Conv2D(
input_shape=input_shape,
filters=num_kernels, kernel_size=(kernel_height, kernel_width)))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
def test_tiny_conv2d_dilated_random(self):
input_dim = 10
input_shape = (input_dim, input_dim, 1)
num_kernels, kernel_height, kernel_width = 3, 5, 5
model = tf.keras.Sequential()
model.add(layers.Conv2D(
input_shape=input_shape, dilation_rate=(2, 2),
filters=num_kernels, kernel_size=(kernel_height, kernel_width)))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
def test_tiny_conv1d_same_random(self):
input_dim = 2
input_length = 10
filter_length = 3
nb_filters = 4
model = tf.keras.Sequential()
model.add(layers.Conv1D(
nb_filters, kernel_size=filter_length, padding='same',
input_shape=(input_length, input_dim)))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
def test_tiny_conv1d_valid_random(self):
input_dim = 2
input_length = 10
filter_length = 3
nb_filters = 4
model = tf.keras.Sequential()
model.add(layers.Conv1D(
nb_filters, kernel_size=filter_length, padding='valid',
input_shape=(input_length, input_dim)))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
@unittest.skip('non-equal block shape is not yet supported')
def test_tiny_conv1d_dilated_random(self):
input_shape = (20, 1)
num_kernels = 2
filter_length = 3
model = tf.keras.Sequential()
model.add(layers.Conv1D(
num_kernels, kernel_size=filter_length, padding='valid',
input_shape=input_shape, dilation_rate=3))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
def test_flatten(self):
model = tf.keras.Sequential()
model.add(layers.Flatten(input_shape=(2, 2, 2)))
self._test_model(model, data_mode='linear', has_variables=False)
def test_conv_dense(self):
input_shape = (48, 48, 3)
model = tf.keras.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation=tf.nn.relu, input_shape=input_shape))
model.add(layers.Flatten())
model.add(layers.Dense(10, activation=tf.nn.softmax))
self._test_model(model)
def test_conv_batchnorm_random(self):
input_dim = 10
input_shape = (input_dim, input_dim, 3)
num_kernels = 3
kernel_height = 5
kernel_width = 5
model = tf.keras.Sequential()
model.add(layers.Conv2D(
input_shape=input_shape,
filters=num_kernels,
kernel_size=(kernel_height, kernel_width)))
model.add(layers.BatchNormalization(epsilon=1e-5))
model.add(layers.Dense(10, activation=tf.nn.softmax))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model, decimal=2, has_variables=True)
@unittest.skip('list index out of range')
def test_tiny_deconv_random(self):
input_dim = 13
input_shape = (input_dim, input_dim, 5)
num_kernels = 16
kernel_height = 3
kernel_width = 3
model = tf.keras.Sequential()
model.add(layers.Conv2DTranspose(
filters=num_kernels,
kernel_size=(kernel_height, kernel_width),
input_shape=input_shape, padding='valid', strides=(2, 2)))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
@unittest.skip('Deconvolution layer has weight matrix of size 432 to encode a 3 x 4 x 3 x 3 convolution.')
def test_tiny_deconv_random_same_padding(self):
input_dim = 14
input_shape = (input_dim, input_dim, 3)
num_kernels = 16
kernel_height = 3
kernel_width = 3
model = tf.keras.Sequential()
model.add(layers.Conv2DTranspose(
filters=num_kernels,
kernel_size=(kernel_height, kernel_width),
input_shape=input_shape, padding='same', strides=(2, 2)))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
def test_tiny_depthwise_conv_same_pad_depth_multiplier(self):
input_dim = 16
input_shape = (input_dim, input_dim, 3)
depth_multiplier = 4
kernel_height = 3
kernel_width = 3
model = tf.keras.Sequential()
model.add(layers.DepthwiseConv2D(
depth_multiplier=depth_multiplier,
kernel_size=(kernel_height, kernel_width),
input_shape=input_shape, padding='same', strides=(1, 1)))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
def test_tiny_depthwise_conv_valid_pad_depth_multiplier(self):
input_dim = 16
input_shape = (input_dim, input_dim, 3)
depth_multiplier = 2
kernel_height = 3
kernel_width = 3
model = tf.keras.Sequential()
model.add(layers.DepthwiseConv2D(
depth_multiplier=depth_multiplier,
kernel_size=(kernel_height, kernel_width),
input_shape=input_shape, padding='valid', strides=(1, 1)))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model)
def test_tiny_separable_conv_valid_depth_multiplier(self):
input_dim = 16
input_shape = (input_dim, input_dim, 3)
depth_multiplier = 5
kernel_height = 3
kernel_width = 3
num_kernels = 40
model = tf.keras.Sequential()
model.add(layers.SeparableConv2D(
filters=num_kernels, kernel_size=(kernel_height, kernel_width),
padding='valid', strides=(1, 1), depth_multiplier=depth_multiplier,
input_shape=input_shape))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model, decimal=2)
def test_tiny_separable_conv_same_fancy_depth_multiplier(self):
input_dim = 16
input_shape = (input_dim, input_dim, 3)
depth_multiplier = 2
kernel_height = 3
kernel_width = 3
num_kernels = 40
model = tf.keras.Sequential()
model.add(layers.SeparableConv2D(
filters=num_kernels, kernel_size=(kernel_height, kernel_width),
padding='same', strides=(2, 2), activation='relu', depth_multiplier=depth_multiplier,
input_shape=input_shape))
model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()])
self._test_model(model, decimal=2)
def test_max_pooling_no_overlap(self):
# no_overlap: pool_size = strides
model = tf.keras.Sequential()
model.add(layers.MaxPooling2D(
input_shape=(16, 16, 3), pool_size=(2, 2),
strides=None, padding='valid'))
self._test_model(model, has_variables=False)
def test_max_pooling_overlap_multiple(self):
# input shape is multiple of pool_size, strides != pool_size
model = tf.keras.Sequential()
model.add(layers.MaxPooling2D(
input_shape=(18, 18, 3), pool_size=(3, 3),
strides=(2, 2), padding='valid'))
self._test_model(model, has_variables=False)
def test_max_pooling_overlap_odd(self):
model = tf.keras.Sequential()
model.add(layers.MaxPooling2D(
input_shape=(16, 16, 3), pool_size=(3, 3),
strides=(2, 2), padding='valid'))
self._test_model(model, has_variables=False)
def test_max_pooling_overlap_same(self):
model = tf.keras.Sequential()
model.add(layers.MaxPooling2D(
input_shape=(16, 16, 3), pool_size=(3, 3),
strides=(2, 2), padding='same'))
self._test_model(model, has_variables=False)
def test_global_max_pooling_2d(self):
model = tf.keras.Sequential()
model.add(layers.GlobalMaxPooling2D(input_shape=(16, 16, 3)))
self._test_model(model, has_variables=False)
def test_global_avg_pooling_2d(self):
model = tf.keras.Sequential()
model.add(layers.GlobalAveragePooling2D(input_shape=(16, 16, 3)))
self._test_model(model, has_variables=False)
def test_max_pooling_1d(self):
model = tf.keras.Sequential()
model.add(layers.MaxPooling1D(input_shape=(16, 3), pool_size=2))
self._test_model(model, has_variables=False)
if __name__ == '__main__':
np.random.seed(1984)
unittest.main()
| StarcoderdataPython |
197415 | from opentuner.resultsdb.models import *
class DriverBase(object):
"""
shared base class between MeasurementDriver and SearchDriver
"""
def __init__(self,
session,
tuning_run,
objective,
tuning_run_main,
args,
**kwargs):
self.args = args
self.objective = objective
self.session = session
self.tuning_run_main = tuning_run_main
self.tuning_run = tuning_run
self.program = tuning_run.program
def results_query(self,
generation=None,
objective_ordered=False,
config=None):
self.session.flush()
q = self.session.query(Result)
q = q.filter_by(tuning_run=self.tuning_run)
if config:
q = q.filter_by(configuration=config)
if generation is not None:
subq = (self.session.query(DesiredResult.result_id)
.filter_by(tuning_run=self.tuning_run,
generation=generation))
q = q.filter(Result.id.in_(subq.subquery()))
if objective_ordered:
q = self.objective.result_order_by(q)
return q
def requests_query(self):
q = self.session.query(DesiredResult).filter_by(tuning_run=self.tuning_run)
return q
| StarcoderdataPython |
1762590 | <filename>clustering_proxy_log/Transform_pcap.py
#HTTP requestのみのDFを作成中 他にHTTP responceのみのDFを作ってackで関連を見る
import dpkt
import pandas as pd
import re
import datetime
import socket
from dpkt.compat import compat_ord
def mac_addr(address):
"""Convert a MAC address to a readable/printable string
Args:
address (str): a MAC address in hex form (e.g. '\x01\x02\x03\x04\x05\x06')
Returns:
str: Printable/readable MAC address
"""
return(':'.join('%02x' % compat_ord(b) for b in address))
def inet_to_str(inet):
"""Convert inet object to a string
Args:
inet (inet struct): inet network address
Returns:
str: Printable/readable IP address
"""
# First try ipv4 and then ipv6
try:
return(socket.inet_ntop(socket.AF_INET, inet))
except ValueError:
return(socket.inet_ntop(socket.AF_INET6, inet))
def Transform_pcap(pcap_file="./D3M_2015/20150208/20150208_marionette.pcap"):
pcap = dpkt.pcap.Reader(open(pcap_file,"rb"))
pd.set_option("display.max_colwidth", 8000)
pd.set_option("display.max_columns", 400)
pd.set_option("display.max_rows", 100)
ind=0#indexナンバーWirreSharkと見比べたりするのに使用
sq_dic={}#パケットからsquid風ログの作成に使うものを保存していく(timestampも一緒に)
pre_sequence_dic={}#現在探しているシーケンス番号を指定したパケットのシーケンス番号
for timestamp, buf in pcap:
ind += 1
# Unpack the Ethernet frame (mac src/dst, ethertype)
eth = dpkt.ethernet.Ethernet(buf)#Ethternetのヘッダとその中身に分ける
# Ethernet形式のdataがIP packetを含場合のみ扱う
if not isinstance(eth.data, dpkt.ip.IP):
#print('Non IP Packet type not supported %s\n' % eth.data.__class__.__name__)
continue
# IP packetはEthernetのdata部分
ip = eth.data
# トランスポート層のプロトコルがTCPである場合のみ扱う
if isinstance(ip.data, dpkt.tcp.TCP):
# Set the TCP data
tcp = ip.data
#if(ind in [1306,1310,1311,1312,1317,1318,1328,1331,1332,1333,1334,1462,1463,1464,1465,1466,1470,1471,1472]):print(ind,tcp.seq,tcp.ack,len(tcp.data),tcp.flags);
#if("data=" in repr(tcp)):print("index : ",ind," ",repr(tcp))
#ここでレスポンスの処理を行う リクエストの次のackをもつ
if(tcp.seq in sq_dic.keys()):
if(sq_dic[tcp.seq]["data"] is None):#該当セッションのレスポンスの頭がまだ見つかっていない場合
if(repr(tcp.data)[0:7] not in["b\"HTTP/","b\'HTTP/"]):#HTTPレスポンスではない場合は探すシーケンス番号をtcp.ack変えて進む
if(sq_dic[tcp.seq]["pre_seq"] in pre_sequence_dic.keys()):del(pre_sequence_dic[sq_dic[tcp.seq]["pre_seq"]])#直前に指定していた番号を削除
sq_dic[tcp.seq]["pre_seq"] = tcp.seq#今のシーケンス番号を直前のシーケンス番号として登録
sq_dic[tcp.ack]=sq_dic[tcp.seq]#次のシーケンス番号待ちに移動
del(sq_dic[tcp.seq])
pre_sequence_dic[tcp.seq]=tcp.ack#次のシーケンスを指定した現在のシーケンス番号を登録
continue
sq_dic[tcp.seq]["found_response"]=True#レスポンスを発見したので変更
header = repr(tcp.data).split("\\r\\n\\r\\n")[0]#ヘッダとボディで分けてヘッダだけ抜き出し
sq_dic[tcp.seq]["status_to_client"] = header.split(" ")[1]#ステータスコードを保存 例:200
#現在はHTTPヘッダも含めてサイズ計算をするのでここはコメントアウト sq_dic[tcp.seq]["data"] = re.search(b"\\r\\n\\r\\n(?P<body>[\s\S]*)",tcp.data)["body"]#HTTPリクエストの最初はヘッダを含むのでそこ以外をsq_dic[tcp.seq]["data"]として追加
sq_dic[tcp.seq]["data"] = tcp.data#TCPパケットのペイロードを得るためにsq_dic[tcp.seq]["data"]として追加
#print(sq_dic[tcp.seq]["index"]," : ",tcp.seq)#," : ",sq_dic[tcp.seq]["size_of_reply"],"\n ",sq_dic[tcp.seq]["data"])#Content-Lengthが記載されていない場合はそれを表示
sq_dic[tcp.seq]["Chunked"] = b"Transfer-Encoding: chunked" in tcp.data
else:#レスポンスの続きパケットだった場合
sq_dic[tcp.seq]["data"] += tcp.data#パケットの全体がbodyなのでdataの後ろに連結
if(len(tcp.data)==0):continue;#tcp.dataが0になったら終わり
sq_dic[tcp.seq]["index"].append(ind)
sq_dic[tcp.seq]["timestamp"].append(timestamp)#関連パケットのtimestampを追加していく
sq_dic[tcp.seq+len(tcp.data)]=sq_dic[tcp.seq]#レスポンスの続きのシーケンス番号に移動
if(sq_dic[tcp.seq]["pre_seq"] in pre_sequence_dic.keys()):del(pre_sequence_dic[sq_dic[tcp.seq]["pre_seq"]])
del(sq_dic[tcp.seq])#移動元の要素を削除
pre_sequence_dic[tcp.seq] = tcp.seq+len(tcp.data)
continue#レスポンスの処理終了
elif(tcp.seq in pre_sequence_dic.keys() and tcp.ack == pre_sequence_dic[tcp.seq]):#今のパケットのシーケンス番号が前のパケットと同じかつ、ackが等しい場合
if(repr(tcp.data)[0:7] in["b\"HTTP/","b\'HTTP/"]):#HTTPレスポンスだった場合は探すシーケンス番号を更新して進む
sq_dic[tcp.ack]["timestamp"].append(timestamp)#関連パケットのtimestampを追加していく
sq_dic[tcp.ack]["index"].append(ind)
sq_dic[tcp.ack]["found_response"] = True#レスポンスを発見
header = repr(tcp.data).split("\\r\\n\\r\\n")[0]#ヘッダとボディで分けてヘッダだけ抜き出し
sq_dic[tcp.ack]["status_to_client"] = header.split(" ")[1]#ステータスコードを保存 例:200
sq_dic[tcp.ack]["data"] = tcp.data#TCPパケットのペイロードを得るためにsq_dic[tcp.seq]["data"]として追加
#print(sq_dic[tcp.ack]["index"]," : ",tcp.seq)#," : ",sq_dic[tcp.seq]["size_of_reply"],"\n ",sq_dic[tcp.seq]["data"])#Content-Lengthが記載されていない場合はそれを表示
sq_dic[tcp.ack]["Chunked"] = b"Transfer-Encoding: chunked" in tcp.data#chunkedかのチェック
del(pre_sequence_dic[tcp.seq])#直前に指定していた番号を削除
sq_dic[tcp.ack]["pre_seq"] = tcp.ack#今のシーケンス番号を直前のシーケンス番号として登録
sq_dic[tcp.seq+len(tcp.data)]=sq_dic[tcp.ack]#次のシーケンス番号に移動
pre_sequence_dic[tcp.ack]=tcp.seq+len(tcp.data)#次のシーケンスを指定した現在のシーケンス番号を登録
del(sq_dic[tcp.ack])#移動元の要素を削除
continue#レスポンスの処理終了
# HTTPのリクエストのみ抜き出していく
try:
request = dpkt.http.Request(tcp.data)#リクエスト形式だった場合
except (dpkt.dpkt.NeedData, dpkt.dpkt.UnpackError):#その他の場合
continue#レスポンスでもリクエストでもないものはスルー
#リクエスト
if("referer"not in request.headers.keys()):request.headers["referer"]="-"#refererの情報が無かったら"-"で置き換え
#reqから抽出できるものをsq_dicに突っ込む
# print("index : ",ind," ack : ",tcp.ack," next ack : ",tcp.seq+len(tcp.data))#ackの確認
if("host"not in request.headers.keys()):request.headers["host"]=""#hostを入れずにGetを投げる例があったのでエラーの回避
sq_dic[tcp.ack] = {"found_response":False,"timestamp":[timestamp],"response_time":None,"client_ip":inet_to_str(ip.src),
"port":tcp.sport,"request_status":None,"status_to_client":None,"size_of_reply":None,
"request_method":request.method,"url_from_client":"http://"+request.headers["host"]+request.uri,
"server_ip":inet_to_str(ip.dst),"user_name":None,"hierarchy_status":None,
"server_peer_name":request.headers["host"],"Referer":request.headers["referer"],
"User_Agent":request.headers["user-agent"],"data":None,"index":[ind],"Chunked":False,"pre_seq":None}
#レスポンスのシーケンス番号を鍵として(timestamp,ステータスコード,content_length)を保存,
#found_responseで対応するレスポンスを発見したか判断
#print(sq_dic.keys())
#データの連結が終わったのでそのサイズを測る
for key in sq_dic.keys():
if(not sq_dic[key]["found_response"]):continue#レスポンスを見つけられなかった場合はとばす
#if(sq_dic[key]["size_of_reply"]is None):print(sq_dic[key]["index"]," : ",key," : ",sq_dic[key]["size_of_reply"],"\n ")
if(len(sq_dic[key]["index"])==1):print(sq_dic[key])
sq_dic[key]["size_of_reply"]=len(sq_dic[key]["data"])
sq_dic[key]["response_time"] = int((sq_dic[key]["timestamp"][-1]-sq_dic[key]["timestamp"][0])*1000)
sq_dic[key]["timestamp"]=[sq_dic[key]["timestamp"][0],sq_dic[key]["timestamp"][-1]]
#if(sq_dic[key]["size_of_reply"] is None):print(sq_dic[key])
squid_DF = pd.DataFrame([list(sq_dic[key].values()) for key in list(sq_dic.keys())],columns=list(sq_dic[key].keys()))
return squid_DF#[squid_DF["Chunked"]==True] | StarcoderdataPython |
1624471 | """
The MIT License (MIT)
Copyright (c) 2020 <NAME>.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
import logging
import openpyxl
from openpyxl.styles import PatternFill
from openpyxl.formula import Tokenizer
from openpyxl.utils.cell import column_index_from_string
import pprint
import re
def compareXl(wb1 : openpyxl.Workbook, wb2 : openpyxl.Workbook):
"""
Compare
Compare any two versions having same template and collection unit
Workbook should be opened with data_only = False
Parameters
----------------------
wb1 : Workbook
Workbook to be comared
wb2 : Workbook
Target Workbook
Returns
----------------------
Workbook with highliting changes : Workbook
"""
logging.info('Function {} starts'.format('compareXl'))
wb1data = analyzeWorkbook(wb1)
wb2data = analyzeWorkbook(wb2)
changedCells = []
formulaCells = []
for sheetname in wb1data.keys():
wb1cells = wb1data[sheetname]
wb2cells = wb2data[sheetname]
for coordinate in wb1cells.keys():
wb1val = wb1[sheetname][coordinate].value
if str(wb1val).startswith('='):
formulaCells.append({'sheet' : sheetname, 'cell' : coordinate, 'value' : wb1val})
if wb1cells[coordinate] != wb2cells[coordinate]:
changedCells.append({'sheet' : sheetname, 'cell' : coordinate})
logging.info('changed cells')
logging.info(pprint.pformat(changedCells))
logging.info('formulas')
logging.info(pprint.pformat(formulaCells))
# find cells referencing changedCells recursively
changedCells = findRefs(changedCells,formulaCells)
# Highlight Changes
for change in changedCells:
changedSheet = change['sheet']
chengedCordinate = change['cell']
fill = PatternFill(patternType='solid', fgColor='0000ff')
wb1[changedSheet][chengedCordinate].fill = fill
logging.info('Function {} ends'.format('compareXl'))
return wb1
def findRefs(changes, formulas):
logging.info('Function {} starts'.format('findRefs'))
logging.info('{} changes'.format(len(changes)))
logging.info('{} formulas'.format(len(formulas)))
# Check changed cell is in formulacell
# if found, move formula cell into changes and call this func recursively
# If no changes are referenced by formula, this func returns changes
for change in changes:
for formula in formulas:
if isReferenced(change,formula):
formulas.remove(formula)
changes.append(formula)
findRefs(changes,formulas)
logging.info('Function {} ends'.format('findRefs'))
return changes
def isReferenced(change, formula):
changeSheet = change["sheet"]
changeCellCordinate = change["cell"]
formulaSheet = formula["sheet"]
formulaexpression = formula["value"]
logging.info("changeSheet {}".format(changeSheet))
logging.info("changeCellCordinate {}".format(changeCellCordinate))
logging.info("formulaSheet {}".format(formulaSheet))
logging.info("formulaexpression {}".format(formulaexpression))
# Tokenize formula and extract RANGE
tok = Tokenizer(formulaexpression)
#print("\n".join("%12s%11s%9s" % (t.value, t.type, t.subtype) for t in tok.items))
for token in tok.items:
if token.subtype == "RANGE":
logging.info("RANGE Found {}".format(token.value))
range = token.value
targetSheetName = formulaSheet
if "!" in range:
targetSheetName = range[:range.find('!')]
targetCordinate = range[range.find('!') +1:]
else:
targetCordinate = range
if targetSheetName != changeSheet:
continue
logging.info("targetSheetName {}".format(targetSheetName))
logging.info("targetCordinate {}".format(targetCordinate))
logging.info("changeCellCordinate {}".format(changeCellCordinate))
# Check changed cell cordinate is in the range or not
targetCordinate = targetCordinate.replace("$","")
changeCellCordinate = changeCellCordinate.replace("$","")
if ":" not in targetCordinate:
targetCordinate = "{}:{}".format(targetCordinate,targetCordinate)
if ":" not in changeCellCordinate:
changeCellCordinate = "{}:{}".format(changeCellCordinate,changeCellCordinate)
m = re.search("(.+):(.+)",targetCordinate)
targetStartCordinate = m.group(1)
targetEndCordinate = m.group(2)
logging.info('targetStartCordinate {}'.format(targetStartCordinate))
logging.info('targetEndCordinate {}'.format(targetEndCordinate))
m = re.search("([A-Z]+)([0-9]+)",targetStartCordinate)
targetStartCol = int(column_index_from_string(m.group(1)))
targetStartRow = int(m.group(2))
logging.info('targetStartCol {}'.format(targetStartCol))
logging.info('targetStartRow {}'.format(targetStartRow))
m = re.search("([A-Z]+)([0-9]+)",targetEndCordinate)
targetEndCol = int(column_index_from_string(m.group(1)))
targetEndRow = int(m.group(2))
logging.info('targetEndCol {}'.format(targetEndCol))
logging.info('targetStartRow {}'.format(targetEndRow))
m = re.search("(.+):(.+)",changeCellCordinate)
changeStartCordinate = m.group(1)
changeEndCordinate = m.group(2)
logging.info('changeStartCordinate {}'.format(changeStartCordinate))
logging.info('changeEndCordinate {}'.format(changeEndCordinate))
m = re.search("([A-Z]+)([0-9]+)",changeStartCordinate)
changeStartCol = int(column_index_from_string(m.group(1)))
changeStartRow = int(m.group(2))
logging.info('changeStartCol {}'.format(changeStartCol))
logging.info('changeStartRow {}'.format(changeStartRow))
m = re.search("([A-Z]+)([0-9]+)",changeEndCordinate)
changeEndCol = int(column_index_from_string(m.group(1)))
changeEndRow = int(m.group(2))
logging.info('changeEndCol {}'.format(changeEndCol))
logging.info('changeEndRow {}'.format(changeEndRow))
# Check change start cell is in the target range
if changeStartRow >= targetStartRow and changeStartRow <= targetEndRow and changeStartCol >= targetStartCol and changeStartCol <= targetEndCol:
logging.info('isReferenced: {}'.format("True"))
return True
# Check change end cell is in the target range
if changeEndRow >= targetStartRow and changeEndRow <= targetEndRow and changeEndCol >= targetStartCol and changeEndCol <= targetEndCol:
logging.info('isReferenced: {}'.format("True"))
return True
logging.info('isReferenced: {}'.format("False"))
return False
def analyzeWorkbook(wb : openpyxl.Workbook):
result = {}
for sheet in wb:
sheetname = sheet.title
cells = {}
for row in sheet:
for cell in row:
cells[cell.coordinate] = cell.value
result[sheetname] = cells
logging.info(pprint.pformat(result))
return result
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG)
excelfilepath1 = "C:\Temp\After.xlsx"
excelfilepath2 = "C:\Temp\Before.xlsx"
wb1 = openpyxl.load_workbook(excelfilepath1, data_only=False, keep_vba=False)
wb2 = openpyxl.load_workbook(excelfilepath2, data_only=False, keep_vba=False)
wbComp = compareXl(wb1,wb2)
wbComp.save("C:\Temp\Compare.xlsx")
wb1.close()
wb2.close()
| StarcoderdataPython |
3282708 | <reponame>Bartzi/handwriting-determination
import os
from image_transformations import otsu_threshold, lighter_otsu_threshold, adaptive_gaussian_threshold, \
etched_lines
IMAGE_FORMATS = ('.png', '.JPG', 'jpg', '.JPEG', '.jpeg')
BASE_DIR = "[path to base dir]"
WORD_PATH = os.path.join(BASE_DIR, 'words')
PHOTOS_PATH = os.path.join(BASE_DIR, 'backgrounds')
PRINT_FONTS_PATH = os.path.join(BASE_DIR, 'fonts')
PRINT_DOCUMENT_PATH = os.path.join(BASE_DIR, 'documents')
HANDWRITTEN_DOCUMENT_PATH = os.path.join(BASE_DIR, 'handwritten_documents')
ARTIFACT_PATH = os.path.join(BASE_DIR, 'artifacts')
def load_image_paths(base_path):
"""
Finds all images in the given base path and returns the paths to them
"""
return [os.path.join(root, name)
for root, dirs, files in os.walk(base_path)
for name in files if name.endswith(IMAGE_FORMATS)]
# load the paths of all available images
word_image_paths = load_image_paths(WORD_PATH)
photo_image_paths = load_image_paths(PHOTOS_PATH)
fonts_image_paths = load_image_paths(PRINT_FONTS_PATH)
document_image_paths = load_image_paths(PRINT_DOCUMENT_PATH)
artifact_image_paths = load_image_paths(ARTIFACT_PATH)
handwritten_document_image_paths = load_image_paths(HANDWRITTEN_DOCUMENT_PATH)
# define the profiles that will later on be used to generate fragments with certain traits,
# one profile defines one trait
# handwritten words
WRITING_CANVAS_PROFILE = {
'image_paths': word_image_paths, # images which will be used for generating this trait
'scale_range': (0.25, 1), # how strong will the images be scaled?
'rotation_range': (0, 360), # how far will the images be rotated?
'preprocessing_method': otsu_threshold, # what preprocessing should be applied to images
'dilation_erosion': [(-3, 1), (3, 1), None, None, None], # what dilation/erosion parameters should be used?
# None means nothing is applied, negative means Erosion
'min_black_share': 0, # what is the minimum amount of black required?
'cutout': False # cutout from the images or paste the whole image?
}
# graphical elements after preprocessing, i.e. organic shapes
GRAPHICAL_CANVAS_PROFILE = {
'image_paths': photo_image_paths,
'scale_range': (2, 10),
'rotation_range': (0, 360),
'preprocessing_method': adaptive_gaussian_threshold,
'dilation_erosion': [(3, 1), None],
'min_black_share': 0,
'cutout': True
}
# shapes that appear after preprocessing a drawing
DRAWING_CANVAS_PROFILE = {
'image_paths': photo_image_paths,
'scale_range': (2, 10),
'rotation_range': (0, 360),
'preprocessing_method': etched_lines,
'dilation_erosion': [(-3, 1), (3, 1), (5, 1), None],
'min_black_share': 0.05,
'cutout': True
}
# words in different fonts
FONT_CANVAS_PROFILE = {
'image_paths': fonts_image_paths,
'scale_range': (0.4, 1),
'rotation_range': (0, 360),
'preprocessing_method': otsu_threshold,
'dilation_erosion': [(-3, 1), (3, 1), (5, 1), None],
'min_black_share': 0.05,
'cutout': False
}
# multiple lines of printed text
DOCUMENT_CANVAS_PROFILE = {
'image_paths': document_image_paths,
'scale_range': (5, 50),
'rotation_range': (0, 360),
'preprocessing_method': otsu_threshold,
'dilation_erosion': [(-3, 1), (3, 1), None, None],
'min_black_share': 0,
'cutout': True
}
# artifacts that appear when preprocessing the original data
ARTIFACT_CANVAS_PROFILE = {
'image_paths': artifact_image_paths,
'scale_range': (1, 5),
'rotation_range': (0, 15),
'preprocessing_method': otsu_threshold,
'dilation_erosion': [None, (-3, 1)],
'min_black_share': 0,
'cutout': False
}
# handwritten lines of text
HANDWRITTEN_DOCUMENT_PROFILE = {
'image_paths': handwritten_document_image_paths,
'scale_range': (5, 50),
'rotation_range': (0, 360),
'preprocessing_method': adaptive_gaussian_threshold,
'dilation_erosion': [(3, 1), (-3, 1), None, None],
'min_black_share': 0.05,
'cutout': True
}
| StarcoderdataPython |
27657 | <reponame>DazEB2/SimplePyScripts<gh_stars>100-1000
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
def upper_print(f):
def wrapper(*args, **kwargs):
f(*[i.upper() if hasattr(i, 'upper') else i for i in args], **kwargs)
return wrapper
if __name__ == '__main__':
text = 'hello world!'
print(text) # hello world!
old_print = print
print = upper_print(print)
print(text) # HELLO WORLD!
print = old_print
print(text) # hello world!
| StarcoderdataPython |
86371 | <reponame>Manug-github/Automating-Real-World-Tasks-with-Python
#!/usr/bin/env python3
import os
import sys
import shutil
import socket
import psutil
import emails
def check_disk_full():
"""Return True if there isn't enough disk space, False otherwise."""
du = shutil.disk_usage("/")
percent_free = 100 * du.free / du.total
if percent_free < 20:
return True
return False
def check_cpu_constrained():
""""Return True if the cpu is having too much usage, False otherwise."""
return psutil.cpu_percent(1) > 80
def check_ram():
""""Return True if the available is lee than 500MB, False otherwise."""
return psutil.virtual_memory().available/ 2**20 < 500
def checks_localhost():
"""Returns True if it fails to resolve local host, False otherwise"""
try:
socket.gethostbyname("127.0.0.1")
return False
except:
return True
def main():
checks = [
(check_disk_full, "Error - Available disk space is less than 20%"),
(check_cpu_constrained, "Error - CPU usage is over 80%"),
(check_ram, "Error - Available memory is less than 500MB"),
(checks_localhost, "Error - localhost cannot be resolved to 127.0.0.1"),
]
for check, msg in checks:
if check():
sender = "<EMAIL>"
receiver = <EMAIL>".format(os.environ.get('USER'))
subject = msg
body = "Please check your system and resolve the issue as soon as possible."
message = emails.generate(sender, receiver, subject, body)
emails.send(message)
if __name__ == "__main__":
main()
| StarcoderdataPython |
4837188 | import itertools
import os
from Character import get_characters
from Options import Options_
from LocationRandomizer import get_npcs
from MonsterRandomizer import change_enemy_name
from Utils import (CHARACTER_PALETTE_TABLE, EVENT_PALETTE_TABLE, FEMALE_NAMES_TABLE, MALE_NAMES_TABLE,
MOOGLE_NAMES_TABLE, RIDING_SPRITE_TABLE, SPRITE_REPLACEMENT_TABLE,
generate_character_palette, get_palette_transformer, hex2int, name_to_bytes,
open_mei_fallback, read_multi, shuffle_char_hues,
Substitution, utilrandom as random, write_multi)
def recolor_character_palette(fout, pointer, palette=None, flesh=False, middle=True, santa=False, skintones=None, char_hues=None, trance=False):
fout.seek(pointer)
if palette is None:
palette = [read_multi(fout, length=2) for _ in range(16)]
outline, eyes, hair, skintone, outfit1, outfit2, NPC = (
palette[:2], palette[2:4], palette[4:6], palette[6:8],
palette[8:10], palette[10:12], palette[12:])
def components_to_color(xxx_todo_changeme):
(red, green, blue) = xxx_todo_changeme
return red | (green << 5) | (blue << 10)
new_style_palette = None
if skintones and char_hues:
new_style_palette = generate_character_palette(skintones, char_hues, trance=trance)
# aliens, available in palette 5 only
if flesh and random.randint(1, 20) == 1:
transformer = get_palette_transformer(middle=middle)
new_style_palette = transformer(new_style_palette)
elif trance:
new_style_palette = generate_character_palette(trance=True)
new_palette = new_style_palette if new_style_palette else []
if not flesh:
pieces = (outline, eyes, hair, skintone, outfit1, outfit2, NPC) if not new_style_palette else [NPC]
for piece in pieces:
transformer = get_palette_transformer(middle=middle)
piece = list(piece)
piece = transformer(piece)
new_palette += piece
if not new_style_palette:
new_palette[6:8] = skintone
if Options_.is_code_active('christmas'):
if santa:
# color kefka's palette to make him look santa-ish
new_palette = palette
new_palette[8] = components_to_color((0x18, 0x18, 0x16))
new_palette[9] = components_to_color((0x16, 0x15, 0x0F))
new_palette[10] = components_to_color((0x1C, 0x08, 0x03))
new_palette[11] = components_to_color((0x18, 0x02, 0x05))
else:
# give them red & green outfits
red = [components_to_color((0x19, 0x00, 0x05)), components_to_color((0x1c, 0x02, 0x04))]
green = [components_to_color((0x07, 0x12, 0x0b)), components_to_color((0x03, 0x0d, 0x07))]
random.shuffle(red)
random.shuffle(green)
outfit = [red, green]
random.shuffle(outfit)
new_palette[8:10] = outfit[0]
new_palette[10:12] = outfit[1]
else:
transformer = get_palette_transformer(middle=middle)
new_palette = transformer(palette)
if new_style_palette:
new_palette = new_style_palette[0:12] + new_palette[12:]
palette = new_palette
fout.seek(pointer)
for p in palette:
write_multi(fout, p, length=2)
return palette
def make_palette_repair(fout, main_palette_changes):
repair_sub = Substitution()
bytestring = []
for c in sorted(main_palette_changes):
_, after = main_palette_changes[c]
bytestring.extend([0x43, c, after])
repair_sub.bytestring = bytestring + [0xFE]
repair_sub.set_location(0xCB154) # Narshe secret entrance
repair_sub.write(fout)
NAME_ID_DICT = {
0: "Terra",
1: "Locke",
2: "Cyan",
3: "Shadow",
4: "Edgar",
5: "Sabin",
6: "Celes",
7: "Strago",
8: "Relm",
9: "Setzer",
0xa: "Mog",
0xb: "Gau",
0xc: "Gogo",
0xd: "Umaro",
0xe: "Trooper",
0xf: "Imp",
0x10: "Leo",
0x11: "Banon",
0x12: "<NAME>",
0x13: "Merchant",
0x14: "Ghost",
0x15: "Kefka"}
def sanitize_names(names):
delchars = ''.join(c for c in map(chr, range(256)) if not c.isalnum() and c not in "!?/:\"'-.")
table = str.maketrans(dict.fromkeys(delchars))
names = [name.translate(table) for name in names]
return [name[:6] for name in names if name != ""]
def manage_character_names(fout, change_to, male):
characters = get_characters()
wild = Options_.is_code_active('partyparty')
sabin_mode = Options_.is_code_active('suplexwrecks')
tina_mode = Options_.is_code_active('bravenudeworld')
soldier_mode = Options_.is_code_active('quikdraw')
moogle_mode = Options_.is_code_active('kupokupo')
ghost_mode = Options_.is_code_active('halloween')
names = []
if tina_mode:
names = ["Tina"] * 30 + ["MADUIN"] + ["Tina"] * 3
elif sabin_mode:
names = ["Teabin", "Loabin", "Cyabin", "Shabin", "Edabin", "Sabin",
"Ceabin", "Stabin", "Reabin", "Seabin", "Moabin", "Gaubin",
"Goabin", "Umabin", "Baabin", "Leabin", "??abin", "??abin",
"Kuabin", "Kuabin", "Kuabin", "Kuabin", "Kuabin", "Kuabin",
"Kuabin", "Kuabin", "Kuabin", "Kaabin", "Moabin", "??abin",
"MADUIN", "??abin", "Viabin", "Weabin"]
elif moogle_mode:
names = ["Kumop", "Kupo", "Kupek", "Kupop", "Kumama", "Kuku",
"Kutan", "Kupan", "Kushu", "Kurin", "Mog", "Kuru",
"Kamog", "Kumaro", "Banon", "Leo", "?????", "?????",
"Cyan", "Shadow", "Edgar", "Sabin", "Celes", "Strago",
"Relm", "Setzer", "Gau", "Gogo"]
gba_moogle_names = ["Moglin", "Mogret", "Moggie", "Molulu", "Moghan",
"Moguel", "Mogsy", "Mogwin", "Mog", "Mugmug", "Cosmog"]
random_name_ids = []
# Terra, Locke, and Umaro get a specific name, or a random moogle name from another ff game
for moogle_id in [0, 1, 13]:
if random.choice([True, True, False]):
random_name_ids.append(moogle_id)
# Other party members get either the name of their counterpart from snes or gba, or moogle name from another ff game
for moogle_id in itertools.chain(range(2, 10), range(11, 13)):
chance = random.randint(1, 4)
if chance == 2:
names[moogle_id] = gba_moogle_names[moogle_id - 2]
elif chance != 1:
random_name_ids.append(moogle_id)
f = open_mei_fallback(MOOGLE_NAMES_TABLE)
mooglenames = sorted(set(sanitize_names([line.strip() for line in f.readlines()])))
f.close()
random_moogle_names = random.sample(mooglenames, len(random_name_ids))
for index, moogle_id in enumerate(random_name_ids):
names[moogle_id] = random_moogle_names[index]
# Human Mog gets a human name, maybe
if random.choice([True, True, False]):
f = open_mei_fallback(MALE_NAMES_TABLE)
malenames = sorted(set(sanitize_names([line.strip() for line in f.readlines()])))
f.close()
names[10] = random.choice(malenames)
else:
f = open_mei_fallback(MALE_NAMES_TABLE)
malenames = sorted(set(sanitize_names([line.strip() for line in f.readlines()])))
f.close()
f = open_mei_fallback(FEMALE_NAMES_TABLE)
femalenames = sorted(set(sanitize_names([line.strip() for line in f.readlines()])))
f.close()
for c in range(14):
choose_male = False
if wild or soldier_mode or ghost_mode:
choose_male = random.choice([True, False])
elif change_to[c] in male:
choose_male = True
if choose_male:
name = random.choice(malenames)
else:
name = random.choice(femalenames)
if name in malenames:
malenames.remove(name)
if name in femalenames:
femalenames.remove(name)
names.append(name)
umaro_name = names[13]
for umaro_id in [0x10f, 0x110]:
change_enemy_name(fout, umaro_id, umaro_name)
if not Options_.is_code_active('capslockoff'):
names = [name.upper() for name in names]
for c in characters:
if c.id < 14:
c.newname = names[c.id]
c.original_appearance = NAME_ID_DICT[c.id]
for c, name in enumerate(names):
name = name_to_bytes(name, 6)
assert len(name) == 6
fout.seek(0x478C0 + (6*c))
fout.write(name)
def get_free_portrait_ids(swap_to, change_to, char_ids, char_portraits):
# get unused portraits so we can overwrite them if needed
sprite_swap_mode = Options_.is_code_active('makeover')
wild = Options_.is_code_active('partyparty')
if not sprite_swap_mode:
return [], False
def reserve_portrait_id(used_portrait_ids, new, swap, portrait):
if swap is None:
if portrait == 0 and wild and new != 0:
used_portrait_ids.add(0xE)
else:
used_portrait_ids.add(new)
elif not swap.has_custom_portrait():
used_portrait_ids.add(swap.fallback_portrait_id)
else:
return 1
return 0
needed = 0
used_portrait_ids = set()
for c in char_ids:
# skip characters who don't have their own portraits
if (char_portraits[c] == 0 and c != 0) or c == 0x13:
continue
new = change_to[c]
portrait = char_portraits[new]
swap = swap_to[c] if c in swap_to else None
needed += reserve_portrait_id(used_portrait_ids, new, swap, portrait)
if not wild:
for i in range(0xE, 0x13):
used_portrait_ids.add(i)
# Merchant normally uses the same portrait as soldier.
# If we have a free slot because some others happen to be sharing, use the portrait for the merchant sprite.
# If not, we have to use the same one as the soldier.
merchant = False
if wild and needed < 19 - len(used_portrait_ids):
c = 0x13
new = change_to[c]
portrait = char_portraits[new]
swap = swap_to[c] if c in swap_to else None
merchant = reserve_portrait_id(used_portrait_ids, new, swap, portrait)
free_portrait_ids = list(set(range(19)) - used_portrait_ids)
return free_portrait_ids, merchant
def get_sprite_swaps(char_ids, male, female, vswaps):
sprite_swap_mode = Options_.is_code_active('makeover')
wild = Options_.is_code_active('partyparty')
clone_mode = Options_.is_code_active('cloneparty')
replace_all = Options_.is_code_active('novanilla') or Options_.is_code_active('frenchvanilla')
external_vanillas = False if Options_.is_code_active('novanilla') else (Options_.is_code_active('frenchvanilla') or clone_mode)
if not sprite_swap_mode:
return []
class SpriteReplacement:
def __init__(self, file, name, gender, riding=None, fallback_portrait_id=0xE, portrait_filename=None, uniqueids=None, groups=None):
self.file = file.strip()
self.name = name.strip()
self.gender = gender.strip().lower()
self.size = 0x16A0 if riding is not None and riding.lower() == "true" else 0x1560
self.uniqueids = [s.strip() for s in uniqueids.split('|')] if uniqueids else []
self.groups = [s.strip() for s in groups.split('|')] if groups else []
if self.gender == "female":
self.groups.append("girls")
if self.gender == "male":
self.groups.append("boys")
self.weight = 1.0
if fallback_portrait_id == '':
fallback_portrait_id = 0xE
self.fallback_portrait_id = int(fallback_portrait_id)
self.portrait_filename = portrait_filename
if self.portrait_filename is not None:
self.portrait_filename = self.portrait_filename.strip()
if self.portrait_filename:
self.portrait_palette_filename = portrait_filename.strip()
if self.portrait_palette_filename and self.portrait_palette_filename:
if self.portrait_palette_filename[-4:] == ".bin":
self.portrait_palette_filename = self.portrait_palette_filename[:-4]
self.portrait_palette_filename = self.portrait_palette_filename + ".pal"
else:
self.portrait_filename = None
def has_custom_portrait(self):
return self.portrait_filename is not None and self.portrait_palette_filename is not None
def is_on(self, checklist):
for g in self.uniqueids:
if g in checklist:
return True
return False
f = open_mei_fallback(SPRITE_REPLACEMENT_TABLE)
known_replacements = [SpriteReplacement(*line.strip().split(',')) for line in f.readlines()]
f.close()
#uniqueids for sprites pulled from rom
vuids = {0: "terra", 1: "locke", 2: "cyan", 3: "shadow", 4: "edgar", 5: "sabin", 6: "celes", 7: "strago", 8: "relm", 9: "setzer", 10: "moogle", 11: "gau", 12: "gogo6", 13: "umaro", 16: "leo", 17: "banon", 18: "terra", 21: "kefka"}
#determine which character ids are makeover'd
blacklist = set()
if replace_all:
num_to_replace = len(char_ids)
is_replaced = [True] * num_to_replace
else:
replace_min = 8 if not wild else 16
replace_max = 12 if not wild else 20
num_to_replace = min(len(known_replacements), random.randint(replace_min, replace_max))
is_replaced = [True] * num_to_replace + [False]*(len(char_ids)-num_to_replace)
random.shuffle(is_replaced)
for i, t in enumerate(is_replaced):
if i in vuids and not t:
blacklist.update([s.strip() for s in vuids[i].split('|')])
if external_vanillas:
#include vanilla characters, but using the same system/chances as all others
og_replacements = [
SpriteReplacement("ogterra.bin", "Terra", "female", "true", 0, None, "terra"),
SpriteReplacement("oglocke.bin", "Locke", "male", "true", 1, None, "locke"),
SpriteReplacement("ogcyan.bin", "Cyan", "male", "true", 2, None, "cyan"),
SpriteReplacement("ogshadow.bin", "Shadow", "male", "true", 3, None, "shadow"),
SpriteReplacement("ogedgar.bin", "Edgar", "male", "true", 4, None, "edgar"),
SpriteReplacement("ogsabin.bin", "Sabin", "male", "true", 5, None, "sabin"),
SpriteReplacement("ogceles.bin", "Celes", "female", "true", 6, None, "celes"),
SpriteReplacement("ogstrago.bin", "Strago", "male", "true", 7, None, "strago"),
SpriteReplacement("ogrelm.bin", "Relm", "female", "true", 8, None, "relm", "kids"),
SpriteReplacement("ogsetzer.bin", "Setzer", "male", "true", 9, None, "setzer"),
SpriteReplacement("ogmog.bin", "Mog", "neutral", "true", 10, None, "moogle"),
SpriteReplacement("oggau.bin", "Gau", "male", "true", 11, None, "gau", "kids"),
SpriteReplacement("oggogo.bin", "Gogo", "neutral", "true", 12, None, "gogo6"),
SpriteReplacement("ogumaro.bin", "Umaro", "neutral", "true", 13, None, "umaro")]
if wild:
og_replacements.extend([
SpriteReplacement("ogtrooper.bin", "Trooper", "neutral", "true", 14),
SpriteReplacement("ogimp.bin", "Imp", "neutral", "true", 15),
SpriteReplacement("ogleo.bin", "Leo", "male", "true", 16, None, "leo"),
SpriteReplacement("ogbanon.bin", "Banon", "male", "true", 17, None, "banon"),
SpriteReplacement("ogesperterra.bin", "Esper Terra", "female", "true", 0, "esperterra-p.bin", "terra"),
SpriteReplacement("ogmerchant.bin", "Merchant", "male", "true", 1),
SpriteReplacement("ogghost.bin", "Ghost", "neutral", "true", 18),
SpriteReplacement("ogkefka.bin", "Kefka", "male", "true", 17, "kefka-p.bin", "kefka")])
if clone_mode:
used_vanilla = [NAME_ID_DICT[vswaps[n]] for i, n in enumerate(char_ids) if not is_replaced[i]]
og_replacements = [r for r in og_replacements if r.name not in used_vanilla]
known_replacements.extend(og_replacements)
#weight selection based on no*/hate*/like*/love* codes
whitelist = [c.name[4:] for c in Options_.active_codes if c.name.startswith("love")]
replace_candidates = []
for r in known_replacements:
whitelisted = False
for g in r.groups:
if not r.weight:
break
if g in whitelist:
whitelisted = True
if Options_.is_code_active("no"+g):
r.weight = 0
elif Options_.is_code_active("hate"+g):
r.weight /= 3
elif Options_.is_code_active("like"+g):
r.weight *= 2
if whitelist and not whitelisted:
r.weight = 0
if r.weight:
replace_candidates.append(r)
#select sprite replacements
if not wild:
female_candidates = [c for c in replace_candidates if c.gender == "female"]
male_candidates = [c for c in replace_candidates if c.gender == "male"]
neutral_candidates = [c for c in replace_candidates if c.gender != "male" and c.gender != "female"]
swap_to = {}
for char_id in random.sample(char_ids, len(char_ids)):
if not is_replaced[char_id]:
continue
if wild:
candidates = replace_candidates
else:
if char_id in female:
candidates = female_candidates
elif char_id in male:
candidates = male_candidates
else:
candidates = neutral_candidates
if random.randint(0, len(neutral_candidates)+2*len(candidates)) <= len(neutral_candidates):
candidates = neutral_candidates
if clone_mode:
reverse_blacklist = [c for c in candidates if c.is_on(blacklist)]
if reverse_blacklist:
weights = [c.weight for c in reverse_blacklist]
swap_to[char_id] = random.choices(reverse_blacklist, weights)[0]
blacklist.update(swap_to[char_id].uniqueids)
candidates.remove(swap_to[char_id])
continue
final_candidates = [c for c in candidates if not c.is_on(blacklist)]
if final_candidates:
weights = [c.weight for c in final_candidates]
swap_to[char_id] = random.choices(final_candidates, weights)[0]
blacklist.update(swap_to[char_id].uniqueids)
candidates.remove(swap_to[char_id])
else:
print(f"custom sprite pool for {char_id} empty, using a vanilla sprite")
return swap_to
def manage_character_appearance(fout, preserve_graphics=False):
characters = get_characters()
wild = Options_.is_code_active('partyparty')
sabin_mode = Options_.is_code_active('suplexwrecks')
tina_mode = Options_.is_code_active('bravenudeworld')
soldier_mode = Options_.is_code_active('quikdraw')
moogle_mode = Options_.is_code_active('kupokupo')
ghost_mode = Options_.is_code_active('halloween')
christmas_mode = Options_.is_code_active('christmas')
sprite_swap_mode = Options_.is_code_active('makeover') and not (sabin_mode or tina_mode or soldier_mode or moogle_mode or ghost_mode)
new_palette_mode = not Options_.is_code_active('sometimeszombies')
if new_palette_mode:
# import recolors for incompatible base sprites
recolors = [("cyan", 0x152D40, 0x16A0), ("mog", 0x15E240, 0x16A0),
("umaro", 0x162620, 0x16A0), ("dancer", 0x1731C0, 0x5C0),
("lady", 0x1748C0, 0x5C0)]
for rc in recolors:
filename = os.path.join("data", "sprites", "RC" + rc[0] + ".bin")
try:
with open_mei_fallback(filename, "rb") as f:
sprite = f.read()
except OSError:
continue
if len(sprite) >= rc[2]:
sprite = sprite[:rc[2]]
fout.seek(rc[1])
fout.write(sprite)
if (wild or tina_mode or sabin_mode or christmas_mode):
if christmas_mode:
char_ids = list(range(0, 0x15)) # don't replace kefka
else:
char_ids = list(range(0, 0x16))
else:
char_ids = list(range(0, 0x0E))
male = None
female = None
if tina_mode:
change_to = dict(list(zip(char_ids, [0x12] * 100)))
elif sabin_mode:
change_to = dict(list(zip(char_ids, [0x05] * 100)))
elif soldier_mode:
change_to = dict(list(zip(char_ids, [0x0e] * 100)))
elif ghost_mode:
change_to = dict(list(zip(char_ids, [0x14] * 100)))
elif moogle_mode:
# all characters are moogles except Mog, Imp, and Esper Terra
if wild:
# make mog human
mog = random.choice(list(range(0, 0x0A)) + list(range(0x0B, 0x0F)) +[0x10, 0x11, 0x13, 0x15])
#esper terra and imp neither human nor moogle
esper_terra, imp = random.sample([0x0F, 0x12, 0x14], 2)
else:
mog = random.choice(list(range(0, 0x0A)) + list(range(0x0B, 0x0E)))
esper_terra = 0x12
imp = 0x0F
change_to = dict(list(zip(char_ids, [0x0A] * 100)))
change_to[0x0A] = mog
change_to[0x12] = esper_terra
change_to[0x0F] = imp
else:
female = [0, 0x06, 0x08]
female += [c for c in [0x03, 0x0A, 0x0C, 0x0D, 0x0E, 0x0F, 0x14] if
random.choice([True, False])]
female = [c for c in char_ids if c in female]
male = [c for c in char_ids if c not in female]
if preserve_graphics:
change_to = dict(list(zip(char_ids, char_ids)))
elif wild:
change_to = list(char_ids)
random.shuffle(change_to)
change_to = dict(list(zip(char_ids, change_to)))
else:
random.shuffle(female)
random.shuffle(male)
change_to = dict(list(zip(sorted(male), male)) +
list(zip(sorted(female), female)))
manage_character_names(fout, change_to, male)
swap_to = get_sprite_swaps(char_ids, male, female, change_to)
for c in characters:
if c.id < 14:
if sprite_swap_mode and c.id in swap_to:
c.new_appearance = swap_to[c.id].name
elif not preserve_graphics:
c.new_appearance = NAME_ID_DICT[change_to[c.id]]
else:
c.new_appearance = c.original_appearance
sprite_ids = list(range(0x16))
ssizes = ([0x16A0] * 0x10) + ([0x1560] * 6)
spointers = dict([(c, sum(ssizes[:c]) + 0x150000) for c in sprite_ids])
ssizes = dict(list(zip(sprite_ids, ssizes)))
char_portraits = {}
char_portrait_palettes = {}
sprites = {}
riding_sprites = {}
try:
f = open(RIDING_SPRITE_TABLE, "r")
except IOError:
pass
else:
for line in f.readlines():
char_id, filename = line.strip().split(',', 1)
try:
g = open_mei_fallback(os.path.join("custom", "sprites", filename), "rb")
except IOError:
continue
riding_sprites[int(char_id)] = g.read(0x140)
g.close()
f.close()
for c in sprite_ids:
fout.seek(0x36F1B + (2*c))
portrait = read_multi(fout, length=2)
char_portraits[c] = portrait
fout.seek(0x36F00 + c)
portrait_palette = fout.read(1)
char_portrait_palettes[c] = portrait_palette
fout.seek(spointers[c])
sprite = fout.read(ssizes[c])
if c in riding_sprites:
sprite = sprite[:0x1560] + riding_sprites[c]
sprites[c] = sprite
if tina_mode:
char_portraits[0x12] = char_portraits[0]
char_portrait_palettes[0x12] = char_portrait_palettes[0]
portrait_data = []
portrait_palette_data = []
fout.seek(0x2D1D00)
for _ in range(19):
portrait_data.append(fout.read(0x320))
fout.seek(0x2D5860)
for _ in range(19):
portrait_palette_data.append(fout.read(0x20))
free_portrait_ids, merchant = get_free_portrait_ids(swap_to, change_to, char_ids, char_portraits)
for c in char_ids:
new = change_to[c]
portrait = char_portraits[new]
portrait_palette = char_portrait_palettes[new]
if c == 0x13 and sprite_swap_mode and not merchant:
new_soldier = change_to[0xE]
portrait = char_portraits[new_soldier]
portrait_palette = char_portrait_palettes[new_soldier]
elif (char_portraits[c] == 0 and c != 0):
portrait = char_portraits[0xE]
portrait_palette = char_portrait_palettes[0xE]
elif sprite_swap_mode and c in swap_to:
use_fallback = True
fallback_portrait_id = swap_to[c].fallback_portrait_id
if fallback_portrait_id < 0 or fallback_portrait_id > 18:
fallback_portrait_id = 0xE
portrait = fallback_portrait_id * 0x320
portrait_palette = bytes([fallback_portrait_id])
new_portrait_data = portrait_data[fallback_portrait_id]
new_portrait_palette_data = portrait_palette_data[fallback_portrait_id]
if swap_to[c].has_custom_portrait():
use_fallback = False
try:
g = open_mei_fallback(os.path.join("custom", "sprites", swap_to[c].portrait_filename), "rb")
h = open_mei_fallback(os.path.join("custom", "sprites", swap_to[c].portrait_palette_filename), "rb")
except IOError:
use_fallback = True
print("failed to load portrait %s for %s, using fallback" %(swap_to[c].portrait_filename, swap_to[c].name))
else:
new_portrait_data = g.read(0x320)
new_portrait_palette_data = h.read(0x20)
h.close()
g.close()
if not use_fallback or fallback_portrait_id in free_portrait_ids:
portrait_id = free_portrait_ids[0]
portrait = portrait_id * 0x320
portrait_palette = bytes([portrait_id])
free_portrait_ids.remove(free_portrait_ids[0])
fout.seek(0x2D1D00 + portrait)
fout.write(new_portrait_data)
fout.seek(0x2D5860 + portrait_id * 0x20)
fout.write(new_portrait_palette_data)
elif portrait == 0 and wild and change_to[c] != 0:
portrait = char_portraits[0xE]
portrait_palette = char_portrait_palettes[0xE]
fout.seek(0x36F1B + (2*c))
write_multi(fout, portrait, length=2)
fout.seek(0x36F00 + c)
fout.write(portrait_palette)
if wild:
fout.seek(spointers[c])
fout.write(sprites[0xE][:ssizes[c]])
fout.seek(spointers[c])
if sprite_swap_mode and c in swap_to:
try:
g = open_mei_fallback(os.path.join("custom", "sprites", swap_to[c].file), "rb")
except IOError:
newsprite = sprites[change_to[c]]
for ch in characters:
if ch.id == c:
ch.new_appearance = NAME_ID_DICT[change_to[c]]
else:
newsprite = g.read(min(ssizes[c], swap_to[c].size))
# if it doesn't have riding sprites, it probably doesn't have a death sprite either
if swap_to[c].size < 0x16A0:
newsprite = newsprite[:0xAE0] + sprites[0xE][0xAE0:0xBA0] + newsprite[0xBA0:]
g.close()
else:
newsprite = sprites[change_to[c]]
newsprite = newsprite[:ssizes[c]]
fout.write(newsprite)
# celes in chains
fout.seek(0x159500)
chains = fout.read(192)
fout.seek(0x17D660)
fout.write(chains)
manage_palettes(fout, change_to, char_ids)
def manage_palettes(fout, change_to, char_ids):
sabin_mode = Options_.is_code_active('suplexwrecks')
tina_mode = Options_.is_code_active('bravenudeworld')
christmas_mode = Options_.is_code_active('christmas')
new_palette_mode = not Options_.is_code_active('sometimeszombies')
characters = get_characters()
npcs = get_npcs()
charpal_Options = {}
for line in open(CHARACTER_PALETTE_TABLE):
if line[0] == '#':
continue
charid, palettes = tuple(line.strip().split(':'))
palettes = list(map(hex2int, palettes.split(',')))
charid = hex2int(charid)
charpal_Options[charid] = palettes
if new_palette_mode:
twinpal = random.randint(0, 5)
char_palette_pool = list(range(0, 6)) + list(range(0, 6))
char_palette_pool.remove(twinpal)
char_palette_pool.append(random.choice(list(range(0, twinpal))+list(range(twinpal, 6))))
while True:
random.shuffle(char_palette_pool)
#make sure terra, locke, and edgar are all different
if twinpal in char_palette_pool[0:2]:
continue
if char_palette_pool[0] == char_palette_pool[1]:
continue
break
char_palette_pool = char_palette_pool[:4] + [twinpal, twinpal] + char_palette_pool[4:]
palette_change_to = {}
additional_celeses = []
for npc in npcs:
if npc.graphics == 0x41:
additional_celeses.append(npc)
if npc.graphics not in charpal_Options:
continue
# Don't recolor shadowy Sabin on Mt. Kolts
if npc.locid in [0x60, 0x61]:
continue
if npc.graphics in change_to:
new_graphics = change_to[npc.graphics]
if (npc.graphics, npc.palette) in palette_change_to:
new_palette = palette_change_to[(npc.graphics, npc.palette)]
elif new_palette_mode and npc.graphics < 14:
new_palette = char_palette_pool[npc.graphics]
palette_change_to[(npc.graphics, npc.palette)] = new_palette
npc.palette = new_palette
else:
while True:
new_palette = random.choice(charpal_Options[new_graphics])
if sabin_mode or tina_mode:
new_palette = random.randint(0, 5)
if (new_palette == 5 and new_graphics not in
[3, 0xA, 0xC, 0xD, 0xE, 0xF, 0x12, 0x14] and
random.randint(1, 10) != 10):
continue
break
palette_change_to[(npc.graphics, npc.palette)] = new_palette
npc.palette = new_palette
npc.palette = new_palette
for npc in additional_celeses:
if (6, 0) in palette_change_to:
npc.palette = palette_change_to[(6, 0)]
main_palette_changes = {}
for character in characters:
c = character.id
if c not in change_to:
continue
fout.seek(0x2CE2B + c)
before = ord(fout.read(1))
new_graphics = change_to[c]
new_palette = palette_change_to[(c, before)]
main_palette_changes[c] = (before, new_palette)
fout.seek(0x2CE2B + c)
fout.write(bytes([new_palette]))
pointers = [0, 4, 9, 13]
pointers = [ptr + 0x18EA60 + (18*c) for ptr in pointers]
if c < 14:
for ptr in pointers:
fout.seek(ptr)
byte = ord(fout.read(1))
byte = byte & 0xF1
byte |= ((new_palette+2) << 1)
fout.seek(ptr)
fout.write(bytes([byte]))
character.palette = new_palette
if Options_.is_code_active('repairpalette'):
make_palette_repair(fout, main_palette_changes)
if new_palette_mode:
char_hues = [0, 10, 20, 30, 45, 60, 75, 90, 120, 150, 180, 200, 220, 240, 270, 300, 330]
char_hues.append(random.choice([0, 0, 345, random.randint(105,135)]))
char_hues = shuffle_char_hues(char_hues)
skintones = [((31, 24, 17), (25, 13, 7)),
((31, 23, 15), (25, 15, 8)),
((31, 24, 17), (25, 13, 7)),
((31, 25, 15), (25, 19, 10)),
((31, 25, 16), (24, 15, 12)),
((27, 17, 10), (20, 12, 10)),
((25, 20, 14), (19, 12, 4)),
((27, 22, 18), (20, 15, 12)),
((28, 22, 16), (22, 13, 6)),
((28, 23, 15), (22, 16, 7)),
((27, 23, 15), (20, 14, 9))]
snowmanvampire = ((29, 29, 30), (25, 25, 27))
if christmas_mode or random.randint(1, 100) > 66:
skintones.append(snowmanvampire)
random.shuffle(skintones)
# no vampire townsfolk
if snowmanvampire in skintones[:6] and not christmas_mode:
skintones.remove(snowmanvampire)
skintones = skintones[:5] + [snowmanvampire]
for i in range(6):
pointer = 0x268000 + (i*0x20)
if new_palette_mode:
palette = recolor_character_palette(fout, pointer, palette=None,
flesh=(i == 5), santa=(christmas_mode and i == 3),
skintones=skintones, char_hues=char_hues)
else:
palette = recolor_character_palette(fout, pointer, palette=None,
flesh=(i == 5), santa=(christmas_mode and i == 3))
pointer = 0x2D6300 + (i*0x20)
recolor_character_palette(fout, pointer, palette=palette)
# esper terra
pointer = 0x268000 + (8*0x20)
if new_palette_mode:
palette = recolor_character_palette(fout, pointer, palette=None, trance=True)
else:
palette = recolor_character_palette(fout, pointer, palette=None, flesh=True,
middle=False)
pointer = 0x2D6300 + (6*0x20)
palette = recolor_character_palette(fout, pointer, palette=palette)
# recolor magitek and chocobos
transformer = get_palette_transformer(middle=True)
def recolor_palette(pointer, size):
fout.seek(pointer)
palette = [read_multi(fout, length=2) for _ in range(size)]
palette = transformer(palette)
fout.seek(pointer)
for c in palette:
write_multi(fout, c, length=2)
recolor_palette(0x2cfd4, 23)
recolor_palette(0x268000+(7*0x20), 16)
recolor_palette(0x12ee20, 16)
recolor_palette(0x12ef20, 16)
for line in open(EVENT_PALETTE_TABLE):
if line[0] == '#':
continue
line = line.split(' ')
if len(line) > 1:
if line[1] == 'c' and Options_.is_code_active('thescenarionottaken'):
return
if line[1] == 'd' and not Options_.is_code_active('thescenarionottaken'):
return
pointer = hex2int(line[0].strip())
fout.seek(pointer)
data = bytearray(fout.read(5))
char_id, palette = data[1], data[4]
if char_id not in char_ids:
continue
try:
data[4] = palette_change_to[(char_id, palette)]
except KeyError:
continue
fout.seek(pointer)
fout.write(data)
| StarcoderdataPython |
1734074 | <filename>nino/client.py<gh_stars>1-10
from __future__ import annotations
import typing as t
import aiohttp
from .http import HTTPClient
from .paginator import PaginatedQuery
__all__ = ("Client",)
class Client:
"""
The client that is used to communicate with the AniList API.
Attributes:
token (str, optional): The token used to do mutations on the AniList API.
session (requests.Session, optional): A session that is used to actually send the requests.
http (nino.HTTPClient): An HTTPClient instance used to handle every request.
"""
def __init__(
self,
token: t.Optional[str] = None,
session: t.Optional[aiohttp.ClientSession] = None,
):
self.session = aiohttp.ClientSession() if session is None else session
self.http = HTTPClient(self, self.session)
self.token = token
async def anime_search(
self, name: str, *, page: int = 1, per_page: int = 1
) -> PaginatedQuery:
"""
A method used to query the API for a Anime, with the data provided.
Args:
name (str): The name to search for.
page (int, optional): What page of items to return. Defaults to 1.
per_page (int, optional): How many items to show per page. Defaults to 1.
Returns:
The [PaginatedQuery](./paginator.md) instance used to read the data that was sent back.
"""
return await self.http.query_from(
name, search_type="anime", page=page, per_page=per_page
)
async def character_search(
self, name: str, *, page: int = 1, per_page: int = 1
) -> PaginatedQuery:
"""
A method used to query the API for a Character, with the data provided.
Args:
name (str): The name to search for.
page (int, optional): What page of items to return. Defaults to 1.
per_page (int, optional): How many items to show per page. Defaults to 1.
Returns:
The [PaginatedQuery](./paginator.md) instance used to read the data that was sent back.
"""
return await self.http.query_from(
name, search_type="character", page=page, per_page=per_page
)
async def staff_search(
self, name: str, *, page: int = 1, per_page: int = 1
) -> PaginatedQuery:
"""
A method used to query the API for a Staff, with the data provided.
Args:
name (str): The name to search for.
page (int, optional): What page of items to return. Defaults to 1.
per_page (int, optional): How many items to show per page. Defaults to 1.
Returns:
The [PaginatedQuery](./paginator.md) instance used to read the data that was sent back.
"""
return await self.http.query_from(
name, search_type="staff", page=page, per_page=per_page
)
async def user_search(
self, name: str, *, page: int = 1, per_page: int = 1
) -> PaginatedQuery:
"""
A method used to query the API for a User, with the data provided.
Args:
name (str): The name to search for.
page (int, optional): What page of items to return. Defaults to 1.
per_page (int, optional): How many items to show per page. Defaults to 1.
Returns:
The [PaginatedQuery](./paginator.md) instance used to read the data that was sent back.
"""
return await self.http.query_from(
name, search_type="user", page=page, per_page=per_page
)
async def studio_search(
self, name: str, *, page: int = 1, per_page: int = 1
) -> PaginatedQuery:
"""
A method used to query the API for a Studio, with the data provided.
Args:
name (str): The name to search for.
page (int, optional): What page of items to return. Defaults to 1.
per_page (int, optional): How many items to show per page. Defaults to 1.
Returns:
The [PaginatedQuery](./paginator.md) instance used to read the data that was sent back.
"""
return await self.http.query_from(
name, search_type="studio", page=page, per_page=per_page
)
async def close(self) -> None:
"""
A method used to close the Session.
"""
await self.session.close()
async def __aenter__(self) -> Client:
return self
async def __aexit__(self, exc_type, exc_value, trace) -> None:
await self.close()
| StarcoderdataPython |
1667207 | <reponame>andela-cnnadi/python-fire
from functools import wraps
def validate_payload(func):
@wraps(func)
def func_wrapper(instance, payload):
native_types = [bool, int, float, str, list, tuple, dict]
if type(payload) not in native_types:
raise ValueError("Invalid payload specified")
return func(instance, payload)
return func_wrapper
def parse_results(func):
@wraps(func)
def func_wrapper(instance, *args, **kwargs):
results = func(instance, *args, **kwargs)
if results.status_code == 200:
return results.json()
else:
results.raise_for_status()
return func_wrapper
| StarcoderdataPython |
142175 | <reponame>ZuuZaa/defacto_price_parser
#for request headers
headers = {
'Access-Control-Allow-Origin': '*',
'Access-Control-Allow-Methods': 'GET',
'Access-Control-Allow-Headers': 'Content-Type',
'Access-Control-Max-Age': '3600',
'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0'
} | StarcoderdataPython |
3314193 | consumer_key = 'CONSUMER_KEY'
consumer_secret = 'CONSUMER_SECRET'
access_token = 'ACCESS_TOKEN'
access_token_secret = 'ACCESS_TOKEN_SECRET' | StarcoderdataPython |
131313 | #!/usr/bin/python
import string
from sys import argv
firmware = argv[1]
f0 = open(firmware+"_0.hex", "w");
f1 = open(firmware+"_1.hex", "w");
f2 = open(firmware+"_2.hex", "w");
f3 = open(firmware+"_3.hex", "w");
main_file = open(firmware+".hex", "r");
text = main_file.readlines();
for line in text:
if(line == "0\n"):
f3.write("0\n");
f2.write("0\n");
f1.write("0\n");
f0.write("0\n");
else:
f3.write(line[0:2] + '\n');
f2.write(line[2:4] + '\n');
f1.write(line[4:6] + '\n');
f0.write(line[6:8] + '\n');
| StarcoderdataPython |
1688283 | import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = <KEY>
# Database
# https://docs.djangoproject.com/en/2.1/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'qqaynkbi',
'USER': 'qqaynkbi',
'PASSWORD': '<PASSWORD>',
'HOST': 'horton.elephantsql.com',
'PORT': '5432',
}
}
| StarcoderdataPython |
1756870 | <gh_stars>10-100
# -*- coding: utf-8 -*- vim:fileencoding=utf-8:
"Error handler tailored for Palo Alto (PANOS) devices."
from .default import DefaultErrorHandler
import re
class PanosErrorHandler(DefaultErrorHandler):
_ERROR_MATCHES = [
re.compile(r'invalid', flags=re.I),
re.compile(r'error', flags=re.I),
re.compile(r'unknown', flags=re.I),
re.compile(r'incomplete', flags=re.I),
re.compile(r'ambiguous', flags=re.I),
]
def __init__(self, personality):
super(PanosErrorHandler, self).__init__(personality)
def has_error(self, output):
if any(m.search(output) for m in self._ERROR_MATCHES):
return True
return False
| StarcoderdataPython |
1612786 | from random import choice
sample_requests = [
"Get me a cheeseburger!",
"May I obtain a burrito?",
"I want a gyro"
]
def init_confirm():
return "Everything's set up now! Send me a request like \"" + choice(sample_requests) + "\""
def order_confirm(item, restaurant, cost, delivery_time):
start_strs = [
"How'd you like a " + item + " from " + restaurant + "?",
"How does a " + item + " from " + restaurant + " Sound?",
"I can get you a " + item + " from " + restaurant + ", sound good?",
"Would you like a " + item + " from " + restaurant + "?",
"Should I order you a " + item + " from " + restaurant + "?"
]
end_str = " That would cost $" + cost + ", and should be delivered in " + delivery_time + " minutes."
return choice(start_strs) + end_str
def misunderstood_order():
return "Sorry, I had trouble understanding that... Try a simpler request, like \"" + choice(sample_requests) + "\""
| StarcoderdataPython |
1672868 | # -*- coding: UTF-8 -*-
from Stock import Stock
import numpy as np
import os
import json
import sys
import time
import datetime
def getAllFiles(dirname="../sync_data/download"):
files = None
for dirpath, dirnames, filenames in os.walk(dirname):
files = [os.path.join(dirpath, filename) for filename in filenames if
filename.startswith('SH') or filename.startswith("SZ")]
return files
def getFile(symbol):
files = getAllFiles()
if not files == None:
return [filename for filename in files if symbol in filename]
return None
# s = Stock(getFile("002673")[0])
# with open('002673.json','w+') as f:
# json.dump(s.__dict__,f)
result = []
files = getAllFiles()
l = len(files)
i = 1
beginTime = time.time()
curDate = datetime.date(2016, 12, 26)
for file in files:
sys.stdout.write('\r%s/%s \' %s is found \' %s' % (i, l, len(result), time.time() - beginTime))
stock = Stock(file)
if stock.length() > 100:
if stock.datas[-1]['date'] == curDate and stock.datas[-1]['open'] < 1000.:
if stock.datas[-1]['volume'] >= 100000 and stock.macd[-1] >= 0 and stock.macd[-2] <= stock.macd[-1]:
result.extend([stock.symbol])
i += 1
sys.stdout.write('\n')
print(time.time() - beginTime)
with open('output/filter1_{:%Y-%m-%d}.txt'.format(curDate), 'w+') as f:
f.write('\n'.join(result))
| StarcoderdataPython |
1697340 | import math
def is_prime(n):
if n < 2:
return False
elif n < 4:
return True
else:
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
T = int(input().strip())
for t in range(T):
n = int(input().strip())
print("Prime" if is_prime(n) else "Not prime")
| StarcoderdataPython |
1606860 | # This file is part of Flask-Multipass-CERN.
# Copyright (C) 2020 - 2021 CERN
#
# Flask-Multipass-CERN is free software; you can redistribute
# it and/or modify it under the terms of the MIT License; see
# the LICENSE file for more details.
import logging
from datetime import datetime
from functools import wraps
from importlib import import_module
from inspect import getcallargs
from authlib.integrations.requests_client import OAuth2Session
from flask import current_app, g, has_request_context
from flask_multipass import IdentityRetrievalFailed
from flask_multipass.data import IdentityInfo
from flask_multipass.exceptions import MultipassException
from flask_multipass.group import Group
from flask_multipass.identity import IdentityProvider
from flask_multipass.providers.authlib import AuthlibAuthProvider, _authlib_oauth
from requests.adapters import HTTPAdapter
from requests.exceptions import RequestException
from urllib3 import Retry
CACHE_LONG_TTL = 86400 * 2
CACHE_TTL = 1800
CERN_OIDC_WELLKNOWN_URL = 'https://auth.cern.ch/auth/realms/cern/.well-known/openid-configuration'
HTTP_RETRY_COUNT = 5
retry_config = HTTPAdapter(max_retries=Retry(total=HTTP_RETRY_COUNT,
status_forcelist=[503, 504],
allowed_methods=frozenset(['GET']),
raise_on_status=False))
_cache_miss = object()
class ExtendedCache:
def __init__(self, cache):
self.cache = self._init_cache(cache)
def _init_cache(self, cache):
if cache is None:
return None
elif callable(cache):
return cache()
elif isinstance(cache, str):
module_path, class_name = cache.rsplit('.', 1)
module = import_module(module_path)
return getattr(module, class_name)
else:
return cache
def get(self, key, default=None):
if self.cache is None:
return default
return self.cache.get(key, default)
def set(self, key, value, timeout=0, refresh_timeout=None):
if self.cache is None:
return
self.cache.set(key, value, timeout)
if refresh_timeout:
self.cache.set(f'{key}:timestamp', datetime.now(), refresh_timeout)
def should_refresh(self, key):
if self.cache is None:
return True
return self.cache.get(f'{key}:timestamp') is None
def memoize_request(f):
@wraps(f)
def memoizer(*args, **kwargs):
if not has_request_context() or current_app.config['TESTING'] or current_app.config.get('REPL'):
# No memoization outside request context
return f(*args, **kwargs)
try:
cache = g._cern_multipass_memoize
except AttributeError:
g._cern_multipass_memoize = cache = {}
key = (f.__module__, f.__name__, make_hashable(getcallargs(f, *args, **kwargs)))
if key not in cache:
cache[key] = f(*args, **kwargs)
return cache[key]
return memoizer
def make_hashable(obj):
if isinstance(obj, (list, set)):
return tuple(obj)
elif isinstance(obj, dict):
return frozenset((k, make_hashable(v)) for k, v in obj.items())
return obj
def normalize_cern_person_id(value):
"""Normalize the CERN person ID.
We always want a string or None if it's missing.
"""
if value is None:
return None
elif isinstance(value, int):
return str(value)
elif not value:
return None
else:
return value
class CERNAuthProvider(AuthlibAuthProvider):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.include_token = True
@property
def authlib_settings(self):
settings = dict(self.settings['authlib_args'])
settings.setdefault('server_metadata_url', CERN_OIDC_WELLKNOWN_URL)
# XXX should we request any other scopes?
settings.setdefault('client_kwargs', {'scope': 'openid'})
return settings
class CERNGroup(Group):
supports_member_list = True
def get_members(self):
assert '/' not in self.name
with self.provider._get_api_session() as api_session:
group_data = self.provider._get_group_data(self.name)
if group_data is None:
return
gid = group_data['id']
params = {
'limit': 5000,
'field': [
'upn',
'firstName',
'lastName',
'instituteName',
'telephone1',
'primaryAccountEmail',
'cernPersonId',
],
'recursive': 'true'
}
results = self.provider._fetch_all(api_session, f'/api/v1.0/Group/{gid}/memberidentities', params)[0]
for res in results:
del res['id'] # id is always included
self.provider._fix_phone(res)
identifier = res.pop('upn')
extra_data = self.provider._extract_extra_data(res)
yield IdentityInfo(self.provider, identifier, extra_data, **res)
def has_member(self, identifier):
cache = self.provider.cache
logger = self.provider.logger
cache_key = f'flask-multipass-cern:{self.provider.name}:groups:{identifier}'
all_groups = cache.get(cache_key)
if all_groups is None or cache.should_refresh(cache_key):
try:
all_groups = {g.name.lower() for g in self.provider.get_identity_groups(identifier)}
cache.set(cache_key, all_groups, CACHE_LONG_TTL, CACHE_TTL)
except RequestException:
logger.warning('Refreshing user groups failed for %s', identifier)
if all_groups is None:
logger.error('Getting user groups failed for %s, access will be denied', identifier)
return False
if self.provider.settings['cern_users_group'] and self.name.lower() == 'cern users':
return self.provider.settings['cern_users_group'].lower() in all_groups
return self.name.lower() in all_groups
class CERNIdentityProvider(IdentityProvider):
supports_refresh = True
supports_get = False
supports_search = True
supports_search_ex = True
supports_groups = True
supports_get_identity_groups = True
group_class = CERNGroup
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.authlib_client = _authlib_oauth.register(self.name + '-idp', **self.authlib_settings)
self.settings.setdefault('cache', None)
self.settings.setdefault('extra_search_filters', [])
self.settings.setdefault('authz_api', 'https://authorization-service-api.web.cern.ch')
self.settings.setdefault('phone_prefix', '+412276')
self.settings.setdefault('cern_users_group', None)
self.settings.setdefault('logger_name', 'multipass.cern')
self.logger = logging.getLogger(self.settings['logger_name'])
self.cache = ExtendedCache(self.settings['cache'])
if not self.settings.get('mapping'):
# usually mapping is empty, in that case we set some defaults
self.settings['mapping'] = {
'first_name': 'firstName',
'last_name': 'lastName',
'affiliation': 'instituteName',
'phone': 'telephone1',
'email': 'primaryAccountEmail',
}
@property
def authlib_settings(self):
settings = dict(self.settings['authlib_args'])
settings.setdefault('server_metadata_url', CERN_OIDC_WELLKNOWN_URL)
return settings
@property
def authz_api_base(self):
return self.settings['authz_api'].rstrip('/')
def refresh_identity(self, identifier, multipass_data):
data = self._get_identity_data(identifier)
self._fix_phone(data)
identifier = data.pop('upn')
extra_data = self._extract_extra_data(data)
return IdentityInfo(self, identifier, extra_data, **data)
def _fix_phone(self, data):
phone = data.get('telephone1')
if not phone or phone.startswith('+'):
return
data['telephone1'] = self.settings['phone_prefix'] + phone
def _extract_extra_data(self, data, default=None):
return {'cern_person_id': normalize_cern_person_id(data.pop('cernPersonId', default))}
def get_identity_from_auth(self, auth_info):
upn = auth_info.data.get('sub')
groups = auth_info.data.get('groups')
cache_key_prefix = f'flask-multipass-cern:{self.name}'
if groups is not None:
groups = {x.lower() for x in groups}
cache_key = f'{cache_key_prefix}:groups:{upn}'
self.cache.set(cache_key, groups, CACHE_LONG_TTL, CACHE_TTL)
try:
data = self._fetch_identity_data(auth_info)
# check for data mismatches between our id token and authz
self._compare_data(auth_info.data, data)
phone = data.get('telephone1')
affiliation = data.get('instituteName')
self.cache.set(f'{cache_key_prefix}:phone:{upn}', phone, CACHE_LONG_TTL)
self.cache.set(f'{cache_key_prefix}:affiliation:{upn}', affiliation, CACHE_LONG_TTL)
except RequestException:
self.logger.warning('Getting identity data for %s failed', upn)
phone = self.cache.get(f'{cache_key_prefix}:phone:{upn}', _cache_miss)
affiliation = self.cache.get(f'{cache_key_prefix}:affiliation:{upn}', _cache_miss)
if phone is _cache_miss or affiliation is _cache_miss:
self.logger.error('Getting identity data for %s failed without cache fallback', upn)
raise IdentityRetrievalFailed('Retrieving identity information from CERN SSO failed', provider=self)
data = {
'firstName': auth_info.data['given_name'],
'lastName': auth_info.data['family_name'],
'displayName': auth_info.data['name'],
'telephone1': phone,
'instituteName': affiliation,
'primaryAccountEmail': auth_info.data['email'],
}
self._fix_phone(data)
data.pop('upn', None)
extra_data = self._extract_extra_data(data, normalize_cern_person_id(auth_info.data.get('cern_person_id')))
return IdentityInfo(self, upn, extra_data, **data)
def search_identities(self, criteria, exact=False):
return iter(self.search_identities_ex(criteria, exact=exact)[0])
@memoize_request
def search_identities_ex(self, criteria, exact=False, limit=None):
emails_key = '-'.join(sorted(x.lower() for x in criteria['primaryAccountEmail']))
cache_key = f'flask-multipass-cern:{self.name}:email-identities:{emails_key}'
use_cache = exact and limit is None and len(criteria) == 1 and 'primaryAccountEmail' in criteria
if use_cache:
cached_data = self.cache.get(cache_key)
if cached_data:
cached_results = []
for res in cached_data[0]:
identifier = res.pop('upn')
extra_data = self._extract_extra_data(res)
cached_results.append(IdentityInfo(self, identifier, extra_data, **res))
if not self.cache.should_refresh(cache_key):
return cached_results, cached_data[1]
if any(len(x) != 1 for x in criteria.values()):
# Unfortunately the API does not support OR filters (yet?).
# Fortunately we never search for more than one value anyway, except for emails when
# looking up identities based on the user's email address.
if len(criteria) != 1:
raise MultipassException('This provider does not support multiple values for a search criterion',
provider=self)
field, values = dict(criteria).popitem()
seen = set()
total = 0
all_identities = []
for value in values:
identities = self.search_identities_ex({field: [value]}, exact=exact, limit=limit)[0]
for identity in identities:
if identity.identifier not in seen:
seen.add(identity.identifier)
all_identities.append(identity)
total += 1
return all_identities, total
criteria = {k: next(iter(v)) for k, v in criteria.items()}
op = 'eq' if exact else 'contains'
api_criteria = [f'{k}:{op}:{v}' for k, v in criteria.items()]
api_criteria.append('type:eq:Person')
api_criteria += self.settings['extra_search_filters']
params = {
'limit': limit or 5000,
'filter': api_criteria,
'field': [
'upn',
'firstName',
'lastName',
'displayName',
'instituteName',
'telephone1',
'primaryAccountEmail',
'cernPersonId',
],
}
with self._get_api_session() as api_session:
results = []
total = 0
try:
results, total = self._fetch_all(api_session, '/api/v1.0/Identity', params, limit=limit)
except RequestException:
self.logger.warning('Refreshing identities failed for criteria %s', criteria)
if use_cache and cached_data:
return cached_results, cached_data[1]
else:
self.logger.error('Getting identities failed for criteria %s', criteria)
raise
identities = []
cache_data = []
for res in results:
if not res['upn']:
total -= 1
continue
del res['id']
self._fix_phone(res)
res_copy = dict(res)
identifier = res_copy.pop('upn')
extra_data = self._extract_extra_data(res_copy)
identities.append(IdentityInfo(self, identifier, extra_data, **res_copy))
if use_cache:
cache_data.append(res)
if use_cache:
self.cache.set(cache_key, (cache_data, total), CACHE_LONG_TTL, CACHE_TTL * 2)
return identities, total
def get_identity_groups(self, identifier):
with self._get_api_session() as api_session:
resp = api_session.get(f'{self.authz_api_base}/api/v1.0/IdentityMembership/{identifier}/precomputed')
if resp.status_code == 404 or resp.status_code == 500:
return set()
resp.raise_for_status()
results = resp.json()['data']
return {self.group_class(self, res['groupIdentifier']) for res in results}
def get_group(self, name):
return self.group_class(self, name)
def search_groups(self, name, exact=False):
op = 'eq' if exact else 'contains'
params = {
'limit': 5000,
'filter': [f'groupIdentifier:{op}:{name}'],
'field': ['groupIdentifier'],
}
with self._get_api_session() as api_session:
results = self._fetch_all(api_session, '/api/v1.0/Group', params)[0]
rv = {self.group_class(self, res['groupIdentifier']) for res in results}
if (
self.settings['cern_users_group'] and
(name.lower() == 'cern users' or (not exact and name.lower() in 'cern users'))
):
rv.add(self.group_class(self, 'CERN Users'))
return rv
@memoize_request
def _get_api_session(self):
cache_key = f'flask-multipass-cern:{self.name}:api-token'
token = self.cache.get(cache_key)
if token:
oauth_session = OAuth2Session(token=token)
oauth_session.mount(self.authz_api_base, retry_config)
return oauth_session
meta = self.authlib_client.load_server_metadata()
token_endpoint = meta['token_endpoint'].replace('protocol/openid-connect', 'api-access')
oauth_session = OAuth2Session(
self.authlib_client.client_id,
self.authlib_client.client_secret,
token_endpoint=token_endpoint,
grant_type='client_credentials',
)
oauth_session.mount(self.authz_api_base, retry_config)
oauth_session.fetch_access_token(
audience='authorization-service-api',
headers={'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'},
)
self.cache.set(cache_key, oauth_session.token, oauth_session.token['expires_in'] - 30)
return oauth_session
def _fetch_identity_data(self, auth_info):
# Exchange the user token to one for the authorization API
user_api_token = self.authlib_client.fetch_access_token(
grant_type='urn:ietf:params:oauth:grant-type:token-exchange',
subject_token_type='urn:ietf:params:oauth:token-type:access_token',
audience='authorization-service-api',
subject_token=auth_info.data['token']['access_token'],
)
params = {
'field': [
'upn',
'firstName',
'lastName',
'instituteName',
'telephone1',
'primaryAccountEmail',
'cernPersonId',
],
}
resp = self.authlib_client.get(f'{self.authz_api_base}/api/v1.0/Identity/current', token=user_api_token,
params=params)
resp.raise_for_status()
data = resp.json()['data']
del data['id'] # id is always included
return data
def _fetch_all(self, api_session, endpoint, params, limit=None):
results = []
resp = api_session.get(self.authz_api_base + endpoint, params=params)
resp.raise_for_status()
data = resp.json()
total = data['pagination']['total']
while True:
results += data['data']
if not data['pagination']['next'] or (limit is not None and len(results) >= limit):
break
resp = api_session.get(self.authz_api_base + data['pagination']['next'])
resp.raise_for_status()
data = resp.json()
if limit is not None:
# in case we got too many results due to a large last page
results = results[:limit]
return results, total
@memoize_request
def _get_group_data(self, name):
params = {
'filter': [f'groupIdentifier:eq:{name}'],
'field': ['id', 'groupIdentifier'],
}
with self._get_api_session() as api_session:
resp = api_session.get(f'{self.authz_api_base}/api/v1.0/Group', params=params)
resp.raise_for_status()
data = resp.json()
if len(data['data']) != 1:
return None
return data['data'][0]
def _get_identity_data(self, identifier):
params = {
'field': [
'upn',
'firstName',
'lastName',
'displayName',
'instituteName',
'telephone1',
'primaryAccountEmail',
'cernPersonId',
]
}
with self._get_api_session() as api_session:
resp = api_session.get(f'{self.authz_api_base}/api/v1.0/Identity/{identifier}', params=params)
resp.raise_for_status()
data = resp.json()
return data['data']
def _compare_data(self, token_data, api_data):
fields_to_compare = [
('sub', 'upn'),
('given_name', 'firstName'),
('family_name', 'lastName'),
('email', 'primaryAccountEmail'),
('cern_person_id', 'cernPersonId'),
]
for token_field, api_field in fields_to_compare:
token_value = str(token_data.get(token_field, ''))
api_value = str(api_data.get(api_field, ''))
if token_value != api_value:
self.logger.warning('Field %s mismatch for %s: %s in id_token, %s in authz api',
token_field, token_data['sub'], token_value, api_value)
| StarcoderdataPython |
183458 | km = float(input('Qual vai ser a distância da viagem: '))
if km <= 200:
print('O valor a ser pago é de: R${:.2f}'.format(km * 0.50))
else:
print('O valor a ser pago é de: R${:.2f}'.format(km * 0.45)) | StarcoderdataPython |
1622975 | vulners_api_key = "" | StarcoderdataPython |
1721331 | '''
Function:
定义金币等掉落的物品
Author:
Charles
微信公众号:
Charles的皮卡丘
'''
import pygame
import random
'''定义食物类'''
class Food(pygame.sprite.Sprite):
def __init__(self, images_dict, selected_key, screensize, **kwargs):
pygame.sprite.Sprite.__init__(self)
self.screensize = screensize
self.image = images_dict[selected_key]
self.mask = pygame.mask.from_surface(self.image)
self.rect = self.image.get_rect()
self.rect.left, self.rect.bottom = random.randint(20, screensize[0]-20), -10
self.speed = random.randrange(5, 10)
self.score = 1 if selected_key == 'gold' else 5
'''更新食物位置'''
def update(self):
self.rect.bottom += self.speed
if self.rect.top > self.screensize[1]:
return True
return False | StarcoderdataPython |
1797223 | <gh_stars>1-10
# coding=utf-8
# Copyright 2022 The OpenBMB team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import math
import torch
import bmtrain as bmt
import torch.nn.functional as F
class RelativePositionEmbedding(bmt.DistributedModule):
""" Relative Position Embedding <https://arxiv.org/abs/1803.02155>
Args:
num_heads (int): number of heads used in attention module.
num_buckets (int, optional): Defaults to 32.
max_distance (int, optional): Defaults to 128.
bidirectional (bool, optional): Defaults to False.
dtype (optional): Defaults to torch.half.
init_mean (float, optional): Defaults to 0.0.
init_std (float, optional): Defaults to 1.
"""
def __init__(self, num_heads : int,
num_buckets : int = 32,
max_distance : int = 128,
bidirectional : bool = False,
dtype = torch.half,
init_mean : float = 0.0,
init_std : float = 1,
):
super().__init__()
self.relative_attention_bias = bmt.DistributedParameter(
torch.empty(num_buckets, num_heads, dtype = dtype),
init_method = bmt.ParameterInitializer(torch.nn.init.normal_, mean = init_mean, std = init_std)
)
self.num_heads = num_heads
self.num_buckets = num_buckets
self.max_distance = max_distance
self.bidirectional = bidirectional
def forward(self, query_len, key_len):
""" Provides relative position embeddings for key and query of `num_heads` attention heads.
Args:
query_len (:obj:`int`): Length of query.
key_len (:obj:`int`): Length of key.
Return:
:obj:`torch.Tensor` of shape ``(num_heads, query_len, key_len)``: Relative position embedding.
"""
part_buckets = self.num_buckets // (2 if self.bidirectional else 1)
exact_buckets = part_buckets // 2
log_buckets = part_buckets - exact_buckets
pos_q = torch.arange(query_len, dtype=torch.long, device="cuda")
pos_k = torch.arange(key_len, dtype=torch.long, device="cuda")
relative_position = pos_q[:, None] - pos_k[None, :] # (query_len, key_len)
neg_pos = relative_position < 0
relative_position = relative_position.abs()
small_pos = relative_position < exact_buckets
log_pos = (torch.clamp(
torch.log(relative_position.float() / exact_buckets) / math.log(self.max_distance / exact_buckets),
0,
0.9999
) * log_buckets).long() + exact_buckets
buckets = torch.where(small_pos, relative_position, log_pos)
if self.bidirectional:
buckets = torch.where(
neg_pos,
buckets + part_buckets,
buckets
)
else:
buckets = torch.masked_fill(
buckets,
neg_pos,
0,
)
return F.embedding(buckets, self.relative_attention_bias, padding_idx = -1).permute(2, 0, 1).contiguous()
class RotaryEmbedding(torch.nn.Module):
"""`Rotary Position Embedding <https://arxiv.org/abs/2104.09864v2>
Args:
rotary_dim (int): rotary dimension
"""
def __init__(self, rotary_dim: int):
# Implementation reference https://github.com/huggingface/transformers/blob/master/src/transformers/models/gptj/modeling_gptj.py
super().__init__()
self.rotary_dim = rotary_dim
def fixed_pos_embedding(self, x, seq_len=None, dtype = torch.float):
dim = x.shape[-1]
inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2) / dim))
sinusoid_inp = torch.einsum("i , j -> i j", torch.arange(seq_len), inv_freq).to(x.device).to(dtype)
return torch.sin(sinusoid_inp), torch.cos(sinusoid_inp)
def rotate_every_two(self, x):
if x.dim() == 4:
x1 = x[:, :, :, ::2]
x2 = x[:, :, :, 1::2]
else:
x1 = x[:, :, ::2]
x2 = x[:, :, 1::2]
x = torch.stack((-x2, x1), axis=-1)
return x.flatten(-2) # in einsum notation: rearrange(x, '... d j -> ... (d j)')
def apply_rotary_pos_emb(self, x, sincos, offset=0):
sin, cos = map(lambda t: t[None, offset : x.shape[-2] + offset, :].repeat_interleave(2, 2), sincos)
# einsum notation for lambda t: repeat(t[offset:x.shape[1]+offset,:], "n d -> () n () (d j)", j=2)
return (x * cos) + (self.rotate_every_two(x) * sin)
def forward(self, h_q, h_k):
"""
Args:
h_q : (batch_size, num_head, len_q, dim_head)
h_k : (batch_size, k_num_head, len_k, dim_head)
Return:
h_q : (batch_size, num_head, len_q, dim_head)
h_k : (batch_size, k_num_head, len_k, dim_head)
"""
if h_q.dim() == 4:
q_rot = h_q[:, :, :, :self.rotary_dim]
q_pass = h_q[:, :, :, self.rotary_dim:]
k_rot = h_k[:, :, :, :self.rotary_dim]
k_pass = h_k[:, :, :, self.rotary_dim:]
else:
q_rot = h_q[:, :, :self.rotary_dim]
q_pass = h_q[:, :, self.rotary_dim:]
k_rot = h_k[:, :, :self.rotary_dim]
k_pass = h_k[:, :, self.rotary_dim:]
seq_len = h_k.shape[-2]
sincos = self.fixed_pos_embedding(k_rot, seq_len=seq_len, dtype=h_k.dtype)
k_rot = self.apply_rotary_pos_emb(k_rot, sincos, offset=0)
q_rot = self.apply_rotary_pos_emb(q_rot, sincos, offset=0)
h_q = torch.cat([q_rot, q_pass], dim=-1)
h_k = torch.cat([k_rot, k_pass], dim=-1)
return h_q, h_k
class SegmentPositionEmbedding(bmt.DistributedModule):
def __init__(self, num_heads,
num_segments = 1,
num_buckets = 32,
max_distance = 128,
bidirectional = False,
dtype = torch.half,
absolute_inner_segment = True,
init_mean : float = 0.0,
init_std : float = 1
):
super().__init__()
self.num_heads = num_heads
self.num_buckets = num_buckets
self.max_distance = max_distance
self.bidirectional = bidirectional
self.num_segments = num_segments
self.absolute_inner_segment = absolute_inner_segment
self.relative_attention_bias = bmt.DistributedParameter(
torch.empty(num_segments * num_segments + num_buckets, num_heads, dtype = dtype),
init_method = bmt.ParameterInitializer(torch.nn.init.normal_, mean = init_mean, std = init_std)
)
def forward(self, key_pos = None, query_pos = None, key_segment = None, query_segment = None):
"""
Args:
key_len: int
query_len : int
Returns:
out : (batch_size, num_heads, query_len, key_len) fp16
"""
with torch.no_grad():
batch = key_pos.size(0)
keylen = key_pos.size(1)
querylen = query_pos.size(1)
assert key_pos.size(0) == query_pos.size(0)
assert keylen == key_segment.size(1) and querylen == query_segment.size(1)
key_pos = key_pos.view(batch, -1, keylen)
query_pos = query_pos.view(batch, querylen, -1)
key_segment = key_segment.view(batch, -1, keylen)
query_segment = query_segment.view(batch, querylen, -1)
relative_position_bucket = self._segment_relative_position_bucket(query_segment, key_segment)
relative_position_bucket = relative_position_bucket + self.num_buckets # 与相对位置编码区间不重叠
# b*q*k
if self.absolute_inner_segment:
absolute_position_bucket = self._absolute_position_bucket(
torch.arange(keylen, dtype=torch.int32, device=relative_position_bucket.device)[None, :] - torch.arange(querylen, dtype=torch.int32, device=relative_position_bucket.device)[:, None],
bidirectional=self.bidirectional,
num_buckets=self.num_buckets,
max_distance = self.max_distance
)
relative_position_bucket = torch.where((key_segment == query_segment), absolute_position_bucket[None, :, :], relative_position_bucket)
# (batch, len_q, len_k)
# (batch, len_q, len_k, num_heads)
embeds = F.embedding(relative_position_bucket, self.relative_attention_bias)
# (batch, num_heads, len_q, len_k)
embeds = embeds.permute(0, 3, 1, 2).contiguous()
return embeds
def _relative_position_bucket(self, relative_position, bidirectional=True, num_buckets = 32, max_exact=0.125, max_distance=0.5):
relative_buckets = 0
if bidirectional:
num_buckets //= 2
max_exact /= 2
relative_buckets = (relative_position > 0).to(torch.int32) * num_buckets
relative_position = torch.abs(relative_position)
else:
relative_position = -torch.min(relative_position, torch.zeros_like(relative_position))
max_exact /= 2
is_small = relative_position < max_exact
half_num_buckets = num_buckets // 2
relative_postion_if_large = half_num_buckets + (torch.log(relative_position / max_exact) / math.log(max_distance / max_exact) * (num_buckets - half_num_buckets)).to(torch.int32)
relative_postion_if_large = torch.min(relative_postion_if_large, torch.full_like(relative_postion_if_large, num_buckets - 1))
relative_buckets += torch.where(is_small, (relative_position / max_exact * half_num_buckets).to(torch.int32), relative_postion_if_large)
return relative_buckets
def _segment_relative_position_bucket(self, query_segment, key_segment):
return query_segment * self.num_segments + key_segment
def _absolute_position_bucket(self, relative_position, bidirectional=True, num_buckets=32, max_distance=128):
relative_buckets = 0
if bidirectional:
num_buckets //= 2
relative_buckets = (relative_position > 0).to(torch.int32) * num_buckets
relative_position = torch.abs(relative_position)
else:
relative_position = -torch.min(relative_position, torch.zeros_like(relative_position))
max_exact = num_buckets // 2
is_small = relative_position < max_exact
relative_postion_if_large = max_exact + (torch.log(relative_position.float() / max_exact) / math.log(max_distance / max_exact) * (num_buckets - max_exact)).to(torch.int32)
relative_postion_if_large = torch.min(relative_postion_if_large, torch.full_like(relative_postion_if_large, num_buckets - 1))
relative_buckets += torch.where(is_small, relative_position.to(torch.int32), relative_postion_if_large)
return relative_buckets
| StarcoderdataPython |
1614095 | # Add all the torch configs here
import hddm
import pickle
import os
class TorchConfig(object):
def __init__(self, model=None):
self.network_files = {
"ddm": "d27193a4153011ecb76ca0423f39a3e6_ddm_torch_state_dict.pt",
"angle": "eba53550128911ec9fef3cecef056d26_angle_torch_state_dict.pt",
"levy": "80dec298152e11ec88b8ac1f6bfea5a4_levy_torch_state_dict.pt",
"ornstein": "1f496b50127211ecb6943cecef057438_ornstein_torch_state_dict.pt",
"weibull": "44deb16a127f11eca325a0423f39b436_weibull_torch_state_dict.pt",
"ddm_par2_no_bias": "495136c615d311ecb5fda0423f39a3e6_par2_no_bias_torch_state_dict.pt",
"ddm_seq2_no_bias": "247aa76015d311ec922d3cecef057012_seq2_no_bias_torch_state_dict.pt",
"ddm_mic2_adj_no_bias": "049de8c23cba11ecb507a0423f3e9a4a_ddm_mic2_adj_no_bias_torch_state_dict.pt",
"ddm_par2_angle_no_bias": "c611f4ca15dd11ec89543cecef056d26_par2_angle_no_bias_torch_state_dict.pt",
"ddm_seq2_angle_no_bias": "7821dc4c15f811eca1553cecef057012_seq2_angle_no_bias_torch_state_dict.pt",
"ddm_mic2_adj_angle_no_bias": "122c7ca63cc411eca89b3cecef05595c_ddm_mic2_adj_angle_no_bias_torch_state_dict.pt",
"ddm_par2_weibull_no_bias": "a5e6bbc2160f11ec88173cecef056d26_par2_weibull_no_bias_torch_state_dict.pt",
"ddm_seq2_weibull_no_bias": "74ca5d6c161b11ec9ebb3cecef056d26_seq2_weibull_no_bias_torch_state_dict.pt",
"ddm_mic2_adj_weibull_no_bias": "151a6c363ccc11ecbf89a0423f3e9b68_ddm_mic2_adj_weibull_no_bias_torch_state_dict.pt",
"lca_no_bias_4": "0d9f0e94175b11eca9e93cecef057438_lca_no_bias_4_torch_state_dict.pt",
"lca_no_bias_angle_4": "362f8656175911ecbe8c3cecef057438_lca_no_bias_angle_4_torch_state_dict.pt",
"race_no_bias_4": "ff29c116173611ecbdba3cecef05595c_race_no_bias_4_torch_state_dict.pt",
"race_no_bias_angle_4": "179c5a6e175111ec93f13cecef056d26_race_no_bias_angle_4_torch_state_dict.pt",
}
self.network_config_files = {
"ddm": "d27193a4153011ecb76ca0423f39a3e6_ddm_torch__network_config.pickle",
"angle": "eba53550128911ec9fef3cecef056d26_angle_torch__network_config.pickle",
"levy": "80dec298152e11ec88b8ac1f6bfea5a4_levy_torch__network_config.pickle",
"ornstein": "1f496b50127211ecb6943cecef057438_ornstein_torch__network_config.pickle",
"weibull": "44deb16a127f11eca325a0423f39b436_weibull_torch__network_config.pickle",
"ddm_par2_no_bias": "495136c615d311ecb5fda0423f39a3e6_par2_no_bias_torch__network_config.pickle",
"ddm_seq2_no_bias": "247aa76015d311ec922d3cecef057012_seq2_no_bias_torch__network_config.pickle",
"ddm_mic2_adj_no_bias": "049de8c23cba11ecb507a0423f3e9a4a_ddm_mic2_adj_no_bias_torch__network_config.pickle",
"ddm_par2_angle_no_bias": "c611f4ca15dd11ec89543cecef056d26_par2_angle_no_bias_torch__network_config.pickle",
"ddm_seq2_angle_no_bias": "7821dc4c15f811eca1553cecef057012_seq2_angle_no_bias_torch__network_config.pickle",
"ddm_mic2_adj_angle_no_bias": "122c7ca63cc411eca89b3cecef05595c_ddm_mic2_adj_angle_no_bias_torch__network_config.pickle",
"ddm_par2_weibull_no_bias": "a5e6bbc2160f11ec88173cecef056d26_par2_weibull_no_bias_torch__network_config.pickle",
"ddm_seq2_weibull_no_bias": "74ca5d6c161b11ec9ebb3cecef056d26_seq2_weibull_no_bias_torch__network_config.pickle",
"ddm_mic2_adj_weibull_no_bias": "151a6c363ccc11ecbf89a0423f3e9b68_ddm_mic2_adj_weibull_no_bias_torch__network_config.pickle",
"lca_no_bias_4": "0d9f0e94175b11eca9e93cecef057438_lca_no_bias_4_torch__network_config.pickle",
"lca_no_bias_angle_4": "362f8656175911ecbe8c3cecef057438_lca_no_bias_angle_4_torch__network_config.pickle",
"race_no_bias_4": "ff29c116173611ecbdba3cecef05595c_race_no_bias_4_torch__network_config.pickle",
"race_no_bias_angle_4": "179c5a6e175111ec93f13cecef056d26_race_no_bias_angle_4_torch__network_config.pickle",
}
self.network_config = self.get_network_config(
file_name=self.network_config_files[model]
)
self.network_path = os.path.join(
hddm.__path__[0], "torch_models", self.network_files[model]
)
def get_network_config(self, file_name=None):
with open(os.path.join(hddm.__path__[0], "torch_models", file_name), "rb") as f:
network_config = pickle.load(f)
return network_config
# network_configs =
# network_configs['ddm'] = {'layer_types': ['dense', 'dense', 'dense', 'dense'],
# 'layer_sizes': [100, 100, 100, 1],
# 'activations': ['tanh', 'tanh', 'tanh', 'linear'],
# 'loss': 'huber',
# 'callbacks': ['checkpoint', 'earlystopping', 'reducelr'],
# 'model_id': 'ddm'}
# return network_configs[model]
| StarcoderdataPython |
3330759 | class InternalRequestError(Exception):
"""
Raised when getting content from a url fails. This could be due to a network error, bad url, bad request, bad status, etc.
"""
class UnknownContentType(Exception):
"""
Raised when the content type of the response is not known.
"""
| StarcoderdataPython |
1765082 | #!/usr/bin/env python
# Copyright (c) 2016 Hewlett Packard Enterprise Development Company, L.P.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import copy
import monasca_analytics.banana.grammar.ast as ast
import monasca_analytics.banana.typeck.type_util as util
import monasca_analytics.exception.banana as exception
import monasca_analytics.util.string_util as strut
import six
class TypeTable(object):
"""
Type table. Support lookup for JsonLike object.
Json-like object have properties that needs to be
type-checked. The TypeTable allows to store
that information as well. All type values are
rooted by their variable name.
Every-time a variable type is erased, we create a new
snapshot of the variables types. This allow to have
variable where the type change as the statement are
being executed.
"""
def __init__(self):
self._variables_snapshots = [(0, {})]
self._variables = self._variables_snapshots[0][1]
def get_type(self, var, statement_index=None):
variables = self.get_variables(statement_index)
if isinstance(var, ast.Ident):
if var in variables:
return variables[var]
else:
raise exception.BananaUnknown(var)
# If we encounter a dot path:
if isinstance(var, ast.DotPath):
if var.varname in variables:
if len(var.properties) > 0:
return variables[var.varname][var.next_dot_path()]
else:
return variables[var.varname]
else:
raise exception.BananaUnknown(var.varname)
raise exception.BananaTypeCheckerBug("Unkown type for {}".format(var))
def set_type(self, var, _type, statement_index):
"""
Set the type for the given var to _type.
:type var: ast.Ident | ast.DotPath
:param var: The var to set a type.
:type _type: util.Object | util.Component | util.String | util.Number
:param _type: The type for the var.
:type statement_index: int
:param statement_index: The statement at which this assignment was
made.
"""
if _type is None:
raise exception.BananaTypeCheckerBug(
"'None' is not a valid banana type"
)
if isinstance(var, ast.Ident):
self._check_needs_for_snapshot(var, _type, statement_index)
self._variables[var] = _type
return
if isinstance(var, ast.DotPath):
if util.is_comp(_type) and len(var.properties) > 0:
raise exception.BananaAssignCompError(var.span)
if len(var.properties) == 0:
self._check_needs_for_snapshot(
var.varname,
_type,
statement_index
)
self._variables[var.varname] = _type
else:
if var.varname in self._variables:
var_type = self._variables[var.varname]
if isinstance(var_type, util.Object):
new_type = util.create_object_tree(
var.next_dot_path(), _type)
util.attach_to_root(var_type, new_type, var.span,
erase_existing=True)
elif isinstance(var_type, util.Component):
var_type[var.next_dot_path()] = _type
else:
raise exception.BananaTypeError(
expected_type=util.Object,
found_type=type(var)
)
# Var undeclared, declare its own type
else:
new_type = util.create_object_tree(var.next_dot_path(),
_type)
self._variables[var.varname] = new_type
return
raise exception.BananaTypeCheckerBug("Unreachable code reached.")
def get_variables(self, statement_index=None):
"""
Returns the list of variables with their associated type.
:type statement_index: int
:param: Statement index.
:rtype: dict[str, util.Object|util.Component|util.String|util.Number]
"""
if statement_index is None:
return self._variables
variables = {}
for created_at, snap in self._variables_snapshots:
if created_at < statement_index:
variables = snap
else:
break
return variables
def get_variables_snapshots(self):
return self._variables_snapshots
def _check_needs_for_snapshot(self, var, _type, statement_index):
if var in self._variables:
# If we shadow a component, we need to raise an error
if util.is_comp(self._variables[var]):
raise exception.BananaShadowingComponentError(
where=var.span,
comp=self._variables[var].class_name
)
# If we change the type of the variable, we create a new snapshot:
# This is very strict but will allow to know exactly how
# the type of a variable (or a property) changed.
if self._variables[var] != _type:
self._create_snapshot(statement_index)
def _create_snapshot(self, statement_index):
"""
Create a new snapshot of the variables.
:type statement_index: int
:param statement_index: index of the statement
(should be strictly positive)
"""
new_snapshot = copy.deepcopy(self._variables)
self._variables_snapshots.append((
statement_index, new_snapshot
))
self._variables = new_snapshot
def to_json(self):
"""
Convert this type table into a dictionary.
Useful to serialize the type table.
:rtype: dict
:return: Returns this type table as a dict.
"""
res = {}
for key, val in six.iteritems(self._variables):
res[key.inner_val()] = val.to_json()
return res
def __contains__(self, key):
"""
Test if the type table contains or not the provided
path. This function is more permissive than the other two.
It will never raise any exception (or should aim not to).
:type key: six.string_types | ast.Ident | ast.DothPath
:param key: The key to test.
:return: Returns True if the TypeTable contains a type for the
given path or identifier.
"""
if isinstance(key, six.string_types):
return key in self._variables
if isinstance(key, ast.Ident):
return key.val in self._variables
if isinstance(key, ast.DotPath):
res = key.varname in self._variables
if not res:
return False
val = self._variables[key.varname]
for prop in key.properties:
if isinstance(val, util.Object):
if prop in val.props:
val = val[prop]
else:
return False
return True
return False
def __str__(self):
return strut.dict_to_str(self._variables)
| StarcoderdataPython |
137555 | <gh_stars>10-100
import os
import subprocess
import sys
filedir = "DFDC-Kaggle"
outdir = "DFDC-Kaggle_image"
def mkdir(path):
try:
os.makedirs(path)
except:
pass
def main(video_file, video_id):
videopath = os.path.join(filedir, video_file)
mkdir(os.path.join(outdir, video_id))
outpath = os.path.join(outdir, video_id, 'frame%d.png')
ffmpeg_command = ['ffmpeg', '-i', videopath, outpath, '-loglevel', 'panic']
subprocess.call(ffmpeg_command)
print('Frames at %s extracted to %s'%(videopath, outpath))
sys.stdout.flush()
if __name__ == '__main__':
files = []
ids = []
clses = os.listdir(filedir)
for cls in clses:
vids = os.listdir(os.path.join(filedir, cls))
for vid in vids:
if not vid.endswith('.mp4'):
continue
files.append(os.path.join(cls, vid))
ids.append(os.path.join(cls, vid[:-4]))
print(len(ids))
for i in range(len(ids)):
main(files[i], ids[i])
| StarcoderdataPython |
189566 | <filename>gpu_speed_test.py
# Calculate the computation times for several matrix sizes on GPU
# Author: <NAME> (<EMAIL>)
from __future__ import print_function
import os
os.environ["CUDA_VISIBLE_DEVICES"] = os.environ['SGE_GPU']
import numpy as np
import tensorflow as tf
import time
import socket
def get_times(matrix_sizes):
elapsed_times = []
for size in matrix_sizes:
#print("####### Calculating size %d" % size)
shape = (size,size)
data_type = tf.float32
with tf.device('/gpu:0'):
r1 = tf.random_uniform(shape=shape, minval=0, maxval=1, dtype=data_type)
r2 = tf.random_uniform(shape=shape, minval=0, maxval=1, dtype=data_type)
dot_operation = tf.matmul(r2, r1)
with tf.Session() as session: #config=tf.ConfigProto(log_device_placement=True)
start_time = time.time()
result = session.run(dot_operation)
elapsed_time = time.time() - start_time
elapsed_times.append(elapsed_time)
return elapsed_times
if __name__ == "__main__":
matrix_sizes = range(500,10000,50)
times = get_times(matrix_sizes)
print ('---------- Versions: -------------')
print('Using GPU%s' % os.environ['SGE_GPU'])
print('Tensorflow version:')
print(tf.__version__)
hostname = socket.gethostname()
print('Hostname: %s' % hostname )
code_path = os.path.dirname(os.path.realpath(__file__))
print('Code path: %s' % code_path)
print('----------- Summary: -------------')
for ii, size in enumerate(matrix_sizes):
print("Size: %dx%d, Time: %f secs" % (size,size,times[ii]))
print('----------------------------------')
print("Average time: %f" % np.mean(times))
print('----------------------------------')
np.savez('%s/%s.npz' % (code_path, hostname), matrix_sizes, times)
| StarcoderdataPython |
331 | <reponame>civodlu/trw
#from trw.utils import collect_hierarchical_module_name, collect_hierarchical_parameter_name, get_batch_n, to_value, \
# safe_lookup, len_batch
from .export import as_image_ui8, as_rgb_image, export_image, export_sample, export_as_image
from .table_sqlite import TableStream, SQLITE_TYPE_PATTERN, get_table_number_of_rows
from .reporting_bokeh import report, create_default_reporting_options
from .reporting_bokeh_samples import PanelDataSamplesTabular
| StarcoderdataPython |
162091 | ## Project: SudokuSolver
## Element: ExtraFunctions -> Additional functions for plotting, and "string-to-dictionary" conversion of the Sudoku
from collections import defaultdict
rows = 'ABCDEFGHI'
cols = '123456789'
boxes = [r + c for r in rows for c in cols]
def extract_units(unitlist, boxes):
""" **Function Provided by UDACITY**
Initialize a mapping from box names to the units that the boxes belong to
Parameters
----------
unitlist(list)
a list containing "units" (rows, columns, diagonals, etc.) of boxes
boxes(list)
a list of strings identifying each box on a sudoku board (e.g., "A1", "C7", etc.)
Returns
-------
dict
a dictionary with a key for each box (string) whose value is a list
containing the units that the box belongs to (i.e., the "member units")
"""
# the value for keys that aren't in the dictionary are initialized as an empty list
units = defaultdict(list)
for current_box in boxes:
for unit in unitlist:
if current_box in unit:
# defaultdict avoids this raising a KeyError when new keys are added
units[current_box].append(unit)
return units
def extract_peers(units, boxes):
""" **Function Provided by UDACITY**
Initialize a mapping from box names to a list of peer boxes (i.e., a flat list
of boxes that are in a unit together with the key box)
Parameters
----------
units(dict)
a dictionary with a key for each box (string) whose value is a list
containing the units that the box belongs to (i.e., the "member units")
boxes(list)
a list of strings identifying each box on a sudoku board (e.g., "A1", "C7", etc.)
Returns
-------
dict
a dictionary with a key for each box (string) whose value is a set
containing all boxes that are peers of the key box (boxes that are in a unit
together with the key box)
"""
# the value for keys that aren't in the dictionary are initialized as an empty list
peers = defaultdict(set) # set avoids duplicates
for key_box in boxes:
for unit in units[key_box]:
for peer_box in unit:
if peer_box != key_box:
# defaultdict avoids this raising a KeyError when new keys are added
peers[key_box].add(peer_box)
return peers
def cross(A, B):
"""Cross product of elements in A and elements in B """
return [x+y for x in A for y in B]
def values2grid(values):
""" **Function Provided by UDACITY**
Convert the dictionary board representation to as string
Parameters
----------
values(dict)
a dictionary of the form {'box_name': '123456789', ...}
Returns
-------
a string representing a sudoku grid.
Ex. '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
"""
res = []
for r in rows:
for c in cols:
v = values[r + c]
res.append(v if len(v) == 1 else '.')
return ''.join(res)
def grid2values(grid):
""" **Function Provided by UDACITY**
Convert grid into a dict of {square: char} with '123456789' for empties.
Parameters
----------
grid(string)
a string representing a sudoku grid.
Ex. '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
Returns
-------
A grid in dictionary form
Keys: The boxes, e.g., 'A1'
Values: The value in each box, e.g., '8'. If the box has no value,
then the value will be '123456789'.
"""
sudoku_grid = {}
for val, key in zip(grid, boxes):
if val == '.':
sudoku_grid[key] = '123456789'
else:
sudoku_grid[key] = val
return sudoku_grid
def grid2values_changed(grid):
"""
Convert grid into a dict of {square: char} with a blank space for empties (to show initial sudoku).
Parameters
----------
grid(string)
a string representing a sudoku grid.
Ex. '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
Returns
-------
A grid in dictionary form
Keys: The boxes, e.g., 'A1'
Values: The value in each box, e.g., '8'. If the box has no value,
then the value will be ' ' (a blank space).
"""
sudoku_grid = {}
for val, key in zip(grid, boxes):
if val == '.':
sudoku_grid[key] = '_'
else:
sudoku_grid[key] = val
return sudoku_grid
def display(values):
""" **Function Provided by UDACITY**
Display the values as a 2-D grid.
Parameters
----------
values(dict): The sudoku in dictionary form
"""
width = 1+max(len(values[s]) for s in boxes)
line = '+'.join(['-'*(width*3)]*3)
for r in rows:
print(''.join(values[r+c].center(width)+('|' if c in '36' else '')
for c in cols))
if r in 'CF': print(line)
print()
| StarcoderdataPython |
3232230 | <reponame>mail2nsrajesh/python-troveclient
# Copyright [2015] Hewlett-Packard Development Company, L.P.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
try:
# handle py34
import builtins
except ImportError:
# and py27
import __builtin__ as builtins
import base64
import fixtures
import mock
import re
import six
import testtools
import troveclient.client
from troveclient import exceptions
import troveclient.shell
from troveclient.tests import fakes
from troveclient.tests import utils
import troveclient.v1.modules
import troveclient.v1.shell
class ShellFixture(fixtures.Fixture):
def setUp(self):
super(ShellFixture, self).setUp()
self.shell = troveclient.shell.OpenStackTroveShell()
def tearDown(self):
if hasattr(self.shell, 'cs'):
self.shell.cs.clear_callstack()
super(ShellFixture, self).tearDown()
class ShellTest(utils.TestCase):
FAKE_ENV = {
'OS_USERNAME': 'username',
'OS_PASSWORD': 'password',
'OS_PROJECT_ID': 'project_id',
'OS_AUTH_URL': 'http://no.where/v2.0',
}
def setUp(self, *args):
"""Run before each test."""
super(ShellTest, self).setUp()
for var in self.FAKE_ENV:
self.useFixture(fixtures.EnvironmentVariable(var,
self.FAKE_ENV[var]))
self.shell = self.useFixture(ShellFixture()).shell
@mock.patch('sys.stdout', new_callable=six.StringIO)
@mock.patch('troveclient.client.get_version_map',
return_value=fakes.get_version_map())
@mock.patch('troveclient.v1.shell._find_instance_or_cluster',
return_value=('1234', 'instance'))
def run_command(self, cmd, mock_find_instance_or_cluster,
mock_get_version_map, mock_stdout):
if isinstance(cmd, list):
self.shell.main(cmd)
else:
self.shell.main(cmd.split())
return mock_stdout.getvalue()
@mock.patch('sys.stdout', new_callable=six.StringIO)
@mock.patch('troveclient.client.get_version_map',
return_value=fakes.get_version_map())
@mock.patch('troveclient.v1.shell._find_instance_or_cluster',
return_value=('cls-1234', 'cluster'))
def run_command_clusters(self, cmd, mock_find_instance_or_cluster,
mock_get_version_map, mock_stdout):
if isinstance(cmd, list):
self.shell.main(cmd)
else:
self.shell.main(cmd.split())
return mock_stdout.getvalue()
def assert_called(self, method, url, body=None, **kwargs):
return self.shell.cs.assert_called(method, url, body, **kwargs)
def assert_called_anytime(self, method, url, body=None):
return self.shell.cs.assert_called_anytime(method, url, body)
def test__strip_option(self):
# Format is: opt_name, opt_string, _strip_options_kwargs,
# expected_value, expected_opt_string, exception_msg
data = [
["volume", "volume=10",
{}, "10", "", None],
["volume", ",volume=10,,type=mine,",
{}, "10", "type=mine", None],
["volume", "type=mine",
{}, "", "type=mine", "Missing option 'volume'.*"],
["volume", "type=mine",
{'is_required': False}, None, "type=mine", None],
["volume", "volume=1, volume=2",
{}, "", "", "Option 'volume' found more than once.*"],
["volume", "volume=1, volume=2",
{'allow_multiple': True}, ['1', '2'], "", None],
["volume", "volume=1, volume=2,, volume=4, volume=6",
{'allow_multiple': True}, ['1', '2', '4', '6'], "", None],
["module", ",flavor=10,,nic='net-id=net',module=test, module=test",
{'allow_multiple': True}, ['test'],
"flavor=10,,nic='net-id=net'", None],
["nic", ",flavor=10,,nic=net-id=net, module=test",
{'quotes_required': True}, "", "",
"Invalid 'nic' option. The value must be quoted.*"],
["nic", ",flavor=10,,nic='net-id=net', module=test",
{'quotes_required': True}, "net-id=net",
"flavor=10,, module=test", None],
["nic",
",nic='port-id=port',flavor=10,,nic='net-id=net', module=test",
{'quotes_required': True, 'allow_multiple': True},
["net-id=net", "port-id=port"],
"flavor=10,, module=test", None],
]
count = 0
for datum in data:
count += 1
opt_name = datum[0]
opts_str = datum[1]
kwargs = datum[2]
expected_value = datum[3]
expected_opt_string = datum[4]
exception_msg = datum[5]
msg = "Error (test data line %s): " % count
try:
value, opt_string = troveclient.v1.shell._strip_option(
opts_str, opt_name, **kwargs)
if exception_msg:
self.assertEqual(True, False,
"%sException not thrown, expecting %s" %
(msg, exception_msg))
if isinstance(expected_value, list):
self.assertEqual(
set(value), set(expected_value),
"%sValue not correct" % msg)
else:
self.assertEqual(value, expected_value,
"%sValue not correct" % msg)
self.assertEqual(opt_string, expected_opt_string,
"%sOption string not correct" % msg)
except Exception as ex:
if exception_msg:
msg = ex.message if hasattr(ex, 'message') else str(ex)
self.assertThat(msg,
testtools.matchers.MatchesRegex(
exception_msg, re.DOTALL),
exception_msg, "%sWrong ex" % msg)
else:
raise
def test_instance_list(self):
self.run_command('list')
self.assert_called('GET', '/instances')
def test_instance_show(self):
self.run_command('show 1234')
self.assert_called('GET', '/instances/1234')
def test_reset_status(self):
self.run_command('reset-status 1234')
self.assert_called('POST', '/instances/1234/action')
def test_instance_delete(self):
self.run_command('delete 1234')
self.assert_called('DELETE', '/instances/1234')
def test_instance_force_delete(self):
self.run_command('force-delete 1234')
self.assert_called('DELETE', '/instances/1234')
def test_instance_update(self):
self.run_command('update 1234')
self.assert_called('PATCH', '/instances/1234')
def test_resize_instance(self):
self.run_command('resize-instance 1234 1')
self.assert_called('POST', '/instances/1234/action')
def test_resize_volume(self):
self.run_command('resize-volume 1234 3')
self.assert_called('POST', '/instances/1234/action')
def test_restart(self):
self.run_command('restart 1234')
self.assert_called('POST', '/instances/1234/action')
def test_detach_replica(self):
self.run_command('detach-replica 1234')
self.assert_called('PATCH', '/instances/1234')
def test_promote_to_replica_source(self):
self.run_command('promote-to-replica-source 1234')
self.assert_called('POST', '/instances/1234/action')
def test_eject_replica_source(self):
self.run_command('eject-replica-source 1234')
self.assert_called('POST', '/instances/1234/action')
def test_flavor_list(self):
self.run_command('flavor-list')
self.assert_called('GET', '/flavors')
def test_flavor_list_with_datastore(self):
cmd = ('flavor-list --datastore_type mysql '
'--datastore_version_id some-version-id')
self.run_command(cmd)
self.assert_called(
'GET', '/datastores/mysql/versions/some-version-id/flavors')
def test_flavor_list_error(self):
cmd = 'flavor-list --datastore_type mysql'
exepcted_error_msg = ('Missing argument\(s\): '
'datastore_type, datastore_version_id')
self.assertRaisesRegexp(
exceptions.MissingArgs, exepcted_error_msg, self.run_command,
cmd)
def test_flavor_show(self):
self.run_command('flavor-show 1')
self.assert_called('GET', '/flavors/1')
def test_flavor_show_leading_zero(self):
self.run_command('flavor-show 02')
self.assert_called('GET', '/flavors/02')
def test_flavor_show_by_name(self):
self.run_command('flavor-show m1.tiny') # defined in fakes.py
self.assert_called('GET', '/flavors/m1.tiny')
def test_flavor_show_uuid(self):
self.run_command('flavor-show m1.uuid')
self.assert_called('GET', '/flavors/m1.uuid')
def test_volume_type_list(self):
self.run_command('volume-type-list')
self.assert_called('GET', '/volume-types')
def test_volume_type_list_with_datastore(self):
cmd = ('volume-type-list --datastore_type mysql '
'--datastore_version_id some-version-id')
self.run_command(cmd)
self.assert_called(
'GET', '/datastores/mysql/versions/some-version-id/volume-types')
def test_volume_type_list_error(self):
cmd = 'volume-type-list --datastore_type mysql'
exepcted_error_msg = ('Missing argument\(s\): '
'datastore_type, datastore_version_id')
self.assertRaisesRegexp(
exceptions.MissingArgs, exepcted_error_msg, self.run_command,
cmd)
def test_volume_type_show(self):
self.run_command('volume-type-show 1')
self.assert_called('GET', '/volume-types/1')
def test_cluster_list(self):
self.run_command('cluster-list')
self.assert_called('GET', '/clusters')
def test_cluster_show(self):
self.run_command('cluster-show cls-1234')
self.assert_called('GET', '/clusters/cls-1234')
def test_cluster_instances(self):
self.run_command('cluster-instances cls-1234')
self.assert_called('GET', '/clusters/cls-1234')
def test_cluster_reset_status(self):
self.run_command('cluster-reset-status cls-1234')
self.assert_called('POST', '/clusters/cls-1234')
def test_cluster_delete(self):
self.run_command('cluster-delete cls-1234')
self.assert_called('DELETE', '/clusters/cls-1234')
def test_cluster_force_delete(self):
self.run_command('cluster-force-delete cls-1234')
self.assert_called('DELETE', '/clusters/cls-1234')
def test_boot_fail_with_size_0(self):
self.assertRaises(exceptions.ValidationError, self.run_command,
'create test-member-1 1 --size 0 --volume_type lvm')
def test_boot(self):
self.run_command('create test-member-1 1 --size 1 --volume_type lvm')
self.assert_called_anytime(
'POST', '/instances',
{'instance': {
'volume': {'size': 1, 'type': 'lvm'},
'flavorRef': 1,
'name': 'test-member-1'
}})
def test_boot_with_modules(self):
self.run_command('create test-member-1 1 --size 1 --volume_type lvm '
'--module 4321 --module 8765')
self.assert_called_anytime(
'POST', '/instances',
{'instance': {
'volume': {'size': 1, 'type': 'lvm'},
'flavorRef': 1,
'name': 'test-member-1',
'modules': [{'id': '4321'}, {'id': '8765'}]
}})
def test_boot_by_flavor_name(self):
self.run_command(
'create test-member-1 m1.tiny --size 1 --volume_type lvm')
self.assert_called_anytime(
'POST', '/instances',
{'instance': {
'volume': {'size': 1, 'type': 'lvm'},
'flavorRef': 1,
'name': 'test-member-1'
}})
def test_boot_by_flavor_leading_zero(self):
self.run_command(
'create test-member-zero 02 --size 1 --volume_type lvm')
self.assert_called_anytime(
'POST', '/instances',
{'instance': {
'volume': {'size': 1, 'type': 'lvm'},
'flavorRef': '02',
'name': 'test-member-zero'
}})
def test_boot_repl_set(self):
self.run_command('create repl-1 1 --size 1 --locality=anti-affinity '
'--replica_count=4')
self.assert_called_anytime(
'POST', '/instances',
{'instance': {
'volume': {'size': 1, 'type': None},
'flavorRef': 1,
'name': 'repl-1',
'replica_count': 4,
'locality': 'anti-affinity'
}})
def test_boot_replica(self):
self.run_command('create slave-1 1 --size 1 --replica_of=master_1')
self.assert_called_anytime(
'POST', '/instances',
{'instance': {
'volume': {'size': 1, 'type': None},
'flavorRef': 1,
'name': 'slave-1',
'replica_of': 'myid',
'replica_count': 1
}})
def test_boot_replica_count(self):
self.run_command('create slave-1 1 --size 1 --replica_of=master_1 '
'--replica_count=3')
self.assert_called_anytime(
'POST', '/instances',
{'instance': {
'volume': {'size': 1, 'type': None},
'flavorRef': 1,
'name': 'slave-1',
'replica_of': 'myid',
'replica_count': 3
}})
def test_boot_locality(self):
self.run_command('create master-1 1 --size 1 --locality=affinity')
self.assert_called_anytime(
'POST', '/instances',
{'instance': {
'volume': {'size': 1, 'type': None},
'flavorRef': 1,
'name': 'master-1',
'locality': 'affinity'
}})
def test_boot_locality_error(self):
cmd = ('create slave-1 1 --size 1 --locality=affinity '
'--replica_of=master_1')
self.assertRaisesRegexp(
exceptions.ValidationError,
'Cannot specify locality when adding replicas to existing '
'master.',
self.run_command, cmd)
def test_boot_nic_error(self):
cmd = ('create test-member-1 1 --size 1 --volume_type lvm '
'--nic net-id=some-id,port-id=some-id')
self.assertRaisesRegexp(
exceptions.ValidationError,
'Invalid NIC argument: nic=\'net-id=some-id,port-id=some-id\'',
self.run_command, cmd)
def test_boot_restore_by_id(self):
self.run_command('create test-restore-1 1 --size 1 --backup bk_1234')
self.assert_called_anytime(
'POST', '/instances',
{'instance': {
'volume': {'size': 1, 'type': None},
'flavorRef': 1,
'name': 'test-restore-1',
'restorePoint': {'backupRef': 'bk-1234'},
}})
def test_boot_restore_by_name(self):
self.run_command('create test-restore-1 1 --size 1 --backup bkp_1')
self.assert_called_anytime(
'POST', '/instances',
{'instance': {
'volume': {'size': 1, 'type': None},
'flavorRef': 1,
'name': 'test-restore-1',
'restorePoint': {'backupRef': 'bk-1234'},
}})
def test_cluster_create(self):
cmd = ('cluster-create test-clstr vertica 7.1 '
'--instance flavor=02,volume=2 '
'--instance flavor=2,volume=1 '
'--instance flavor=2,volume=1,volume_type=my-type-1')
self.run_command(cmd)
self.assert_called_anytime(
'POST', '/clusters',
{'cluster': {
'instances': [
{
'volume': {'size': '2'},
'flavorRef': '02'
},
{
'volume': {'size': '1'},
'flavorRef': '2'
},
{
'volume': {'size': '1', 'type': 'my-type-1'},
'flavorRef': '2'
}],
'datastore': {'version': '7.1', 'type': 'vertica'},
'name': 'test-clstr'}})
def test_cluster_create_by_flavor_name(self):
cmd = ('cluster-create test-clstr vertica 7.1 '
'--instance flavor=m1.small,volume=2 '
'--instance flavor=m1.leading-zero,volume=1')
self.run_command(cmd)
self.assert_called_anytime(
'POST', '/clusters',
{'cluster': {
'instances': [
{
'volume': {'size': '2'},
'flavorRef': '2'
},
{
'volume': {'size': '1'},
'flavorRef': '02'
}],
'datastore': {'version': '7.1', 'type': 'vertica'},
'name': 'test-clstr'}})
def test_cluster_create_error(self):
cmd = ('cluster-create test-clstr vertica 7.1 --instance volume=2 '
'--instance flavor=2,volume=1')
self.assertRaisesRegexp(
exceptions.MissingArgs, "Missing option 'flavor'",
self.run_command, cmd)
def test_cluster_grow(self):
cmd = ('cluster-grow cls-1234 '
'--instance flavor=2,volume=2 '
'--instance flavor=02,volume=1')
self.run_command(cmd)
self.assert_called('POST', '/clusters/cls-1234')
def test_cluster_shrink(self):
cmd = ('cluster-shrink cls-1234 1234')
self.run_command(cmd)
self.assert_called('POST', '/clusters/cls-1234')
def test_cluster_upgrade(self):
cmd = ('cluster-upgrade cls-1234 1234')
self.run_command(cmd)
self.assert_called('POST', '/clusters/cls-1234')
def test_cluster_create_with_locality(self):
cmd = ('cluster-create test-clstr2 redis 3.0 --locality=affinity '
'--instance flavor=2,volume=1 '
'--instance flavor=02,volume=1 '
'--instance flavor=2,volume=1 ')
self.run_command(cmd)
self.assert_called_anytime(
'POST', '/clusters',
{'cluster': {
'instances': [
{'flavorRef': '2',
'volume': {'size': '1'}},
{'flavorRef': '02',
'volume': {'size': '1'}},
{'flavorRef': '2',
'volume': {'size': '1'}},
],
'datastore': {'version': '3.0', 'type': 'redis'},
'name': 'test-clstr2',
'locality': 'affinity'}})
def test_cluster_create_with_nic_az(self):
cmd = ('cluster-create test-clstr1 vertica 7.1 '
'--instance flavor=2,volume=2,nic=\'net-id=some-id\','
'availability_zone=2 '
'--instance flavor=2,volume=2,nic=\'net-id=some-id\','
'availability_zone=2')
self.run_command(cmd)
self.assert_called_anytime(
'POST', '/clusters',
{'cluster': {
'instances': [
{
'flavorRef': '2',
'volume': {'size': '2'},
'nics': [{'net-id': 'some-id'}],
'availability_zone': '2'
},
{
'flavorRef': '2',
'volume': {'size': '2'},
'nics': [{'net-id': 'some-id'}],
'availability_zone': '2'
}],
'datastore': {'version': '7.1', 'type': 'vertica'},
'name': 'test-clstr1'}})
def test_cluster_create_with_nic_az_error(self):
cmd = ('cluster-create test-clstr vertica 7.1 '
'--instance flavor=2,volume=2,nic=net-id=some-id,'
'port-id=some-port-id,availability_zone=2 '
'--instance flavor=2,volume=1,nic=net-id=some-id,'
'port-id=some-port-id,availability_zone=2')
self.assertRaisesRegexp(
exceptions.ValidationError, "Invalid 'nic' option. "
"The value must be quoted.",
self.run_command, cmd)
def test_cluster_create_with_nic_az_error_again(self):
cmd = ('cluster-create test-clstr vertica 7.1 '
'--instance flavor=2,volume=2,nic=\'v4-fixed-ip=10.0.0.1\','
'availability_zone=2 '
'--instance flavor=2,volume=1,nic=\'v4-fixed-ip=10.0.0.1\','
'availability_zone=2')
self.assertRaisesRegexp(
exceptions.ValidationError, 'Invalid NIC argument',
self.run_command, cmd)
def test_datastore_list(self):
self.run_command('datastore-list')
self.assert_called('GET', '/datastores')
def test_datastore_show(self):
self.run_command('datastore-show d-123')
self.assert_called('GET', '/datastores/d-123')
def test_datastore_version_list(self):
self.run_command('datastore-version-list d-123')
self.assert_called('GET', '/datastores/d-123/versions')
def test_datastore_version_show(self):
self.run_command('datastore-version-show v-56 --datastore d-123')
self.assert_called('GET', '/datastores/d-123/versions/v-56')
def test_datastore_version_show_error(self):
expected_error_msg = ('The datastore name or id is required to '
'retrieve a datastore version by name.')
self.assertRaisesRegexp(exceptions.NoUniqueMatch, expected_error_msg,
self.run_command,
'datastore-version-show v-56')
def test_configuration_list(self):
self.run_command('configuration-list')
self.assert_called('GET', '/configurations')
def test_configuration_show(self):
self.run_command('configuration-show c-123')
self.assert_called('GET', '/configurations/c-123')
def test_configuration_create(self):
cmd = "configuration-create c-123 some-thing"
self.assertRaises(ValueError, self.run_command, cmd)
def test_configuration_update(self):
cmd = "configuration-update c-123 some-thing"
self.assertRaises(ValueError, self.run_command, cmd)
def test_configuration_patch(self):
cmd = "configuration-patch c-123 some-thing"
self.assertRaises(ValueError, self.run_command, cmd)
def test_configuration_parameter_list(self):
cmd = 'configuration-parameter-list v-156 --datastore d-123'
self.run_command(cmd)
self.assert_called('GET',
'/datastores/d-123/versions/v-156/parameters')
def test_configuration_parameter_list_error(self):
expected_error_msg = ('The datastore name or id is required to '
'retrieve the parameters for the configuration '
'group by name')
self.assertRaisesRegexp(
exceptions.NoUniqueMatch, expected_error_msg,
self.run_command, 'configuration-parameter-list v-156')
def test_configuration_parameter_show(self):
cmd = ('configuration-parameter-show v_56 '
'max_connections --datastore d_123')
self.run_command(cmd)
self.assert_called(
'GET',
'/datastores/d_123/versions/v_56/parameters/max_connections')
def test_configuration_instances(self):
cmd = 'configuration-instances c-123'
self.run_command(cmd)
self.assert_called('GET', '/configurations/c-123/instances')
def test_configuration_delete(self):
self.run_command('configuration-delete c-123')
self.assert_called('DELETE', '/configurations/c-123')
def test_configuration_default(self):
self.run_command('configuration-default 1234')
self.assert_called('GET', '/instances/1234/configuration')
def test_configuration_attach(self):
self.run_command('configuration-attach 1234 c-123')
self.assert_called('PUT', '/instances/1234')
def test_configuration_detach(self):
self.run_command('configuration-detach 1234')
self.assert_called('PUT', '/instances/1234')
def test_upgrade(self):
self.run_command('upgrade 1234 c-123')
self.assert_called('PATCH', '/instances/1234')
def test_metadata_edit(self):
self.run_command('metadata-edit 1234 key-123 value-123')
self.assert_called('PATCH', '/instances/1234/metadata/key-123')
def test_metadata_update(self):
self.run_command('metadata-update 1234 key-123 key-456 value-123')
self.assert_called('PUT', '/instances/1234/metadata/key-123')
def test_metadata_delete(self):
self.run_command('metadata-delete 1234 key-123')
self.assert_called('DELETE', '/instances/1234/metadata/key-123')
def test_metadata_create(self):
self.run_command('metadata-create 1234 key123 value123')
self.assert_called_anytime(
'POST', '/instances/1234/metadata/key123',
{'metadata': {'value': 'value123'}})
def test_metadata_list(self):
self.run_command('metadata-list 1234')
self.assert_called('GET', '/instances/1234/metadata')
def test_metadata_show(self):
self.run_command('metadata-show 1234 key123')
self.assert_called('GET', '/instances/1234/metadata/key123')
def test_module_list(self):
self.run_command('module-list')
self.assert_called('GET', '/modules')
def test_module_list_datastore(self):
self.run_command('module-list --datastore all')
self.assert_called('GET', '/modules?datastore=all')
def test_module_show(self):
self.run_command('module-show 4321')
self.assert_called('GET', '/modules/4321')
def test_module_create(self):
with mock.patch.object(builtins, 'open'):
return_value = b'mycontents'
expected_contents = str(return_value.decode('utf-8'))
mock_encode = mock.Mock(return_value=return_value)
with mock.patch.object(base64, 'b64encode', mock_encode):
self.run_command('module-create mod1 type filename')
self.assert_called_anytime(
'POST', '/modules',
{'module': {'contents': expected_contents,
'all_tenants': 0,
'module_type': 'type', 'visible': 1,
'auto_apply': 0, 'live_update': 0,
'name': 'mod1', 'priority_apply': 0,
'apply_order': 5}})
def test_module_update(self):
with mock.patch.object(troveclient.v1.modules.Module, '__repr__',
mock.Mock(return_value='4321')):
self.run_command('module-update 4321 --name mod3')
self.assert_called_anytime(
'PUT', '/modules/4321',
{'module': {'name': 'mod3'}})
def test_module_delete(self):
with mock.patch.object(troveclient.v1.modules.Module, '__repr__',
mock.Mock(return_value='4321')):
self.run_command('module-delete 4321')
self.assert_called_anytime('DELETE', '/modules/4321')
def test_module_list_instance(self):
self.run_command('module-list-instance 1234')
self.assert_called_anytime('GET', '/instances/1234/modules')
def test_module_instances(self):
with mock.patch.object(troveclient.v1.modules.Module, '__repr__',
mock.Mock(return_value='4321')):
self.run_command('module-instances 4321')
self.assert_called_anytime('GET', '/modules/4321/instances')
def test_module_instances_clustered(self):
with mock.patch.object(troveclient.v1.modules.Module, '__repr__',
mock.Mock(return_value='4321')):
self.run_command('module-instances 4321 --include_clustered')
self.assert_called_anytime(
'GET', '/modules/4321/instances?include_clustered=True')
def test_module_instance_count(self):
with mock.patch.object(troveclient.v1.modules.Module, '__repr__',
mock.Mock(return_value='4321')):
self.run_command('module-instance-count 4321')
self.assert_called(
'GET', '/modules/4321/instances?count_only=True')
def test_module_instance_count_clustered(self):
with mock.patch.object(troveclient.v1.modules.Module, '__repr__',
mock.Mock(return_value='4321')):
self.run_command('module-instance-count 4321 --include_clustered')
self.assert_called(
'GET', '/modules/4321/instances?count_only=True&'
'include_clustered=True')
def test_module_reapply(self):
with mock.patch.object(troveclient.v1.modules.Module, '__repr__',
mock.Mock(return_value='4321')):
self.run_command('module-reapply 4321 --delay=5')
self.assert_called_anytime('PUT', '/modules/4321/instances')
def test_cluster_modules(self):
self.run_command('cluster-modules cls-1234')
self.assert_called_anytime('GET', '/clusters/cls-1234')
def test_module_apply(self):
self.run_command('module-apply 1234 4321 8765')
self.assert_called_anytime('POST', '/instances/1234/modules',
{'modules':
[{'id': '4321'}, {'id': '8765'}]})
def test_module_remove(self):
self.run_command('module-remove 1234 4321')
self.assert_called_anytime('DELETE', '/instances/1234/modules/4321')
def test_module_query(self):
self.run_command('module-query 1234')
self.assert_called('GET', '/instances/1234/modules?from_guest=True')
def test_module_retrieve(self):
with mock.patch.object(troveclient.v1.modules.Module, '__getattr__',
mock.Mock(return_value='4321')):
with mock.patch.object(builtins, 'open'):
self.run_command('module-retrieve 1234')
self.assert_called(
'GET',
'/instances/1234/modules?'
'include_contents=True&from_guest=True')
def test_limit_list(self):
self.run_command('limit-list')
self.assert_called('GET', '/limits')
def test_backup_list(self):
self.run_command('backup-list')
self.assert_called('GET', '/backups')
def test_backup_show(self):
self.run_command('backup-show bk-1234')
self.assert_called('GET', '/backups/bk-1234')
def test_backup_list_instance(self):
self.run_command('backup-list-instance 1234')
self.assert_called('GET', '/instances/1234/backups')
def test_backup_delete(self):
self.run_command('backup-delete bk-1234')
self.assert_called('DELETE', '/backups/bk-1234')
def test_backup_create(self):
self.run_command('backup-create 1234 bkp_1')
self.assert_called_anytime(
'POST', '/backups',
{'backup': {
'instance': '1234',
'name': 'bkp_1',
'incremental': False
}})
def test_backup_copy(self):
self.run_command('backup-copy new_bkp bk-1234')
self.assert_called_anytime(
'POST', '/backups',
{'backup': {
'name': 'new_bkp',
'incremental': False,
'backup': {'region': None, 'id': 'bk-1234'}
}})
def test_database_list(self):
self.run_command('database-list 1234')
self.assert_called('GET', '/instances/1234/databases')
def test_database_delete(self):
self.run_command('database-delete 1234 db_1')
self.assert_called('DELETE', '/instances/1234/databases/db_1')
def test_database_create(self):
cmd = ('database-create 1234 db_1 --character_set utf8 '
'--collate utf8_general_ci')
self.run_command(cmd)
self.assert_called_anytime(
'POST', '/instances/1234/databases',
{'databases': [{'character_set': 'utf8',
'name': 'db_1',
'collate': 'utf8_general_ci'}]})
def test_user_list(self):
self.run_command('user-list 1234')
self.assert_called('GET', '/instances/1234/users')
def test_user_show(self):
self.run_command('user-show 1234 jacob')
self.assert_called('GET', '/instances/1234/users/jacob')
def test_user_delete(self):
self.run_command('user-delete 1234 jacob')
self.assert_called('DELETE', '/instances/1234/users/jacob')
def test_user_create(self):
self.run_command('user-create 1234 jacob password')
self.assert_called_anytime(
'POST', '/instances/1234/users',
{'users': [{
'password': 'password',
'name': 'jacob',
'databases': []}]})
def test_user_show_access(self):
self.run_command('user-show-access 1234 jacob')
self.assert_called('GET', '/instances/1234/users/jacob/databases')
def test_user_update_host(self):
cmd = 'user-update-attributes 1234 jacob --new_host 10.0.0.1'
self.run_command(cmd)
self.assert_called('PUT', '/instances/1234/users/jacob')
def test_user_update_name(self):
self.run_command('user-update-attributes 1234 jacob --new_name sam')
self.assert_called('PUT', '/instances/1234/users/jacob')
def test_user_update_password(self):
cmd = 'user-update-attributes 1234 jacob --new_password <PASSWORD>'
self.run_command(cmd)
self.assert_called('PUT', '/instances/1234/users/jacob')
def test_user_grant_access(self):
self.run_command('user-grant-access 1234 jacob db1 db2')
self.assert_called('PUT', '/instances/1234/users/jacob/databases')
def test_user_revoke_access(self):
self.run_command('user-revoke-access 1234 jacob db1')
self.assert_called('DELETE',
'/instances/1234/users/jacob/databases/db1')
def test_root_enable_instance(self):
self.run_command('root-enable 1234')
self.assert_called_anytime('POST', '/instances/1234/root')
def test_root_enable_cluster(self):
self.run_command_clusters('root-enable cls-1234')
self.assert_called_anytime('POST', '/clusters/cls-1234/root')
def test_root_disable_instance(self):
self.run_command('root-disable 1234')
self.assert_called_anytime('DELETE', '/instances/1234/root')
def test_root_show_instance(self):
self.run_command('root-show 1234')
self.assert_called('GET', '/instances/1234/root')
def test_root_show_cluster(self):
self.run_command_clusters('root-show cls-1234')
self.assert_called('GET', '/clusters/cls-1234/root')
def test_secgroup_list(self):
self.run_command('secgroup-list')
self.assert_called('GET', '/security-groups')
def test_secgroup_show(self):
self.run_command('secgroup-show 2')
self.assert_called('GET', '/security-groups/2')
def test_secgroup_list_rules(self):
self.run_command('secgroup-list-rules 2')
self.assert_called('GET', '/security-groups/2')
def test_secgroup_delete_rule(self):
self.run_command('secgroup-delete-rule 2')
self.assert_called('DELETE', '/security-group-rules/2')
def test_secgroup_add_rule(self):
self.run_command('secgroup-add-rule 2 192.168.3.11/24')
self.assert_called_anytime(
'POST', '/security-group-rules',
{'security_group_rule': {
'cidr': '192.168.3.11/24',
'group_id': '2',
}})
@mock.patch('sys.stdout', new_callable=six.StringIO)
@mock.patch('troveclient.client.get_version_map',
return_value=fakes.get_version_map())
@mock.patch('troveclient.v1.shell._find_instance',
side_effect=exceptions.CommandError)
@mock.patch('troveclient.v1.shell._find_cluster',
return_value='cls-1234')
def test_find_instance_or_cluster_find_cluster(self, mock_find_cluster,
mock_find_instance,
mock_get_version_map,
mock_stdout):
cmd = 'root-show cls-1234'
self.shell.main(cmd.split())
self.assert_called('GET', '/clusters/cls-1234/root')
@mock.patch('sys.stdout', new_callable=six.StringIO)
@mock.patch('troveclient.client.get_version_map',
return_value=fakes.get_version_map())
@mock.patch('troveclient.v1.shell._find_instance',
return_value='1234')
def test_find_instance_or_cluster(self, mock_find_instance,
mock_get_version_map, mock_stdout):
cmd = 'root-show 1234'
self.shell.main(cmd.split())
self.assert_called('GET', '/instances/1234/root')
| StarcoderdataPython |
145325 | #!/usr/bin/env python
# wujian@2019
import argparse
import numpy as np
from libs.ssl import ml_ssl, srp_ssl, music_ssl
from libs.data_handler import SpectrogramReader, NumpyReader
from libs.utils import get_logger, EPSILON
from libs.opts import StftParser, str2tuple
logger = get_logger(__name__)
def add_wta(masks_list, eps=1e-4):
"""
Produce winner-take-all masks
"""
masks = np.stack(masks_list, axis=-1)
max_mask = np.max(masks, -1)
wta_masks = []
for spk_mask in masks_list:
m = np.where(spk_mask == max_mask, spk_mask, eps)
wta_masks.append(m)
return wta_masks
def run(args):
stft_kwargs = {
"frame_len": args.frame_len,
"frame_hop": args.frame_hop,
"round_power_of_two": args.round_power_of_two,
"window": args.window,
"center": args.center,
"transpose": True
}
steer_vector = np.load(args.steer_vector)
logger.info(f"Shape of the steer vector: {steer_vector.shape}")
num_doa, _, _ = steer_vector.shape
min_doa, max_doa = str2tuple(args.doa_range)
if args.output == "radian":
angles = np.linspace(min_doa * np.pi / 180, max_doa * np.pi / 180,
num_doa + 1)
else:
angles = np.linspace(min_doa, max_doa, num_doa + 1)
spectrogram_reader = SpectrogramReader(args.wav_scp, **stft_kwargs)
mask_reader = None
if args.mask_scp:
mask_reader = [NumpyReader(scp) for scp in args.mask_scp.split(",")]
online = (args.chunk_len > 0 and args.look_back > 0)
if online:
logger.info("Set up in online mode: chunk_len " +
f"= {args.chunk_len}, look_back = {args.look_back}")
if args.backend == "srp":
split_index = lambda sstr: [
tuple(map(int, p.split(","))) for p in sstr.split(";")
]
srp_pair = split_index(args.srp_pair)
srp_pair = ([t[0] for t in srp_pair], [t[1] for t in srp_pair])
logger.info(f"Choose srp-based algorithm, srp pair is {srp_pair}")
else:
srp_pair = None
with open(args.doa_scp, "w") as doa_out:
for key, stft in spectrogram_reader:
# stft: M x T x F
_, _, F = stft.shape
if mask_reader:
# T x F => F x T
mask = [r[key] for r in mask_reader] if mask_reader else None
if args.mask_eps >= 0 and len(mask_reader) > 1:
mask = add_wta(mask, eps=args.mask_eps)
mask = mask[0]
# F x T => T x F
if mask.shape[-1] != F:
mask = mask.transpose()
else:
mask = None
if not online:
if srp_pair:
idx = srp_ssl(stft,
steer_vector,
srp_pair=srp_pair,
mask=mask)
elif args.backend == "ml":
idx = ml_ssl(stft,
steer_vector,
mask=mask,
compression=-1,
eps=EPSILON)
else:
idx = music_ssl(stft, steer_vector, mask=mask)
doa = idx if args.output == "index" else angles[idx]
logger.info(f"Processing utterance {key}: {doa:.4f}")
doa_out.write(f"{key}\t{doa:.4f}\n")
else:
logger.info(f"Processing utterance {key}...")
_, T, _ = stft.shape
online_doa = []
for t in range(0, T, args.chunk_len):
s = max(t - args.look_back, 0)
if mask is not None:
chunk_mask = mask[..., s:t + args.chunk_len]
else:
chunk_mask = None
stft_chunk = stft[:, s:t + args.chunk_len, :]
if srp_pair:
idx = srp_ssl(stft_chunk,
steer_vector,
srp_pair=srp_pair,
mask=chunk_mask)
elif args.backend == "ml":
idx = ml_ssl(stft_chunk,
steer_vector,
mask=chunk_mask,
compression=-1,
eps=EPSILON)
else:
idx = music_ssl(stft_chunk,
steer_vector,
mask=chunk_mask)
doa = idx if args.output == "index" else angles[idx]
online_doa.append(doa)
doa_str = " ".join([f"{d:.4f}" for d in online_doa])
doa_out.write(f"{key}\t{doa_str}\n")
logger.info(f"Processing {len(spectrogram_reader)} utterance done")
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Command to ML/SRP based sound souce localization (SSL)."
"Also see scripts/sptk/compute_steer_vector.py",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
parents=[StftParser.parser])
parser.add_argument("wav_scp",
type=str,
help="Multi-channel wave rspecifier")
parser.add_argument("steer_vector",
type=str,
help="Pre-computed steer vector in each "
"directions (in shape A x M x F, A: number "
"of DoAs, M: microphone number, F: FFT bins)")
parser.add_argument("doa_scp",
type=str,
help="Wspecifier for estimated DoA")
parser.add_argument("--backend",
type=str,
default="ml",
choices=["ml", "srp", "music"],
help="Which algorithm to choose for SSL")
parser.add_argument("--srp-pair",
type=str,
default="",
help="Microphone index pair to compute srp response")
parser.add_argument("--doa-range",
type=str,
default="0,360",
help="DoA range")
parser.add_argument("--mask-scp",
type=str,
default="",
help="Rspecifier for TF-masks in numpy format")
parser.add_argument("--output",
type=str,
default="degree",
choices=["radian", "degree", "index"],
help="Output type of the DoA")
parser.add_argument("--mask-eps",
type=float,
default=-1,
help="Value of eps used in masking winner-take-all")
parser.add_argument("--chunk-len",
type=int,
default=-1,
help="Number frames per chunk "
"(for online setups)")
parser.add_argument("--look-back",
type=int,
default=125,
help="Number of frames to look back "
"(for online setups)")
args = parser.parse_args()
run(args) | StarcoderdataPython |
1613392 | <filename>example/android/with_keras.py
from sepmachine.pipeline import BasePipeline
from sepmachine.handler import KerasHandler
from sepmachine.capture import AdbCapture
video_path = "../../demo1.mp4"
model_path = "../../output.h5"
empty_cap = AdbCapture("123456F")
handler = KerasHandler(model_path=model_path)
pipeline = BasePipeline(empty_cap, handler)
pipeline.run(video_path)
| StarcoderdataPython |
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": {}},
}
| StarcoderdataPython |
3362819 | from __future__ import annotations
import typing
from solana.publickey import PublicKey
from solana.transaction import TransactionInstruction, AccountMeta
import borsh_construct as borsh
from .. import types
from ..program_id import PROGRAM_ID
class PlayArgs(typing.TypedDict):
tile: types.tile.Tile
layout = borsh.CStruct("tile" / types.tile.Tile.layout)
class PlayAccounts(typing.TypedDict):
game: PublicKey
player: PublicKey
def play(args: PlayArgs, accounts: PlayAccounts) -> TransactionInstruction:
keys: list[AccountMeta] = [
AccountMeta(pubkey=accounts["game"], is_signer=False, is_writable=True),
AccountMeta(pubkey=accounts["player"], is_signer=True, is_writable=False),
]
identifier = b"\xd5\x9d\xc1\x8e\xe48\xf8\x96"
encoded_args = layout.build(
{
"tile": args["tile"].to_encodable(),
}
)
data = identifier + encoded_args
return TransactionInstruction(keys, PROGRAM_ID, data)
| StarcoderdataPython |
139443 | # pylint: disable=no-self-use,invalid-name,protected-access
from __future__ import division
from __future__ import absolute_import
from nltk.tree import Tree
from allennlp.data.dataset_readers import PennTreeBankConstituencySpanDatasetReader
from allennlp.common.testing import AllenNlpTestCase
from allennlp.data.dataset_readers.dataset_utils.span_utils import enumerate_spans
try:
from itertools import izip
except:
izip = zip
class TestPennTreeBankConstituencySpanReader(AllenNlpTestCase):
def setUp(self):
super(TestPennTreeBankConstituencySpanReader, self).setUp()
self.span_width = 5
def test_read_from_file(self):
ptb_reader = PennTreeBankConstituencySpanDatasetReader()
instances = ptb_reader.read(unicode(self.FIXTURES_ROOT / u'data' / u'example_ptb.trees'))
assert len(instances) == 2
fields = instances[0].fields
tokens = [x.text for x in fields[u"tokens"].tokens]
pos_tags = fields[u"pos_tags"].labels
spans = [(x.span_start, x.span_end) for x in fields[u"spans"].field_list]
span_labels = fields[u"span_labels"].labels
assert tokens == [u'Also', u',', u'because', u'UAL', u'Chairman', u'Stephen', u'Wolf',
u'and', u'other', u'UAL', u'executives', u'have', u'joined', u'the',
u'pilots', u"'", u'bid', u',', u'the', u'board', u'might', u'be', u'forced',
u'to', u'exclude', u'him', u'from', u'its', u'deliberations', u'in',
u'order', u'to', u'be', u'fair', u'to', u'other', u'bidders', u'.']
assert pos_tags == [u'RB', u',', u'IN', u'NNP', u'NNP', u'NNP', u'NNP', u'CC', u'JJ', u'NNP',
u'NNS', u'VBP', u'VBN', u'DT', u'NNS', u'POS', u'NN', u',', u'DT', u'NN',
u'MD', u'VB', u'VBN', u'TO', u'VB', u'PRP', u'IN', u'PRP$',
u'NNS', u'IN', u'NN', u'TO', u'VB', u'JJ', u'TO', u'JJ', u'NNS', u'.']
assert spans == enumerate_spans(tokens)
gold_tree = Tree.fromstring(u"(S(ADVP(RB Also))(, ,)(SBAR(IN because)"
u"(S(NP(NP(NNP UAL)(NNP Chairman)(NNP Stephen)(NNP Wolf))"
u"(CC and)(NP(JJ other)(NNP UAL)(NNS executives)))(VP(VBP have)"
u"(VP(VBN joined)(NP(NP(DT the)(NNS pilots)(POS '))(NN bid))))))"
u"(, ,)(NP(DT the)(NN board))(VP(MD might)(VP(VB be)(VP(VBN "
u"forced)(S(VP(TO to)(VP(VB exclude)(NP(PRP him))(PP(IN from)"
u"(NP(PRP$ its)(NNS deliberations)))(SBAR(IN in)(NN order)(S("
u"VP(TO to)(VP(VB be)(ADJP(JJ fair)(PP(TO to)(NP(JJ other)(NNS "
u"bidders))))))))))))))(. .))")
assert fields[u"metadata"].metadata[u"gold_tree"] == gold_tree
assert fields[u"metadata"].metadata[u"tokens"] == tokens
correct_spans_and_labels = {}
ptb_reader._get_gold_spans(gold_tree, 0, correct_spans_and_labels)
for span, label in izip(spans, span_labels):
if label != u"NO-LABEL":
assert correct_spans_and_labels[span] == label
fields = instances[1].fields
tokens = [x.text for x in fields[u"tokens"].tokens]
pos_tags = fields[u"pos_tags"].labels
spans = [(x.span_start, x.span_end) for x in fields[u"spans"].field_list]
span_labels = fields[u"span_labels"].labels
assert tokens == [u'That', u'could', u'cost', u'him', u'the', u'chance',
u'to', u'influence', u'the', u'outcome', u'and', u'perhaps',
u'join', u'the', u'winning', u'bidder', u'.']
assert pos_tags == [u'DT', u'MD', u'VB', u'PRP', u'DT', u'NN',
u'TO', u'VB', u'DT', u'NN', u'CC', u'RB', u'VB', u'DT',
u'VBG', u'NN', u'.']
assert spans == enumerate_spans(tokens)
gold_tree = Tree.fromstring(u"(S(NP(DT That))(VP(MD could)(VP(VB cost)(NP(PRP him))"
u"(NP(DT the)(NN chance)(S(VP(TO to)(VP(VP(VB influence)(NP(DT the)"
u"(NN outcome)))(CC and)(VP(ADVP(RB perhaps))(VB join)(NP(DT the)"
u"(VBG winning)(NN bidder)))))))))(. .))")
assert fields[u"metadata"].metadata[u"gold_tree"] == gold_tree
assert fields[u"metadata"].metadata[u"tokens"] == tokens
correct_spans_and_labels = {}
ptb_reader._get_gold_spans(gold_tree, 0, correct_spans_and_labels)
for span, label in izip(spans, span_labels):
if label != u"NO-LABEL":
assert correct_spans_and_labels[span] == label
def test_strip_functional_tags(self):
ptb_reader = PennTreeBankConstituencySpanDatasetReader()
# Get gold spans should strip off all the functional tags.
tree = Tree.fromstring(u"(S (NP=PRP (D the) (N dog)) (VP-0 (V chased) (NP|FUN-TAGS (D the) (N cat))))")
ptb_reader._strip_functional_tags(tree)
assert tree == Tree.fromstring(u"(S (NP (D the) (N dog)) (VP (V chased) (NP (D the) (N cat))))")
def test_get_gold_spans_correctly_extracts_spans(self):
ptb_reader = PennTreeBankConstituencySpanDatasetReader()
tree = Tree.fromstring(u"(S (NP (D the) (N dog)) (VP (V chased) (NP (D the) (N cat))))")
span_dict = {}
ptb_reader._get_gold_spans(tree, 0, span_dict)
spans = list(span_dict.items()) # pylint: disable=protected-access
assert spans == [((0, 1), u'NP'), ((3, 4), u'NP'), ((2, 4), u'VP'), ((0, 4), u'S')]
def test_get_gold_spans_correctly_extracts_spans_with_nested_labels(self):
ptb_reader = PennTreeBankConstituencySpanDatasetReader()
# Here we have a parse with several nested labels - particularly the (WHNP (WHNP (WP What)))
# fragment. These should be concatenated into a single label by get_gold_spans.
tree = Tree.fromstring(u"""
(S
(`` ``)
(S-TPC
(NP-SBJ (PRP We))
(VP
(VBP have)
(S
(VP
(TO to)
(VP
(VP
(VB clear)
(PRT (RP up))
(NP (DT these) (NNS issues)))
(CC and)
(VP
(VB find)
(PRT (RP out))
(SBAR-NOM
(WHNP (WHNP (WP what)))
(S
(VP
(VBZ is)
(ADJP-PRD (JJ present))
(SBAR
(WHNP (WDT that))
(S
(VP
(VBZ is)
(VP
(VBG creating)
(NP (JJ artificial) (NN volatility)))))))))))))))
(, ,)
('' '')
(NP-SBJ (NNP Mr.) (NNP Fisher))
(VP (VBD said))
(. .))
""")
span_dict = {}
ptb_reader._strip_functional_tags(tree) # pylint: disable=protected-access
ptb_reader._get_gold_spans(tree, 0, span_dict) # pylint: disable=protected-access
assert span_dict == {(1, 1): u'NP', (5, 5): u'PRT', (6, 7): u'NP', (4, 7): u'VP', (10, 10): u'PRT',
(11, 11): u'WHNP-WHNP', (13, 13): u'ADJP', (14, 14): u'WHNP', (17, 18): u'NP',
(16, 18): u'VP', (15, 18): u'S-VP', (14, 18): u'SBAR', (12, 18): u'S-VP',
(11, 18): u'SBAR', (9, 18): u'VP', (4, 18): u'VP', (3, 18): u'S-VP',
(2, 18): u'VP', (1, 18): u'S', (21, 22): u'NP', (23, 23): u'VP', (0, 24): u'S'}
| StarcoderdataPython |
183567 | <filename>ws_icra2022/src/my_pkg/ur5_eyeInhand/frompitoangle.py<gh_stars>0
#!/usr/bin/env python
def getpi(listb):
lista=[]
listcc=[]
for i in listb:
temp=i/180*3.14
lista.append((temp,i))
listcc.append(temp)
return lista
def getangle(listb):
lista=[]
for i in listb:
temp=i/3.14*180
lista.append((i,temp))
return lista
def getangle_new(listb):
lista=[]
for i in listb:
temp=i/3.14*180
lista.append(temp)
return lista
def display(listc):
listpi=[]
listangle=[]
for i in listc:
listpi.append(i[0])
listangle.append(i[1])
#print(i)
print("pi====:",listpi)
print("angle==:",listangle)
return listpi
def getpi_for_py(listc):
listpi=[]
listangle=[]
for i in listc:
listpi.append(i[0])
listangle.append(i[1])
#print(i)
#print("pi====:",listpi)
#print("angle==:",listangle)
return listpi
if __name__=="__main__":
#joint_positions_inpi = [-1.565429989491598, -1.6473701635943812, 0.05049753189086914, -1.4097726980792444,-1.14049534956561487, -0.8895475069154912]
#kk=getangle(joint_positions_inpi)
#joint_position_inangle=[-89.73802487531454, -94.43523230795815, 2.894762974635811, -80.81499543129426, -65.37871430630913, -50.993169186238354]
#aa=getpi(joint_position_inangle)
#display(kk)
reslut=[]
#display(aa)
Q0=[-0.69,-100.70,102.06,-174.24,-90.16,-45.35]
Q1=[-0.69,-91.22,62.51,-151.14,-90.16,-45.36]
#Q0=[-14.49,-49.08,69.91,-203.91,-75.70,-65.06]
#Q1=[-0.12,-50.14,69.91,-199.52,-89.52,-65.07]
Q2=[14.27,-44.13,32.03,-165.34,-100.79,-65.07]
#Q23 = [8.24, -40.93, 15.51, -155.41, -97.56, -65.07]
Q3=[8.24,-40.93,6.51,-146.41,-97.56,-65.07]
Q4=[-0.55,-41.01,6.27,-151.46,-93.72,-65.07]
Q5=[-15.41,-42.01,6.29,-144.16,-73.85,-65.07]
Q6=[-16.84,-54.61,56.91,-186.31,-73.86,-65.08]
Q7=[-3.04,-52.20,49.33,-180.78,-84.35,-65.07]
Q8=[84.81, -124.65, -78.10, 99.59, -96.62, 89.99]
Q9=[1.4794633333333334, -2.17445, -1.3624111111111112, 1.7372922222222222, -1.6854822222222223, 1.5698255555555556]
Q10=[5.,-139.,-79.,-51.,91.,177.]
# print getpi(Q10)
display(getpi(Q10))
# display(getangle(Q9))
#display(getpi(Q0))
#reslut.append(display(getpi(Q8)))
#display(getpi(Q1))
#reslut.append(display(getpi(Q1)))
# display(getpi(Q2))
# reslut.append(display(getpi(Q2)))
# #display(getpi(Q23))
# #reslut.append(display(getpi(Q23)))
# display(getpi(Q3))
# reslut.append(display(getpi(Q3)))
# display(getpi(Q4))
# reslut.append(display(getpi(Q4)))
# display(getpi(Q5))
# reslut.append(display(getpi(Q5)))
# display(getpi(Q6))
# reslut.append(display(getpi(Q6)))
# display(getpi(Q7))
# reslut.append(display(getpi(Q7)))
# print(reslut)
| StarcoderdataPython |
3321376 | <filename>day06/Thead_demo2.py
#!/usr/bin/env python
# -*- coding:utf-8 -*-
'''
t1.join(timeout) #设置子线程等待主线程的时间
t1.join() #join是设置等待时间 如果子线程没有完成就一直等待
t1.join(5) #设置5是等待子线程5秒，5秒后不再等待继续主线程
'''
from threading import Thread
def Foo(arg):
print arg
print 'before'
t1 = Thread(target=Foo,args=(1,)) #创建线程的固定格式
t1.start() #执行线程
t1.join(5) #join是设置等待时间 如果子线程没有完成就一直等待 设置5是等待子线程5秒，5秒后不再等待继续主线程
print 'after' | StarcoderdataPython |
3378749 | <reponame>CiscoSystems/heat<gh_stars>1-10
# vim: tabstop=4 shiftwidth=4 softtabstop=4
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import eventlet
from heat.openstack.common import log as logging
from heat.common import exception
from heat.engine import resource
logger = logging.getLogger(__name__)
class Volume(resource.Resource):
properties_schema = {'AvailabilityZone': {'Type': 'String',
'Required': True},
'Size': {'Type': 'Number'},
'SnapshotId': {'Type': 'String'},
'Tags': {'Type': 'List'}}
def __init__(self, name, json_snippet, stack):
super(Volume, self).__init__(name, json_snippet, stack)
def handle_create(self):
vol = self.cinder().volumes.create(
self.properties['Size'],
display_name=self.physical_resource_name(),
display_description=self.physical_resource_name())
while vol.status == 'creating':
eventlet.sleep(1)
vol.get()
if vol.status == 'available':
self.resource_id_set(vol.id)
else:
raise exception.Error(vol.status)
def handle_update(self, json_snippet):
return self.UPDATE_REPLACE
def handle_delete(self):
if self.resource_id is not None:
vol = self.cinder().volumes.get(self.resource_id)
if vol.status == 'in-use':
logger.warn('cant delete volume when in-use')
raise exception.Error("Volume in use")
self.cinder().volumes.delete(self.resource_id)
class VolumeAttachment(resource.Resource):
properties_schema = {'InstanceId': {'Type': 'String',
'Required': True},
'VolumeId': {'Type': 'String',
'Required': True},
'Device': {'Type': "String",
'Required': True,
'AllowedPattern': '/dev/vd[b-z]'}}
def __init__(self, name, json_snippet, stack):
super(VolumeAttachment, self).__init__(name, json_snippet, stack)
def handle_create(self):
server_id = self.properties['InstanceId']
volume_id = self.properties['VolumeId']
dev = self.properties['Device']
inst = self.stack.clients.attach_volume_to_instance(server_id,
volume_id,
dev)
self.resource_id_set(inst)
def handle_update(self, json_snippet):
return self.UPDATE_REPLACE
def handle_delete(self):
server_id = self.properties['InstanceId']
volume_id = self.properties['VolumeId']
self.stack.clients.detach_volume_from_instance(server_id, volume_id)
def resource_mapping():
return {
'AWS::EC2::Volume': Volume,
'AWS::EC2::VolumeAttachment': VolumeAttachment,
}
| StarcoderdataPython |
1792972 | <reponame>aaditkamat/competitive-programming
# Title: Product of Array Except Self
# Runtime: 140 ms
# Memory: 20.8 MB
class Solution:
def get_left_products(self, nums: List[int]) -> List[int]:
curr_prod = 1
left_prod = []
for num in nums[: : -1]:
left_prod.append(curr_prod * num)
curr_prod *= num
left_prod.reverse()
left_prod.append(1)
return left_prod
def productExceptSelf(self, nums: List[int]) -> List[int]:
left_prod = self.get_left_products(nums)
curr_prod = 1
result = []
for i in range(len(nums)):
result.append(left_prod[i + 1] * curr_prod)
curr_prod *= nums[i]
return result
| StarcoderdataPython |
3280389 | #!/usr/bin/env python
# This script will be run by bazel when the build process starts to
# generate key-value information that represents the status of the
# workspace. The output should be like
#
# KEY1 VALUE1
# KEY2 VALUE2
#
# If the script exits with non-zero code, it's considered as a failure
# and the output will be discarded.
from __future__ import print_function
import subprocess
import sys
CMD = ['git', 'describe', '--always', '--match', 'v[0-9].*', '--dirty']
def revision():
try:
return subprocess.check_output(CMD).strip().decode("utf-8")
except OSError as err:
print('could not invoke git: %s' % err, file=sys.stderr)
sys.exit(1)
except subprocess.CalledProcessError as err:
print('error using git: %s' % err, file=sys.stderr)
sys.exit(1)
print("STABLE_BUILD_QUOTA_LABEL %s" % revision())
| StarcoderdataPython |
3270619 | import os
import sys
import pkg_resources
import numpy as np
from matplotlib.image import imread
import obrero.cal as ocal
import obrero.plot as oplot
import obrero.experimental.enso as oenso
# path where stored logo
DATA_PATH = pkg_resources.resource_filename('obrero', 'data/')
def _add_text_axes(axes, text):
"""Use a given axes to place given text."""
txt = axes.text(0.5, 0.5, text, ha='center', va='center')
axes.axis('off')
return txt
def _latex_authoring(title, author, affil, email):
"""Creates a text object with LaTeX code to include in plots
made with `video_udea`.
""" # noqa
texmsg = []
# lets build it
texmsg.append(r'\begin{center}')
# title
if isinstance(title, list):
for t in title:
texmsg.append(t + r'\\')
else:
texmsg.append(title + r'\\')
# a bit of space
texmsg.append(r'\vspace{1em}')
# authors
if isinstance(author, list):
for a in author:
texmsg.append(r'\tiny{' + a + r'}\\')
else:
texmsg.append(r'\tiny{' + author + r'}\\')
# authors
if isinstance(affil, list):
for a in affil:
texmsg.append(r'\tiny{' + a + r'}\\')
else:
texmsg.append(r'\tiny{' + affil + r'}\\')
# email
if isinstance(email, list):
for e in email:
texmsg.append(r'\tiny{' + e + r'}')
else:
texmsg.append(r'\tiny{' + email + r'}')
# finish
texmsg.append(r'\end{center}')
# join
latext = ' '.join(texmsg)
return latext
def video_udea(dlist, slist, bbox, title, author, affil, email,
rotate, wpx=1920, hpx=1080, dpi=300, lon0=0, dg=1,
save_dir=None, smooth=False, winds=None, xhres=None):
"""Create video made for ExpoIngenieria 2018.
A very specific format was used to produce this video and to keep
it we created this function. It can only be used to produce such
video. In this case we need for sets of data arrays: a variable to
be plotted in an Orthographic projection rotating every `dg`
degrees, two lines of time series area average over a region to be
plotted and compared in an xy-plot, and sea surface temperature
(SST) values to include the ONI time series. The user can also
input horizontal wind fields U and V to have vectors plotted on
top of contours.
Parameters
----------
dlist: list of xarray.DataArray
This list must have the following order:
[variable_for_contours, first_time_series,
second_time_series, sst_array]
The first variable will be plotted in a rotating Orthographic
projection. The time series will be plotted together in an
xy-plot. And the SST array will be used to plot also an ONI
index axes.
slist: list of dict objects of specifications
This list must contain three dict objects: one for the contour
plot, one for the time series plot and one for the ONI index
plot. So the list must be:
[specifications_contours, specifications_time_series,
specifications_oni_index]
For the specifications of the contours see keywords of
function `plot_global_contour`, except keyword `axes`. For the
time series specifications see keywords of the function
`averages_video_udea`. And for the ONI plot see keywords in
the `oni_video_udea` function.
bbox: list of list objects
This is a list of two list objects which have corner
coordinates to plot a squared region: [xcorners,
ycorners]. This in case the user wants to highlight a squared
region somewhere in the Orthographic projection map. This
object can be obatined using function `bbox_linecoords`.
title: str or list of str
Title to be placed in a text-only axes. Input for
`_latex_authoring`. If multiple lines it should be a list of
str in which each str is a single line.
author: str or list of str
Author information to be placed in a text-only axes. Input for
`_latex_authoring`. If multiple lines it should be a list of
str in which each str is a single line.
affil: str or list of str
Affiliation information of author to be placed in a text-only
axes. Input for `_latex_authoring`. If multiple lines it
should be a list of str in which each str is a single line.
email: str or list of str
Author e-mail information to be placed in a text-only
axes. Input for `_latex_authoring`. If multiple lines it
should be a list of str in which each str is a single line.
rotate: list
In this list the user can specify when to rotate the
projection. To do this the user must use dates in the format:
'YYYY-MMM', using 3 letters for the month. So for example if:
rotate = ['1997-Jun', '1998-Dec']
It means that the Orthographic projection will rotate for
those two months only, in spite of the data arrays having more
time steps.
wpx: int, optional
Width in pixels for the images. Default is 1920 px.
hpx: int, optional
Height in pixels for the images. Default is 1080 px.
lon0: float, optional
Initial longitude at which to start rotating every time step.
Default is Greenwich meridian.
dg: float, optional
Degrees step to advance rotation. The maximum possible value is
dg = 360 which means no rotation at all. The slowest possible is
dg = 1. Default is 1.
save_dir: str, optional
If the user wants to save all plotted frames in a folder, they
can set this keyword to a folder name and figures will be
stored there. Otherwise figures will not be saved. Default is
not save plots.
dpi: int, optional
Dots per inch for every frame. Default is 300.
smooth: bool, optional
Use this boolean flag to choose whether to smooth the time
series or not. The smoothing will be done using a rolling mean
every 3-time steps, so if it is monthly data, the user will
actually be plotting 3-monthly rolling averages. Default is
False.
winds: list of xarray.DataArray, optional
If the user has U and V winds data and wants to put vectors on
top of the contours in the Orthographic projection plot, then
they must use this option for input winds like so:
winds = [u, v]
For this to work the user must also use the `xhres` keyword
because the function needs the resolution of the grid in the x
direction to be able to avoid plotting vectors out of the
projection bounds.
xhres: float, optional
Grid resolution in the x direction. This keyword is only used
if `winds` is being used, in which case it is a mandatory
argument.
""" # noqa
# unpack data and specifications
vmap, vline1, vline2, sst = dlist
spec1, spec2, spec3 = slist
# check if wind wanted and given
if winds is not None:
u, v = winds
if xhres is None:
msg = ('if you want wind you must specify horizontal ' +
'horizontal x resolution with \'xhres\' keyword')
raise ValueError(msg)
# only lats in between will have wind
w_ymin = 4
w_ymax = 28
# longitudes will have wind
wlon = 9
# get longitudes as x
x = u.longitude.values
y = u.latitude.values
mlon = x.size
# smooth area averages if wanted
if smooth is True:
vline1 = (vline1.rolling(time=3, min_periods=2)
.mean(keep_attrs=True))
vline2 = (vline2.rolling(time=3, min_periods=2)
.mean(keep_attrs=True))
# get number of times
ntim = vmap.time.size
# get oni series from exp
oni = oenso.oni(sst).values.flatten()
# authoring message
msg = _latex_authoring(title, author, affil, email)
# get dates
dates = ocal.get_dates(vmap.time.values)
# guess number of maps
nmpr = int(360 / dg)
nrots = len(rotate)
totm = (ntim - nrots) + nrots * nmpr
# counter for names
c = 1
# create save directory
save_path = oplot.create_save_dir(save_dir)
# step every time
for t in range(ntim):
# rotate only for specified dates
dstr = dates[t].strftime('%Y-%b')
if dstr in rotate:
rotation = True
nrot = nmpr # number of maps per rotation
else:
rotation = False
nrot = 1
if winds is not None:
clon = x[(x >= lon0 - xhres / 2) & (x < lon0 + xhres / 2)]
idx = np.where(x == clon)[0][0]
# rotate or not
for i in range(nrot):
# create figure instance
fig = oplot.plt.figure(1, figsize=(wpx / dpi, hpx / dpi))
# projection
prj = oplot.ort(central_longitude=lon0)
# create axes for all
ax1 = oplot.plt.subplot2grid((3, 6), (0, 0), colspan=3,
rowspan=3, projection=prj)
ax2 = oplot.plt.subplot2grid((3, 6), (0, 3), colspan=3)
ax3 = oplot.plt.subplot2grid((3, 6), (1, 3), colspan=3)
ax4 = oplot.plt.subplot2grid((3, 6), (2, 3), colspan=2)
ax5 = oplot.plt.subplot2grid((3, 6), (2, 5))
# add axes and title to specifications
spec1['axes'] = ax1
spec1['title'] = r'\texttt{' + dstr + r'}'
# plot
oplot.plot_global_contour(vmap[t], **spec1)
# add wind arrows if given
if winds is not None:
# get winds
U = u[t].values
V = v[t].values
# get longitude range indexes
if (idx + wlon) < mlon:
xrang = np.arange(idx - wlon, idx + wlon + 1,
dtype=int)
else:
xrang = np.arange(idx - mlon - wlon, idx - mlon
+ wlon + 1, dtype=int)
# select those to plot
xx = x[xrang]
yy = y[w_ymin:w_ymax]
uu = U[w_ymin:w_ymax, xrang]
vv = V[w_ymin:w_ymax, xrang]
# add arrows
quiv = ax1.quiver(xx, yy, uu, vv, pivot='middle',
transform=oplot.pcar(),
scale_units='inches',
scale=8500 / 25.4)
# add key
ax1.quiverkey(quiv, 0.9, 0.1, 20, r'20 km h$^{-1}$',
labelpos='S', angle=180)
# bounding box
ax1.plot(bbox[0], bbox[1], '-', linewidth=1,
color='black', transform=oplot.pcar())
# plot averages
averages_video_udea(dates[:t + 1], vline1.values[:t + 1],
vline2.values[:t + 1], ax2, **spec2)
# plot oni
oni_video_udea(dates[:t + 1], oni[:t + 1], ax3, **spec3)
# add message
_add_text_axes(ax4, msg)
# add logo
udea_logo(ax5)
# maximize plot
oplot.plt.tight_layout()
# savefig if provided name
if save_dir is not None:
img = os.path.join(save_path, "rotate_%08d.png" % c)
oplot.plt.savefig(img, dpi=dpi)
oplot.plt.close(fig)
sys.stdout.write('Plotting progress: %d%% \r' %
(100 * c/totm))
sys.stdout.flush()
# update counter
c += 1
else:
oplot.plt.pause(0.05)
# update lon0
if rotation is True:
if lon0 > 0.0:
lon0 = lon0 - dg
else:
lon0 = 360.0
# update clon if winds and get ist index
if winds is not None:
if idx <= mlon - 1:
clon = x[(x >= lon0 - xhres / 2.0) &
(x < lon0 + xhres / 2.0)]
try:
idx = np.where(x == clon)[0][0]
except IndexError:
idx = 0
else:
idx = 0
def oni_video_udea(dates, oni, axes, xticks=None, xlim=None,
ylim=[-3, 3], title='ONI', color='black',
xlabel=r'Year', ylabel=r'($^{\circ}$\,C)'):
"""Plot ONI time series for UdeA video.
In the video there will be an axes with ONI values. This function
will take care of it.
Parameters
----------
dates: pandas.DatetimeIndex
These are the x axis values. Matplotlib will interpret them as
dates and format them as such.
oni: numpy.ndarray
This is a time series. It should be obtained flattening the
values of the data frame that the function `enso.get_oni`
creates.
axes: matplotlib.axes.Axes
Generally created using `figure.add_subplot()`. Since this
plot is to be appended to a larger picture, the axes must be
created outside this function and used as input.
xticks: list or numpy.ndarray, optional
This controls the tick marks in the x axis. Default is to put
a tick from the second year until the end every 2 years.
xlim: list, optional
Limits in the x axis. The user can choose the limit dates in
this axis. Default is to use the first and last items in
`dates`.
ylim: list, optional
Limits in the y axis. Default is [-3, 3].
title: str, optional
Centered title. Default is 'ONI'.
xlabel: str, optional
Title in the x axis. Default is 'Year'.
ylabel: str, optional
Title in the y axis. Default is '(oC)'.
Returns
-------
matplotlib.axes.Axes with plot attached.
""" # noqa
# get ticks
if xticks is None:
xticks = dates[12::48]
# get xlim
if xlim is None:
xlim = [dates[0], dates[-1]]
# get colors for line plots
cm = oplot.plt.get_cmap('bwr')
cred = cm(cm.N)
cblue = cm(0)
# plot last as point
point = oni[-1]
if point > 0.5:
cpoint = cred
elif point < -0.5:
cpoint = cblue
else:
cpoint = 'black'
# line plot
axes.plot(dates, oni, linewidth=1, color=color)
axes.plot(dates[-1], point, 'o', color=cpoint, ms=2)
# axes lims
axes.set_xlim(xlim)
axes.set_ylim(ylim)
# set ticks
axes.set_xticks(xticks)
# horizonatl lines
axes.axhline(y=0, linestyle='--', alpha=0.5, linewidth=1,
color='black')
axes.axhline(y=0.5, linestyle='--', alpha=0.5, linewidth=1,
color=cred)
axes.axhline(y=-0.5, linestyle='--', alpha=0.5, linewidth=1,
color=cblue)
# titling
axes.set_title(title)
axes.set_ylabel(ylabel)
axes.set_xlabel(xlabel)
return axes
def averages_video_udea(dates, dlist, axes, names=['Exp1', 'Exp2'],
colors=['black', 'DodgerBlue'], xticks=None,
xlim=None, ylim=[-3, 3], title='',
xlabel=r'Year', ylabel=''):
"""Plot area average time series of variable for UdeA video.
In the video there will be axes with time series of some variable
for two different data sets averaged spatially. This function will
take care of it.
Parameters
----------
dates: pandas.DatetimeIndex
These are the x axis values. Matplotlib will interpret them as
dates and format them as such.
dlist: list of numpy.ndarrays
Only two arrays are supported. These should be time series of
area averages for some variable.
axes: matplotlib.axes.Axes
Generally created using `figure.add_subplot()`. Since this
plot is to be appended to a larger picture, the axes must be
created outside this function and used as input.
names: list of str, optional
Names to be shown in the legend. They must have the same order
as the data in `dlist`. Default is ['Exp1', 'Exp2']. They will
always be converted to upper case.
colors: list of named colors, optional
Colors for each line. They must have the same order as the
data in `dlist`. Default is ['black', 'DodgerBlue']
xticks: list or numpy.ndarray, optional
This controls the tick marks in the x axis. Default is to put
a tick from the second year until the end every 2 years.
xlim: list of datetime objects, optional
Limits in the x axis. The user can choose the limit dates in
this axis. Default is to use the first and last items in
`dates`.
ylim: list of float, optional
Limits in the y axis. Default is [-3, 3].
title: str, optional
Centered title. Default is empty.
xlabel: str, optional
Title in the x axis. Default is 'Year'.
ylabel: str, optional
Title in the y axis. Default is empty.
Returns
-------
matplotlib.axes.Axes with plot attached.
""" # noqa
# get ticks
if xticks is None:
xticks = dates[12::48]
# get xlim
if xlim is None:
xlim = [dates[0], dates[-1]]
# unpack data
av1, av2 = dlist
# points
point1 = av1[-1]
point2 = av2[-1]
# line plot for land
axes.plot(dates, av1, linewidth=1, color=colors[0],
label=names[0].upper())
axes.plot(dates, av2, linewidth=1, color=colors[1],
label=names[1].upper())
axes.plot(dates[-1], point1, 'o', color=colors[0], ms=2)
axes.plot(dates[-1], point2, 'o', color=colors[1], ms=2)
# set lims
axes.set_xlim(xlim)
axes.set_ylim(ylim)
axes.set_xticks(xticks)
# horizonatl lines
axes.axhline(y=0, linestyle='--', alpha=0.5, linewidth=1,
color='black')
# titling
axes.set_title(title)
axes.set_ylabel(ylabel)
axes.set_xlabel(xlabel)
axes.legend(ncol=2)
return axes
def udea_logo(axes):
"""Add Universidad de Antioquia logo to given axes.
For some plots it is nice to put the logo of the school. This
function was specifically created to be used in `video_udea`
function but might be used elsewhere.
Paramaters
----------
axes: matplotlib.axes.Axes
Generally created using `figure.add_subplot()`.
Returns
-------
matplotlib.axes.Axes with logo attached.
"""
# university logo
logo = imread(DATA_PATH + 'logo-udea_240px.png')
# logo
plog = axes.imshow(logo)
axes.axis('off')
return plog
| StarcoderdataPython |
4804252 | <filename>is_number/__init__.py<gh_stars>0
"""Utility functions to calculate if an object is a number and other things."""
from .core import is_it_number, is_float, add_numbers, get_array_shape
# from module1 import square_plus_one
# from ._version import get_versions
# __version__ = get_versions()["version"]
# del get_versions
| StarcoderdataPython |
31784 | import logging
import pytest
from selenium.webdriver.remote.remote_connection import LOGGER
from stere.areas import Area, Areas
LOGGER.setLevel(logging.WARNING)
def test_areas_append_wrong_type():
"""Ensure a TypeError is raised when non-Area objects are appended
to an Areas.
"""
a = Areas()
with pytest.raises(TypeError) as e:
a.append('1')
assert str(e.value) == (
'1 is not an Area. Only Area objects can be inside Areas.'
)
def test_areas_append():
"""Ensure Area objects can be appended to an Areas."""
a = Areas()
area = Area()
a.append(area)
assert 1 == len(a)
def test_areas_remove():
"""Ensure Areas.remove() behaves like list.remove()."""
a = Areas()
area = Area()
a.append(area)
a.remove(area)
assert 0 == len(a)
def test_areas_len():
"""Ensure Areas reports length correctly."""
a = Areas(['1', '2', '3'])
assert 3 == len(a)
def test_areas_containing_type(test_page):
"""Ensure Areas.containing() returns an Areas object."""
test_page.navigate()
found_areas = test_page.repeating_area.areas.containing(
'link', 'Repeating Link 2',
)
assert isinstance(found_areas, Areas)
def test_areas_containing(test_page):
"""Ensure Areas.containing() returns valid results."""
test_page.navigate()
found_areas = test_page.repeating_area.areas.containing(
'link', 'Repeating Link 2',
)
assert found_areas[0].text.value == 'Repeating Area 2'
def test_areas_containing_nested_attr(test_page):
"""Ensure Areas.containing() handles dot attrs."""
test_page.navigate()
found_areas = test_page.repeating_area.areas.containing(
'nested.ax', 'AX1',
)
assert found_areas[0].nested.ax.value == 'AX1'
def test_areas_containing_invalid_field_name(test_page):
test_page.navigate()
with pytest.raises(AttributeError) as e:
test_page.repeating_area.areas.containing(
'lunk', 'Repeating Link 2')
assert str(e.value) == "'Area' object has no attribute 'lunk'"
def test_areas_containing_nested_attr_invalid_field_name(test_page):
test_page.navigate()
with pytest.raises(AttributeError) as e:
test_page.repeating_area.areas.containing(
'nested.cx', 'CX1')
assert str(e.value) == "'Area' object has no attribute 'cx'"
def test_areas_contain(test_page):
"""Ensure Areas.contain() returns True when a result is found."""
test_page.navigate()
assert test_page.repeating_area.areas.contain("link", "Repeating Link 1")
def test_areas_contain_not_found(test_page):
"""Ensure Areas.contain() returns False when a result is not found."""
test_page.navigate()
assert not test_page.repeating_area.areas.contain(
"link", "Repeating Link 666",
)
| StarcoderdataPython |
3238152 | <gh_stars>0
USER_AGENT = {
# 塞班系统:诺基亚手机浏览器(7.3.1.26)
"Symbian": (
"Mozilla/5.0 (SymbianOS/9.3; Series60/3.2 NokiaE5-00/071.003; Profile/MIDP-2.1 Configuration/CLDC-1.1) "
"AppleWebKit/533.4 (KHTML, like Gecko) NokiaBrowser/7.3.1.26 Mobile Safari/533.4 3gpp-gba"),
# Windows系统(Win10):Chrome浏览器(77.0.3865.90)
"Win10_Chrome": ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36"),
}
| StarcoderdataPython |
3322284 | <filename>24_DynamicProgramming2/Step02/wowo0709.py
import sys
input = sys.stdin.readline
N = int(input())
sizes = [[x for x in map(int,input().split())] for _ in range(N)]
dp = [[0 for _ in range(N)] for _ in range(N)]
for d in range(1,N):
for start in range(N-d):
end = start + d
for i in range(start,end):
tmp = dp[start][i]+dp[i+1][end]+(sizes[start][0]*sizes[i][1]*sizes[end][1])
if i == start:
dp[start][end] = tmp
else:
dp[start][end] = tmp if dp[start][end] > tmp else dp[start][end]
print(dp[0][N-1]) | StarcoderdataPython |
3259137 | <gh_stars>0
import numpy as np
import networkx as nx
import copy
from math import log2
"""
Implementation of the hierarchy coordinates via networkX from
Hierarchy in Complex Networks: The Possible and the Actual [B Corominas-Murtra - 2013] [*] - Supporting Information
Though implemented for unweighted networkX graphs, in the context of its original application,
these are applied to weighted graphs by averaging over the unweighted graphs resulting from
applying thresholds to normalized weighted graphs.
"""
# General Functions:
def distribute(n, end_value_range=None, dist=1, sampled_range_of_dist=(0, 1)):
"""Returns n floats distributed as within the sampled range of provided distribution, rescaled to end_value_range
Defaults to an exponential distribution e^x, x = (0, 1), where int/float values of dist modify the coefficient on x
Parameters
----------
n : int
Number of exponentially distributed points returned
end_value_range : tuple, optional
Range which final values of the distributed points occupy.
Defaults to the distribution's native range
dist : float, default: 1
A in np.exp(A*x)
dist: overloaded: types.FunctionType, optional
Alternate distribution yielding single samples from 1d input
sampled_range_of_dist: tuple, default: (0, 1)
Range of distribution sampled
Returns
-------
pts: numpy array
numpy array of n floats
Examples
--------
n, Max, Min = 100, 10, -10
exp_dist_0 = hc.distribute(n=n, end_value_range=(Min, Max))
exp_dist_1 = hc.distribute(n=n, dist=-2, end_value_range=(Min, Max), sampled_range_of_dist=(1, 2))
dist = lambda x: 4*x*x - 3*x*x*x
parabolic_dist = hc.distribute(n=n, dist=dist, end_value_range=(Min, Max), sampled_range_of_dist=(0, 2))
# Visualization of sampling
plt.xlabel('# samples')
plt.ylabel('sampled value')
plt.plot(exp_dist_0, label='e^x: (0, 1)')
plt.plot(exp_dist_1, label='e^-2x: (1, 2)')
plt.plot(parabolic_dist, label='4x^2 - 3x^3: (0, 2)')
plt.legend()
plt.show()
"""
if isinstance(dist, float) or isinstance(dist, int):
distribution = lambda x: np.exp(dist * x)
else:
distribution = dist
x_increment = np.abs(max(sampled_range_of_dist) - min(sampled_range_of_dist)) / n
pts = np.array([distribution(x_increment*i) for i in range(n)])
pts /= abs(max(pts) - min(pts))
if end_value_range is not None:
pts = pts*(max(end_value_range) - min(end_value_range)) + min(end_value_range)
return pts
def matrix_normalize(matrix, row_normalize=False):
"""normalizes 2d matrices.
Parameters
----------
matrix: square 2d numpy array, nested list,
matrix to be normalized
row_normalize: bool
normalizes row *instead* of default columns if True
Returns
-------
numpy array:
column or row normalized array
Examples
--------
a = np.repeat(np.arange(1, 5), 4).reshape(4, 4)
print(a)
print(np.round(hc.matrix_normalize(a), 2))
print(np.round(hc.matrix_normalize(a, row_normalize=True), 2))
Notes
-----
Should be replaced with appropriate generalized, efficient version
"""
if row_normalize:
row_sums = matrix.sum(axis=1)
return np.array([matrix[index, :] / row_sums[index] if row_sums[index] != 0 else [0] * row_sums.size for index in range(row_sums.size)])
else:
column_sums = matrix.sum(axis=0)
return np.array([matrix[:, index] / column_sums[index] if column_sums[index] != 0 else [0]*column_sums.size for index in range(column_sums.size)]).T
# Hierarchy Coordinate Functions
def weakly_connected_component_subgraphs(G, copy=True):
"""Generate weakly connected components as subgraphs. Re-imported to ensure later NetworkX compatibility
Parameters
----------
G : NetworkX Graph
A directed graph.
copy : bool
If copy is True, graph, node, and edge attributes are copied to the
subgraphs.
Notes
-----
Simply brought in from earlier version of NetworkX to ensure compatibility with later versions.
Not sure why it was dropped...
"""
for comp in nx.weakly_connected_components(G):
if copy:
yield G.subgraph(comp).copy()
else:
yield G.subgraph(comp)
def node_weighted_condense(A, num_thresholds=8, threshold_distribution=None):
"""Returns a series of node_weighted condensed graphs (DAGs) [1]_ and their original nx_graphs.
Parameters
----------
A: numpy array
Adjacency matrix, as square 2d numpy array
num_thresholds: int, default: 8
Number of thresholds and resultant sets of node-weighted Directed Acyclic Graphs
threshold_distribution: float, optional
If true or float, distributes the thresholds exponentially, with an exponent equal to the float input.
Returns
-------
largest_condensed_graphs: list of networkX Graphs
list of node weighted condensed networkx graphs reduced from unweighted digraphs determined by thresholds. (See note)
nx_graphs: list of networkX Graphs
list of unweighted graphs produced from applying thresholds to the original weighted network
Examples
--------
Graphing the resultant network is recommended, as otherwise this is difficult to visualize...
a = np.array([
[0, 0.2, 0, 0, 0],
[0, 0, 0, 0.7, 0],
[0, 0.4, 0, 0, 0],
[0, 0, 0.1, 0, 1.0],
[0, 0, 0, 0, 0],
])
condensed_networks, base_binary_networks = hc.node_weighted_condense(a)
for network in condensed_networks:
print(nx.to_numpy_array(network))
Notes
------
TODO: As multiple independent graphs may form from applying threshold cutoffs to a weighted graph,
only the largest is considered. This might be worth considering in re-evaluating the meaning of
weighted network hierarchy coordinate evaluations. (See pages 7, 8 of [1]_, supplementary material)
An threshold_distribution of None results in a linear distribution, otherwise
the exponential distribution is sampled from exp(x) \in (0, 1)
.. [1] "On the origins of hierarchy in complex networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>,
Proceedings of the National Academy of Sciences 110, no. 33 (2013)
"""
# Establishing Thresholds
if num_thresholds == 1 or np.isclose(np.max(A) - np.min(A), 0, 1e-2):
nx_graphs = [nx.from_numpy_matrix(A, create_using=nx.DiGraph)]
else:
if threshold_distribution is None:
try:
thresholds = list(np.round(np.arange(np.min(A), np.max(A), (np.max(A - np.min(A))) / num_thresholds), 4)) # linear distribution
except:
thresholds = [np.max(A)]*num_thresholds
else:
thresholds = distribute(dist=threshold_distribution, end_value_range=(np.min(A), np.max(A)), n=num_thresholds)
# Converting to binary nx_graphs according to thresholds:
nx_graphs = [nx.from_numpy_matrix(np.where(A > threshold, 1, 0), create_using=nx.DiGraph) for threshold in thresholds]
nx_graphs = [graph for graph in nx_graphs if not nx.is_empty(graph)] # eliminates empty graphs
# TODO: Possibly better to count empty graphs as a 0
condensed_graphs = [nx.condensation(nx_graphs[index]) for index in range(len(nx_graphs))]
largest_condensed_graphs = []
for condensed_graph in condensed_graphs:
largest_condensed_graphs.append(nx.convert_node_labels_to_integers(
max(weakly_connected_component_subgraphs(condensed_graph, copy=True), key=len)))
# networkx.weakly_connected_component_subgraphs comes from networkx 1.10 documentation, and has sense been discontinued.
# For ease of access and future networkx compatibility, it was copied directly to this file before the class declaration.
members = nx.get_node_attributes(largest_condensed_graphs[-1], 'members')
node_weights = [len(w) for w in members.values()]
for node_index in range(len(node_weights)):
largest_condensed_graphs[-1].nodes[node_index]["weight"] = node_weights[node_index]
return largest_condensed_graphs, nx_graphs
def weight_nodes_by_condensation(condensed_graph):
"""Weights nodes according to the integer number of other nodes they condensed. Proposed in _[1]
e.g. if a cycle contained 3 nodes (and became one in condensation)
the resulting node of the condensed graph would then gain weight = 3.
Parameters
----------
condensed_graph: NetworkX Graph
result of a networkx.condensation call, such that the 'members'
attribute is populated with constituent cyclical nodes
Return
------
condensed_graph: NetworkX Graph
node weighted condensed graph
Examples
--------
Visualization also recommended here (with node size prop. weighting)
b = np.array([
[0, 0.2, 0, 0, 0],
[0, 0, 0, 0.7, 0],
[0, 0.4, 0, 0, 0],
[0, 0, 0.1, 0, 1.0],
[0, 0, 0, 0, 0],
])
num_thresholds = 2
condensed_networks, _ = hc.node_weighted_condense(b, num_thresholds=num_thresholds)
for network_index in range(num_thresholds):
print(f"Network {network_index}:")
for node_index in range(len(condensed_networks[network_index].nodes)):
print(f"Node {node_index}, new weight:", condensed_networks[network_index].nodes[node_index]["weight"])
print()
Note:
------
TODO: Might wish to eliminate return, or enable copying
.. [1] "On the origins of hierarchy in complex networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>,
Proceedings of the National Academy of Sciences 110, no. 33 (2013)
"""
node_weights = [len(w) for w in nx.get_node_attributes(condensed_graph, 'members').values()]
for node_index in range(len(node_weights)):
condensed_graph.nodes[node_index]["weight"] = node_weights[node_index]
return condensed_graph # Not be necessary, as the graph itself is updated (not copied)
def max_min_layers(G, max_layer=True):
"""
Returns the maximal (k_in = 0, highest in hierarchy) layer (those nodes with in degree = 0) or the minimal layer (k_out = 0)
Parameters
----------
G: NetworkX Graph
A directed graph.
max_layer: bool, default: True
if True, returns maximal layer (k_in = 0), else returns nodes for which k_out = 0, minimal layer
Return
------
min/max_layer: list
list of node indices as ints
Examples:
a = np.array([
[0, 0, 1, 1, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0],
[0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
])
G = nx.from_numpy_matrix(a, create_using=nx.DiGraph)
print(hc.max_min_layers(G))
print(hc.max_min_layers(G, max_layer=False))
Notes:
-------
TODO: Should be two functions?
"""
if max_layer:
return [node for node in G.nodes() if G.in_degree(node) == 0]
else:
return [node for node in G.nodes() if G.out_degree(node) == 0]
def leaf_removal(G, forward=True):
"""Returns a pruned network, with either maximal (k_in=0)
or minimal (k_out = 0) nodes removed upon call.
Parameters
-----------
G: NetworkX Graph
A directed graph.
forward: bool, default: True
if True, prunes from k_in=0 nodes
Return
-------
NetworkX Graph:
copy of the original graph G without either maximal or minimal nodes
Examples:
---------
a = np.array([
[0, 0, 1, 1, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0],
[0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
])
G = nx.from_numpy_matrix(a, create_using=nx.DiGraph)
print(nx.to_numpy_array(hc.leaf_removal(G)))
print(nx.to_numpy_array(hc.leaf_removal(G, forward=False)))
Raises
------
TODO: NonDAG: will loop infinitely for cyclic input
Notes
------
Crafted as a component of the leaf-removal algorithm given in [1]_;
.. [1] "On the origins of hierarchy in complex networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>,
Proceedings of the National Academy of Sciences 110, no. 33 (2013)
"""
layer = max_min_layers(G, max_layer=forward)
peeled_graph = copy.deepcopy(G)
for node in layer:
peeled_graph.remove_node(node)
return peeled_graph
def recursive_leaf_removal(G, from_top=True, keep_linkless_layer=False):
"""Prunes nodes from top (maximal) or bottom (minimal) recursively. Original DAG is given as first element
Parameters
----------
G: NetworkX graph
A directed graph.
from_top: bool, default: True
Determines whether nodes are removed from the top or bottom of the hierarchy
keep_linkless_layer: bool, default: False
if True, empty, single node and all zero layers are preserved
Return
-------
list of NetworkX Graphs:
Starting with the initial DAG and with successively pruned hierarchy layers
Examples
---------
a = np.array([
[0, 0, 1, 1, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0],
[0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
])
G = nx.from_numpy_matrix(a, create_using=nx.DiGraph)
pruned_to_ground = hc.recursive_leaf_removal(G, from_top=True)
pruned_from_ground = hc.recursive_leaf_removal(G, from_top=False)
print("Pruned from top:")
for pruned_tree in pruned_to_ground:
print(nx.to_numpy_array(pruned_tree))
print("Pruned from bottom:")
for pruned_tree in pruned_from_ground:
print(nx.to_numpy_array(pruned_tree))
"""
dissected_graphs = [copy.deepcopy(G)]
while len(dissected_graphs[-1].nodes()) > 1:
dissected_graphs.append(leaf_removal(dissected_graphs[-1], forward=from_top))
if not keep_linkless_layer:
while nx.is_empty(dissected_graphs[-1]) and len(dissected_graphs) > 1: # catches empty graphs, which are eliminated in node condense
dissected_graphs = dissected_graphs[:-1] # removes empty or single node layer
return dissected_graphs
def orderability(G, condensed_nx_graph=None, num_thresholds=8, threshold_distribution=None):
"""Evaluates orderability, or number of nodes which were not condensed
over total number of nodes in original uncondensed graph. Evaluated as in [1]_
Parameters
----------
G: NetworkX Graph
A directed graph.
condensed_nx_graph: optional
Directed acyclic networkX graph if already evaluated to save computational time
num_thresholds: int, optional
only applicable as node_weighted_condense parameter if G is weighted
threshold_distribution: float, optional
only applicable as node_weighted_condense parameter if G is weighted
Return
-------
float: orderability
Hierarchy coordinate
Examples
---------
a = np.array([
[0, 0.2, 0, 0, 0],
[0, 0, 0, 0.7, 0],
[0, 0.4, 0, 0, 0],
[0, 0, 0.1, 0, 1.0],
[0, 0, 0, 0, 0],
])
G = nx.from_numpy_matrix(a, create_using=nx.DiGraph)
print(hc.orderability(G))
Notes
______
TODO: Not sure what's proper re: optional num_thresholds and threshold_distribution parameter
.. [1] "On the origins of hierarchy in complex networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>,
Proceedings of the National Academy of Sciences 110, no. 33 (2013)
"""
if not np.array_equal(np.unique(nx.to_numpy_array(G)), [0, 1]): # unweighted (non-binary) check
o = 0
condensed_graphs, original_graphs = node_weighted_condense(nx.to_numpy_array(G), # creates binary graphs
num_thresholds=num_thresholds,
threshold_distribution=threshold_distribution)
for index in range(len(condensed_graphs)):
o += orderability(original_graphs[index], condensed_graphs[index])
return o / len(condensed_graphs)
if condensed_nx_graph is None:
condensed_nx_graph = weight_nodes_by_condensation(nx.condensation(G))
non_cyclic_nodes = [node[0] for node in nx.get_node_attributes(condensed_nx_graph, 'weight').items() if node[1] == 1]
total_acyclic_node_weight = sum([weight for weight in nx.get_node_attributes(condensed_nx_graph, 'weight').values()])
return len(non_cyclic_nodes) / total_acyclic_node_weight
def feedforwardness_iteration(G):
"""Performs a single iteration of the feedforward algorithm described in [1]_
Parameters
----------
G: NetworkX Graph
a directed, acyclic graph [1]_
Return
--------
g: float
sum of feedforwardness for a single Directed Acyclic Graph
num_paths: int
sum total paths considered
Examples
---------
a = np.array([
[0, 0.2, 0, 0, 0],
[0, 0, 0, 0.7, 0],
[0, 0.4, 0, 0, 0],
[0, 0, 0.1, 0, 1.0],
[0, 0, 0, 0, 0],
])
condensed_networks, base_binary_networks = hc.node_weighted_condense(a)
for network in condensed_networks:
print(nx.to_numpy_array(network))
g, paths = hc.feedforwardness_iteration(network)
print('g: {0}, # paths: {1}'.format(g, paths))
Notes
______
g(G) = sum of F over all paths from maximal to minimal nodes
.. [1] "On the origins of hierarchy in complex networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>,
Proceedings of the National Academy of Sciences 110, no. 33 (2013)
"""
max_layer = max_min_layers(G, max_layer=True)
min_layer = max_min_layers(G, max_layer=False)
weights = nx.get_node_attributes(G, 'weight')
g = 0
num_paths = 0
for max_node in max_layer:
for min_node in min_layer:
for path in nx.all_simple_paths(G, source=max_node, target=min_node):
g += len(path) / sum([weights[node] for node in path]) # where each path calculation is F(path)
num_paths += 1
return g, num_paths
def feedforwardness(DAG):
"""
Parameters
----------
DAG: NetworkX Graph
A Directed, Acyclic Graph.
Return
-------
float:
feedforwardness, hierarchy coordinate
Examples
---------
a = np.array([
[0, 0.2, 0, 0, 0],
[0.4, 0, 0, 0.7, 0],
[0, 0.4, 0, 0, 0],
[0, 0, 0.1, 0, 1.0],
[0, 0, 0, 0, 0],
])
condensed_networks, base_binary_networks = hc.node_weighted_condense(a)
for network in condensed_networks:
print("\nDAG: \n", nx.to_numpy_array(network))
print("Feedforwardness: {0}".format(hc.feedforwardness(network)))
Notes
______
feedforwardness is calculated by pruning layers of the original graph and averaging
over subsequent feedforwardness calculations.
"""
# Must be fed the set of graphs with nodes lower on the hierarchy eliminated first
successively_peeled_nx_graphs = recursive_leaf_removal(DAG, from_top=False)
if len(successively_peeled_nx_graphs) == 1 and len(successively_peeled_nx_graphs[0].nodes()) == 1:
return 0
f = 0
total_num_paths = 0
for nx_graph in successively_peeled_nx_graphs:
g, paths = feedforwardness_iteration(nx_graph)
f += g
total_num_paths += paths
return f / total_num_paths
def graph_entropy(DAG, forward_entropy=False):
"""
Parameters
----------
DAG: NetworkX Graph
Directed Acyclic Graph
forward_entropy: Bool, default: False
if True, calculates entropy from maximal nodes (k_in = 0) nodes to others.
Otherwise calculates using paths from the bottom (minimal nodes) of the network.
Return
-------
entropy: float
graph entropy, in [1]_, eq.14/16 ( H_b/f (G_C) )
Examples
---------
b = np.array([
[0, 0, 1, 0, 0, 0, 1],
[0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 0],
])
condensed_network_layers = hc.recursive_leaf_removal(nx.condensation(nx.from_numpy_matrix(b, create_using=nx.DiGraph)))
fwd_graph_entropy = [round(hc.graph_entropy(net, forward_entropy=True), 3) for net in condensed_network_layers]
bkwd_graph_entropy = [round(hc.graph_entropy(net), 3) for net in condensed_network_layers]
print("fwd graph entropy (from top | bottom): {0} | {1}".format(fwd_graph_entropy, bkwd_graph_entropy))
Notes
______
As described in the text of _[1]:
Graph Entropy, B(G)_ij, is measure of probability of crossing a node n_j when following a path from n_i.
Found in _[1], proposed and developed in _[2], _[3].
.. [1] "On the origins of hierarchy in complex networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>,
Proceedings of the National Academy of Sciences 110, no. 33 (2013)
.. [2] "Topological reversibility and causality in feed-forward networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>.
New Journal of Physics 12, no. 11 (2010): pg 113051
.. [3] "Measuring the hierarchy of feedforward networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>.
Chaos: An Interdisciplinary Journal of Nonlinear Science 21, no. 1 (2011): pg 016108.
"""
dag = nx.convert_node_labels_to_integers(DAG)
L_GC = len(recursive_leaf_removal(DAG)) # Could be passed in most contexts to reduce redundant computation
if forward_entropy:
B_prime = matrix_normalize(nx.to_numpy_array(dag), row_normalize=True)
P = sum([np.power(B_prime, k) for k in range(1, L_GC+1)]) #+1 as k \in ( 1, L(G_C) )
# TODO: Not so sure about this unless k coincides with the number of steps already taken (and the sum is odd)
else:
B = matrix_normalize(nx.to_numpy_array(dag), row_normalize=False)
P = sum([np.power(B.T, k) for k in range(1, L_GC+1)])
boundary_layer = max_min_layers(dag, max_layer=forward_entropy)
non_extremal_nodes = set(dag.nodes() - boundary_layer)
entropy = 0
for layer_node in boundary_layer:
for non_extremal_node in non_extremal_nodes:
if forward_entropy:
# entropy += P[layer_node][non_extremal_node] * np.log(dag.out_degree(layer_node)) # nan for 0 outdegree
entropy += P[layer_node][non_extremal_node] * log2(dag.out_degree(layer_node)) # nan for 0 outdegree
else:
# entropy += P[layer_node][non_extremal_node] * np.log(dag.in_degree(layer_node))
entropy += P[layer_node][non_extremal_node] * log2(dag.in_degree(layer_node))
entropy /= len(boundary_layer)
return entropy
def infographic_graph_entropy(DAG, forward_entropy=False):
"""
Parameters
----------
DAG: NetworkX Graph
Directed Acyclic Graph
forward_entropy: Bool, default: False
if True, calculates entropy from maximal nodes (k_in = 0) nodes to others.
Otherwise calculates using paths from the bottom (minimal nodes) of the network.
Return
-------
entropy: float
graph entropy, in [1]_, eq.14/16 ( H_b/f (G_C) )
Examples
---------
b = np.array([
[0, 0, 1, 0, 0, 0, 1],
[0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 0],
])
condensed_network_layers = hc.recursive_leaf_removal(nx.condensation(nx.from_numpy_matrix(b, create_using=nx.DiGraph)))
fwd_graph_entropy = [round(hc.infographic_graph_entropy(net, forward_entropy=True), 3) for net in condensed_network_layers]
bkwd_graph_entropy = [round(hc.infographic_graph_entropy(net), 3) for net in condensed_network_layers]
print("fwd graph entropy (from top | bottom): {0} | {1}".format(fwd_graph_entropy, bkwd_graph_entropy))
Notes
______
As described in the infographic of _[1] (figure 14):
Graph Entropy, B(G)_ij, is measure of probability of crossing a node n_j when following a path from n_i.
Found in _[1], proposed and developed in _[2], _[3].
.. [1] "On the origins of hierarchy in complex networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>,
Proceedings of the National Academy of Sciences 110, no. 33 (2013)
.. [2] "Topological reversibility and causality in feed-forward networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>.
New Journal of Physics 12, no. 11 (2010): pg 113051
.. [3] "Measuring the hierarchy of feedforward networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>.
Chaos: An Interdisciplinary Journal of Nonlinear Science 21, no. 1 (2011): pg 016108.
"""
dag = nx.convert_node_labels_to_integers(DAG)
start_layer = max_min_layers(dag, max_layer=forward_entropy)
end_layer = max_min_layers(dag, max_layer=not forward_entropy)
entropy = 0
for start_node in start_layer:
for end_node in end_layer:
if forward_entropy:
paths = list(nx.all_simple_paths(dag, source=start_node, target=end_node))
else:
paths = list(nx.all_simple_paths(dag.reverse(copy=True), source=start_node, target=end_node))
for path in paths:
if forward_entropy:
n = sum([dag.out_degree(node) for node in path[:-1] if dag.out_degree(node) != 1])
# Except ones as they don't indicate further possible paths
if n == 0:
n = 1
else:
n = sum([dag.in_degree(node) for node in path[:-1] if dag.in_degree(node) != 1])
if n == 0:
n = 1
# entropy += np.log(n) / n
entropy += log2(n) / n
entropy /= len(start_layer)
return entropy
def single_graph_treeness(DAG):
"""
Parameters
----------
DAG: NetworkX Graph
Directed acyclic graph
Return
-------
float:
treeness for a single DAG (equation 17 from [1])
Examples
---------
a = np.array([
[0, 0, 1, 1, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0],
[0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
])
print("treeness (single graph): {0}".format(hc.single_graph_treeness(condensed_networks)))
Notes
______
.. [1] "On the origins of hierarchy in complex networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>,
Proceedings of the National Academy of Sciences 110, no. 33 (2013)
"""
if len(DAG.nodes()) == 1:
return 0
forward_entropy = graph_entropy(DAG, forward_entropy=True)
backward_entropy = graph_entropy(DAG, forward_entropy=False)
if forward_entropy == 0 and backward_entropy == 0:
return 0
return (forward_entropy - backward_entropy) / max(forward_entropy, backward_entropy)
def treeness(DAG):
"""
Parameters
----------
DAG: NetworkX Graph
Directed Acyclic networkX Graph
Return
-------
float:
Treeness, hierarchy coordinate, Equation 18 from _[1]
Examples
---------
b = np.array([
[0, 0, 1, 0, 0, 0, 1],
[0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 0],
])
dag = nx.condensation(nx.from_numpy_matrix(b, create_using=nx.DiGraph))
print("treeness (b): {0}".format(hc.treeness(dag)))
Notes
______
.. [1] "On the origins of hierarchy in complex networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>,
Proceedings of the National Academy of Sciences 110, no. 33 (2013)
"""
pruned_from_top = recursive_leaf_removal(G=DAG, from_top=True)
pruned_from_bottom = recursive_leaf_removal(G=DAG, from_top=False)
# removal of original graphs from subsets:
pruned_from_top = pruned_from_top[1:]
pruned_from_bottom = pruned_from_bottom[1:]
entropy_sum = single_graph_treeness(DAG)
for index in range(len(pruned_from_top)):
entropy_sum += single_graph_treeness(pruned_from_top[index])
for index in range(len(pruned_from_bottom)):
entropy_sum += single_graph_treeness(pruned_from_bottom[index])
return entropy_sum / (1 + len(pruned_from_bottom) + len(pruned_from_top))
def hierarchy_coordinates(A, num_thresholds=8, threshold_distribution=None):
"""
Parameters
----------
A: 2d numpy array or networkX graph
numpy Adjacency matrix or networkx of which hierarchy coordinates will be calculated
num_thresholds: int, optional
specifies number of weighted graph subdivisions
threshold_distribution: None, float or lambda fct ptr, default: None
determines the distribution of threshold values used to create unweighted from weighted networks.
if None, creates a linear distribution of thresholds spanning the set of weights evenly.
if float, is the coefficient of exp(Ax) sampled between (0, 1) and rescaled appropriately.
if a lambda expression, determines a custom distribution sampled between (0, 1) and rescaled appropriately.
Return
-------
tuple of floats:
(treeness, feedforwardness, orderability) hierarchy coordinates
Examples
---------
a = np.array([
[0, 0.2, 0, 0, 0],
[0, 0, 0, 0.7, 0],
[0, 0.4, 0, 0, 0],
[0, 0.3, 0.1, 0, 1.0],
[0, 0, 0, 0, 0],
])
b = np.array([
[0, 0, 1, 0, 0, 0, 1],
[0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 0],
])
print('(a) Treeness: {0} | Feedforwardness: {1} | Orderability: {2}'.format(*np.round(hc.hierarchy_coordinates(a), 2)))
print('(b) Treeness: {0} | Feedforwardness: {1} | Orderability: {2}'.format(*np.round(hc.hierarchy_coordinates(b), 2)))
Notes
______
.. [1] "On the origins of hierarchy in complex networks."
Corominas-Murtra, Bernat, <NAME>, <NAME>, and <NAME>,
Proceedings of the National Academy of Sciences 110, no. 33 (2013)
returns the averaged hierarchy coordinates given the adjacency matrix A
"""
np_A = []
if isinstance(A, nx.DiGraph) or isinstance(A, nx.Graph) or isinstance(A, nx.MultiGraph) or isinstance(A, nx.MultiDiGraph):
np_A = nx.to_numpy_array(A)
elif isinstance(A, np.ndarray):
np_A = A
else:
print('A must be given as either a networkx graph or adjacency matrix (as nested list or 2d numpy array)')
if np.array_equal(np.unique(np_A), [0]): # null check
# raise Exception("Unconnected graph; trivially 0 hierarchy") # TODO: Raise exception if undefined instead
return 0, 0, 0
if np.array_equal(np.unique(np_A), [0, 1]): # binary check
num_thresholds = 1
else:
num_thresholds = num_thresholds
o, f, t = 0, 0, 0
condensed_graphs, original_graphs = node_weighted_condense(A=np_A, num_thresholds=num_thresholds, threshold_distribution=threshold_distribution)
for index in range(len(condensed_graphs)):
t += treeness(condensed_graphs[index])
f += feedforwardness(condensed_graphs[index])
o += orderability(original_graphs[index], condensed_graphs[index])
t /= len(condensed_graphs); f /= len(condensed_graphs); o /= len(condensed_graphs)
return t, f, o
########################################################################################################################
if __name__ == "__main__":
# CHECK VERSIONS
vers_python0 = '3.7.3'
vers_numpy0 = '1.17.3'
vers_netx0 = '2.4'
from sys import version_info
from networkx import __version__ as vers_netx
vers_python = '%s.%s.%s' % version_info[:3]
vers_numpy = np.__version__
print('\n------------------- Hierarchy Coordinates -----------------------\n')
print('Required modules:')
print('Python: tested for: %s. Yours: %s' % (vers_python0, vers_python))
print('numpy: tested for: %s. Yours: %s' % (vers_numpy0, vers_numpy))
print('networkx: tested for: %s. Yours: %s' % (vers_netx0, vers_netx))
print('\n------------------------------------------------------------------\n') | StarcoderdataPython |
3306496 | #!/usr/bin/env python3
import sys, os, gzip, math
infile = gzip.open(sys.argv[1])
nind = float(sys.argv[2])
outfile = open(sys.argv[3], "w")
N = 5000
pos2gpos = dict()
poss = list()
line = infile.readline()
while line:
line = line.strip().split()
pos = int(line[1])
gpos = float(line[2])
pos2gpos[pos] = gpos
poss.append(pos)
line = infile.readline()
print(len(poss))
nsnp = len(poss)
chunk = float(nsnp)/float(N)
print(chunk)
chunk = int(math.floor(chunk))
print(chunk)
for i in range(chunk):
start = i*N
end = i*N + N
if i == chunk-1:
end = len(poss)-1
startpos = poss[start]
endpos = poss[end]
# print >> outfile, startpos, endpos
print(str(startpos)+' '+str(endpos), file=outfile)
continue
startpos = poss[start]
endpos = poss[end-1]
endgpos = pos2gpos[endpos]
test =end+1
testpos = poss[test]
stop = False
while stop == False:
if test == len(poss):
stop = True
continue
testpos = poss[test]
testgpos = pos2gpos[testpos]
df = testgpos-endgpos
tmp = math.exp( -4.0*11418.0*df / (2.0*nind))
if tmp < 1.5e-8:
stop = True
else:
test = test+1
# print >> outfile, startpos, testpos
print(str(startpos)+' '+str(testpos), file=outfile)
| StarcoderdataPython |
4815807 | #!/usr/bin/python3
import subprocess
from dg_storage import *
from shutil import copyfile
import re
import tempfile
import multiprocessing
RE = re.compile(r'RE\[([^\]]+)\]')
def score_game(sgf):
"""
Returns the winner of the game in the given SGF file as
judged by `gnugo`.
"""
with tempfile.NamedTemporaryFile() as sgf_file:
sgf_file.write(sgf.encode())
sgf_file.flush()
# start-up our judge (gnugo)
gnugo = subprocess.Popen(
['/usr/games/gnugo',
'--score', 'aftermath',
'--chinese-rules', '--positional-superko',
'-l', sgf_file.name],
stdin=subprocess.DEVNULL,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL
)
try:
for line in gnugo.stdout:
line = line.decode('utf-8').strip()
if 'White wins by' in line: # White wins by 8.5 points
return 'W+' + line.split()[3]
elif 'Black wins by' in line: # Black wins by 32.5 points
return 'B+' + line.split()[3]
finally:
gnugo.communicate()
def clean_game(sgf):
""" Returns the given game after it has been _cleaned up_. """
winner = RE.search(sgf)
resign = winner and 'R' in winner.group(1).upper()
if winner and not resign:
winner = score_game(sgf)
if winner:
sgf = re.sub(RE, 'RE[' + winner + ']', sgf)
return sgf
# (1) download recent network
# (2) generate 1,000 fresh game records
if __name__ == '__main__':
best_network = copy_most_recent_network()
if best_network:
copyfile(best_network, '/app/dream_go.json')
game_records = ''
env = {}
proc = subprocess.Popen([
'/app/dream_go',
'--self-play', '1000',
'--num-rollout', '800',
'--num-threads', '64',
'--batch-size', '16'
], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
with multiprocessing.Pool() as pool:
def add_game_record(x):
global game_records
game_records += x
game_records += '\r\n'
# score the games as they get finished by the engine
for line in proc.stdout:
line = line.decode('utf-8').strip()
pool.apply_async(clean_game, [line], callback=add_game_record)
# wait for everything to finish
_stdout, _stderr = proc.communicate()
if proc.returncode != 0:
quit(proc.returncode)
pool.close()
pool.join()
upload_game_records(game_records, from_network=best_network, env=env, args=proc.args)
| StarcoderdataPython |
4816357 | <filename>pyinsteon/device_types/plm.py<gh_stars>10-100
"""Insteon Powerline Modem (PLM)."""
from ..aldb.plm_aldb import PlmALDB
from .modem_base import ModemBase
class PLM(ModemBase):
"""Insteon PLM class."""
def __init__(
self,
address="000000",
cat=0x03,
subcat=0x00,
firmware=0x00,
description="",
model="",
):
"""Init the Modem class."""
super().__init__(address, cat, subcat, firmware, description, model)
self._aldb = PlmALDB(self._address)
| StarcoderdataPython |
61918 | from itertools import permutations
from string import ascii_lowercase
INPUT_PATH = 'input.txt'
def get_input(path=INPUT_PATH):
"""Get the input for day 5.
This should all be one long string. I tested with the given input and we don't need to join
the lines but it's just a bit less brittle this way."""
with open(path) as f:
return ''.join(f.readlines()).strip()
def react_polymer(polymer):
"""React the polymer with a brute force method.
Just iterate the possible character pairs and remove them, then check whether the
new string is the same as the old one."""
pairs = [''.join(s) for s in permutations('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 2)
if s[0].casefold() == s[1].casefold() and s[0].islower() != s[1].islower()]
while True:
old_polymer = polymer
for pair in pairs:
polymer = polymer.replace(pair, '')
if polymer == '' or old_polymer == polymer:
return polymer
def polymer_reductions(polymer):
return (polymer.replace(l, '').replace(l.upper(), '') for l in ascii_lowercase)
def shortest_reduced_polymer(polymer):
return min(len(react_polymer(p)) for p in polymer_reductions(polymer))
| StarcoderdataPython |
131562 | <filename>1-alltodoor.py
import csv
import pandas as pd
from csv import reader, writer
A1A2_data1 = []
highway_traffic_data = []
highway_traffic_data_first = []
highway_traffic_next = []
highway_traffic_pre = []
def read_csv_file(filename):
with open(filename, encoding='utf-8', newline='') as file:
for row in file:
highway_traffic_data.append(row)
return csv.reader(file)
def read_csv_file1(filename):
with open(filename, encoding='utf-8', newline='') as file:
for row in file:
A1A2_data1.append(row)
return csv.reader(file)
df = read_csv_file('/Users/lofangyu/Documents/highway＿data analytics/highway_traffic_data_104.csv')
df1 = read_csv_file1('/Users/lofangyu/Documents/highway＿data analytics/A1A2Table1.csv')
for i in range (len(highway_traffic_data)):
highway_traffic_data[i] = highway_traffic_data[i].split(',')
for i in range (len(A1A2_data1)):
A1A2_data1[i] = A1A2_data1[i].split(',')
#print(A1A2_data1[0][25:29])
#print(A1A2_data1[1083][25:29])
#print(A1A2_data1[1083][6:9])
#print(int(A1A2_data1[1083][26]+A1A2_data1[1083][27]))
#print(A1A2_data1[1083][6][7:])
#print(A1A2_data1[1][6][5])
#print(A1A2_data1[123][28])
print(A1A2_data1[0][54])
print(A1A2_data1[0][55])
#2015/1事故
day = []
for i in range(31):
day.append(str(i+1))
etc_20150101 = []
# 17 22/18 20/ 19 25/ 20 28/ 21 28/ 22 28/ 23 24/24 19/ 25 18/ 26 20/ 27 22/ 28 22
day = '28'
last_day = '24'
next_day = '30'
month = '03'
last_month = '01'
last_day_len = 20
day_len = 23
next_day_len = 19
for i in range(len(A1A2_data1)-1):
if A1A2_data1[i+1][6][2:4] == '15' and A1A2_data1[i+1][6][5] == str(int(month)) and A1A2_data1[i+1][6][7:] == str(int(day)) and A1A2_data1[i+1][28] != '西' and A1A2_data1[i+1][28] != '東':
etc_20150101.append(A1A2_data1[i+1][6:9] + A1A2_data1[i+1][25:29] + A1A2_data1[i+1][54:56])
for i in range(len(etc_20150101)):
if etc_20150101[i][6] == '南':
etc_20150101[i][6] = 'S'
if etc_20150101[i][6] == '北':
etc_20150101[i][6] = 'N'
if etc_20150101[i][3][2] == '3':
etc_20150101[i][3] = '國道三號'
if etc_20150101[i][3][2] == '1':
etc_20150101[i][3] = '國道一號'
#for i in range(len(etc_20150101)):
# print(etc_20150101[i])
#########
print(etc_20150101)
#單一事故去找發生的門架（國道/向南向北）
for j in range(len(etc_20150101)):
highway_traffic_data_first = []
highway_traffic_next = []
highway_traffic_pre = []
for i in range(len(highway_traffic_data)):
if highway_traffic_data[i][0] == etc_20150101[j][3] and highway_traffic_data[i][1] == etc_20150101[j][6]:
highway_traffic_data_first.append(highway_traffic_data[i])
#pre 門架
for i in range(len(highway_traffic_data_first)):
#print(int(highway_traffic_data_first[i][3][3:7]))
if etc_20150101[j][3] != '國道五號':
if int(highway_traffic_data_first[i][3][3:7]) < int(etc_20150101[j][4]+etc_20150101[j][5][0]):
highway_traffic_pre.append(highway_traffic_data_first[i][3][3:7])
else:
if int(highway_traffic_data_first[i][3][4:7]) < int(etc_20150101[j][4]+etc_20150101[j][5][0]):
highway_traffic_pre.append(highway_traffic_data_first[i][3][4:7])
for i in range(len(highway_traffic_data_first)):
if etc_20150101[j][3] != '國道五號':
if highway_traffic_pre !=[]:
if highway_traffic_data_first[i][3][3:7] == max(highway_traffic_pre):
#print(highway_traffic_data_first[i])
etc_20150101[j].append(highway_traffic_data_first[i][3])
else:
etc_20150101[j].append('NO')
break
else:
if highway_traffic_pre !=[]:
if highway_traffic_data_first[i][3][4:7] == max(highway_traffic_pre):
#print(highway_traffic_data_first[i])
etc_20150101[j].append(highway_traffic_data_first[i][3])
else:
etc_20150101[j].append('NO')
break
#next 門架
for i in range(len(highway_traffic_data_first)):
if etc_20150101[j][3] != '國道五號':
if int(highway_traffic_data_first[i][3][3:7]) >= int(etc_20150101[j][4]+etc_20150101[j][5][0]):
highway_traffic_next.append(highway_traffic_data_first[i][3][3:7])
else:
if int(highway_traffic_data_first[i][3][4:7]) >= int(etc_20150101[j][4]+etc_20150101[j][5][0]):
highway_traffic_next.append(highway_traffic_data_first[i][3][4:7])
for i in range(len(highway_traffic_data_first)):
if etc_20150101[j][3] != '國道五號':
if highway_traffic_next != []:
if highway_traffic_data_first[i][3][3:7] == min(highway_traffic_next):
#print(highway_traffic_data_first[i])
etc_20150101[j].append(highway_traffic_data_first[i][3])
else:
etc_20150101[j].append('NO')
break
else:
if highway_traffic_next != []:
if highway_traffic_data_first[i][3][4:7] == min(highway_traffic_next):
#print(highway_traffic_data_first[i])
etc_20150101[j].append(highway_traffic_data_first[i][3])
else:
etc_20150101[j].append('NO')
break
for i in range(len(etc_20150101)):
if len(etc_20150101[i][1]) == 1:
etc_20150101[i][1] = '0' + etc_20150101[i][1]
print(etc_20150101[i])
etc_len = []
for i in range(len(etc_20150101)):
etc_len.append(str(i))
#open ets text
def open_txt_split(filename):
f = open(r'/Users/lofangyu/Documents/highway＿data analytics/2015ETC/201503/'+filename+'.txt')
file1 = []
for line in f:
file1.append(line)
for i in range (len(file1)):
file1[i] =file1[i].split(',')
return file1
ad = 0
if ad != 1:
with open('etc201502_A1A2.csv', 'a', newline='') as csvfile:
writer = csv.writer(csvfile)
writer.writerows(etc_20150101)
for b in range(day_len):
df = open_txt_split('2015'+ month + day + '-'+ str(b+1))
def Average(lst):
return sum(lst) / len(lst)
for j in range(len(etc_20150101)):
total_time = []
enter_car = []
out_car = []
for i in range(len(df)):
if df[i][2] == etc_20150101[j][9]:
if int(etc_20150101[j][1]) == 0:
if int(df[i][1][8:10]) == int(last_day) and int(df[i][1][11:13]) == 23 and int(df[i][1][14:16]) >= int(etc_20150101[j][2]):
enter_car.append(df[i])
if int(df[i][1][8:10]) ==int(day) and int(df[i][1][11:13]) == (int(etc_20150101[j][1]) - 1) and int(df[i][1][14:16]) >= int(etc_20150101[j][2]):
enter_car.append(df[i])
if int(df[i][1][8:10]) ==int(day) and int(df[i][1][11:13]) == (int(etc_20150101[j][1]) + 1) and int(df[i][1][14:16]) <= int(etc_20150101[j][2]):
#print(int(df[i][1][11:13]))
enter_car.append(df[i])
if int(etc_20150101[j][1]) == 23:
if int(df[i][1][8:10]) == int(next_day) and int(df[i][1][11:13]) == 0 and int(df[i][1][14:16]) <= int(etc_20150101[j][2]):
enter_car.append(df[i])
if int(df[i][1][8:10]) ==int(day) and int(df[i][1][11:13]) == int(etc_20150101[j][1]):
enter_car.append(df[i])
if df[i][2] == etc_20150101[j][10]:
if int(etc_20150101[j][1]) == 0:
if int(df[i][1][8:10]) == int(last_day) and int(df[i][1][11:13]) == 23 and int(df[i][1][14:16]) >= int(etc_20150101[j][2]):
out_car.append(df[i])
if int(df[i][1][8:10]) ==int(day) and int(df[i][1][11:13]) == (int(etc_20150101[j][1]) - 1) and int(df[i][1][14:16]) >= int(etc_20150101[j][2]):
out_car.append(df[i])
if int(df[i][1][8:10]) ==int(day) and int(df[i][1][11:13]) == (int(etc_20150101[j][1]) + 1) and int(df[i][1][14:16]) <= int(etc_20150101[j][2]):
out_car.append(df[i])
if int(df[i][1][8:10]) ==int(day) and int(df[i][1][11:13]) == int(etc_20150101[j][1]):
out_car.append(df[i])
if int(etc_20150101[j][1]) == 23:
if int(df[i][1][8:10]) == int(next_day) and int(df[i][1][11:13]) == 0 and int(df[i][1][14:16]) <= int(etc_20150101[j][2]):
out_car.append(df[i])
with open('etc_2015'+month+day+'_inlatehour'+ etc_len[j] + '.csv', 'a', newline='') as csvfile:
writer = csv.writer(csvfile)
writer.writerows(enter_car)
writer.writerows(out_car)
print(str(b+1) + "done")
#print(etc_20150101)
#with open('etc_20150101_output.csv', 'a', newline='') as csvfile:
# writer = csv.writer(csvfile)
# writer.writerows(etc_20150101)
| StarcoderdataPython |
172993 | from tests.test_base import app, client, login
_SCRIPT_ID_HELLO = "pyscriptdemo.helloworld.HelloWorld"
_SCRIPT_ID_HELLO_WITH_PARAMS = "pyscriptdemo.helloworld.HelloWorldWithParams"
def test_hello(app, client):
login(client)
response = client.post("/api/scripts/" + _SCRIPT_ID_HELLO + "/_run")
assert response.json["success"]
assert response.json["message"] == "Hello World !"
test_output = "Hello Mister, Hello Mister, Hello Mister, Hello Mister, Hello Mister, Hello Mister, Hello Mister"
assert response.json["dataOutput"] == test_output
def test_hello_with_params(app, client):
login(client)
response = client.post("/api/scripts/" + _SCRIPT_ID_HELLO_WITH_PARAMS + "/_run")
assert response.json["success"]
assert response.json["dataOutput"]["values"] is None
params = {"a":"default value", "b":10, "c":True, "d":"My text \n in textarea", "e":"1", "f":"b"}
response = client.post("/api/scripts/" + _SCRIPT_ID_HELLO_WITH_PARAMS + "/_run", json=params)
assert response.json["success"]
assert response.json["dataOutput"]["values"] == params
assert response.json["dataOutput"]["params"] == [
{
"id": "a",
"type": "text",
"label": "Type text",
"default": "default value"
}, {
"id": "b",
"type": "number",
"label": "Type number",
"default": 10
}, {
"id": "c",
"type": "checkbox",
"label": "Type checkbox",
"default": True
}, {
"id": "d",
"type": "textarea",
"label": "Type textarea",
"placeholder": "Placeholder",
"default": "My text \n in textarea"
}, {
"id": "e",
"type": "radio",
"label": "Type radio",
"values": [
{"value": "1", "label": "Radio 1"},
{"value": "2", "label": "Radio 2"}
],
"default": "1"
}, {
"id": "f",
"type": "select",
"multiple": False,
"label": "Type select",
"values": [
{"value": "a", "label": "Option a"},
{"value": "b", "label": "Option b"},
{"value": "c", "label": "Option c"}
],
"default": "b"
}]
| StarcoderdataPython |
52100 | <reponame>UAEKondaya1/expressvpn_leak_testing
import ctypes
import netifaces
import NetworkManager # pylint: disable=import-error
from xv_leak_tools.exception import XVEx
from xv_leak_tools.log import L
from xv_leak_tools.process import check_subprocess
class _NetworkObject:
def __init__(self, conn):
self._settings = conn.GetSettings()
self._id = self._settings['connection']['id']
self._uuid = self._settings['connection']['uuid']
def __str__(self):
return "{} ({})".format(self.id(), self.uuid())
def __repr__(self):
return str(self)
def __eq__(self, other):
return self.uuid() == other.uuid()
def uuid(self):
return self._uuid
def id(self):
return self._id
def name(self):
# TODO: Decide on this API.
return self._id
class NetworkService(_NetworkObject):
def active(self):
active_conns = NetworkManager.NetworkManager.ActiveConnections
active_conns = [NetworkService(conn.Connection) for conn in active_conns]
if self in active_conns:
return True
return False
def enable(self):
L.debug("Enabling connection {}".format(self.name()))
check_subprocess(['nmcli', 'connection', 'up', self.name()])
def disable(self):
L.debug("Disabling connection {}".format(self.name()))
check_subprocess(['nmcli', 'connection', 'down', self.name()])
def interface(self):
# TODO: Reject this idea? Maybe interfaces should be chosen without
# regard to connection status, if NM can't be trusted.
# In which case, tests that get a list of interfaces should just use
# netifaces directly.
try:
return self._settings['connection']['interface-name']
except KeyError:
connection_type = self._settings['connection']['type']
# TODO: Test this on different types.
mac_address = self._settings[connection_type]['mac-address']
for iface in netifaces.interfaces():
iface_mac = netifaces.ifaddresses(iface)[netifaces.AF_LINK][0]['addr'].lower()
if mac_address.lower() == iface_mac:
return iface
raise XVEx("Couldn't find any connection interfaces")
def enable_interface(self):
L.debug("Enabling interface {}".format(self.interface()))
# TODO: Move to unix tools or use "ip link set dev iface up"?
check_subprocess(['ifconfig', self.interface(), 'up'])
def disable_interface(self):
L.debug("Disabling interface {}".format(self.interface()))
# TODO: Move to unix tools or use "ip link set dev iface up"?
check_subprocess(['ifconfig', self.interface(), 'down'])
class LinuxNetwork:
@staticmethod
def network_services_in_priority_order():
conns = NetworkManager.Settings.ListConnections()
conns = list(
filter(lambda x: 'autoconnect-priority' in x.GetSettings()['connection'], conns))
# NetworkManager uses int32s so we need to "cast" the autoconnect-priority value.
def uint32(signed_integer):
return int(ctypes.c_uint32(signed_integer).value)
conns.sort(
key=lambda x: uint32(x.GetSettings()['connection']['autoconnect-priority']),
reverse=True)
return [NetworkService(conn) for conn in conns]
| StarcoderdataPython |
3379368 | # Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.
from typing import Any, Mapping, Optional, Union, List, Iterator
from collections import OrderedDict
import logging
import time
import itertools
import yaml
import os
import shutil
import pathlib
TItems = Union[Mapping, str]
# do not reference common or otherwise we will have circular deps
def _fmt(val:Any)->str:
if isinstance(val, float):
return f'{val:.4g}'
return str(val)
class OrderedDictLogger:
"""The purpose of the structured logging is to store logs as key value pair. However, when you have loop and sub routine calls, what you need is hierarchical dictionaries where the value for a key could be a dictionary. The idea is that you set one of the nodes in tree as current node and start logging your values. You can then use pushd to create and go to child node and popd to come back to parent. To implement this mechanism we use two main variables: _stack allows us to push each node on stack when pushd is called. The node is OrderedDictionary. As a convinience, we let specify child path in pushd in which case child hierarchy is created and current node will be set to the last node in specified path. When popd is called, we go back to original parent instead of parent of current node. To implement this we use _paths variable which stores subpath when each pushd call was made.
"""
def __init__(self, filepath:Optional[str], logger:Optional[logging.Logger],
save_delay:Optional[float]=30.0, yaml_log=True) -> None:
super().__init__()
self.reset(filepath, logger, save_delay, yaml_log=yaml_log)
def reset(self, filepath:Optional[str], logger:Optional[logging.Logger],
save_delay:Optional[float]=30.0,
load_existing_file=False, backup_existing_file=True, yaml_log=True) -> None:
self._logger = logger
self._yaml_log = yaml_log
# stack stores dict for each path
# path stores each path created via pushd
self._paths = [['']]
self._save_delay = save_delay
self._call_count = 0
self._last_save = time.time()
self._filepath = filepath
# backup file if already exist
root_od = OrderedDict()
if self._yaml_log and filepath and os.path.exists(filepath):
if load_existing_file:
root_od = yaml.load(self._filepath, Loader=yaml.Loader)
if backup_existing_file:
cur_p = pathlib.Path(filepath)
new_p = cur_p.with_name(cur_p.stem + '.' + str(int(time.time()))
+ cur_p.suffix)
if os.path.exists(str(new_p)):
raise RuntimeError(f'Cannot backup file {filepath} because new name {new_p} already exist')
cur_p.rename(new_p)
self._stack:List[Optional[OrderedDict]] = [root_od]
def debug(self, dict:TItems, level:Optional[int]=logging.DEBUG, exists_ok=False)->None:
self.info(dict, level, exists_ok)
def warn(self, dict:TItems, level:Optional[int]=logging.WARN, exists_ok=False)->None:
self.info(dict, level, exists_ok)
def info(self, dict:TItems, level:Optional[int]=logging.INFO, exists_ok=False)->None:
self._call_count += 1 # provides default key when key is not specified
if isinstance(dict, Mapping): # if logging dict then just update current section
self._update(dict, exists_ok)
msg = ', '.join(f'{k}={_fmt(v)}' for k, v in dict.items())
else:
msg = dict
key = '_warnings' if level==logging.WARN else '_messages'
self._update_key(self._call_count, msg, node=self._root(), path=[key])
if level is not None and self._logger:
self._logger.log(msg=self.path() + ' ' + msg, level=level)
if self._save_delay is not None and \
time.time() - self._last_save > self._save_delay:
self.save()
self._last_save = time.time()
def _root(self)->OrderedDict:
r = self._stack[0]
assert r is not None
return r
def _cur(self)->OrderedDict:
self._ensure_paths()
c = self._stack[-1]
assert c is not None
return c
def save(self, filepath:Optional[str]=None)->None:
filepath = filepath or self._filepath
if filepath:
with open(filepath, 'w') as f:
yaml.dump(self._root(), f)
def load(self, filepath:str)->None:
with open(filepath, 'r') as f:
od = yaml.load(f, Loader=yaml.Loader)
self._stack = [od]
def close(self)->None:
self.save()
if self._logger:
for h in self._logger.handlers:
h.flush()
def _insert(self, dict:Mapping):
self._update(dict, exists_ok=False)
def _update(self, dict:Mapping, exists_ok=True):
for k,v in dict.items():
self._update_key(k, v, exists_ok)
def _update_key(self, key:Any, val:Any, exists_ok=True,
node:Optional[OrderedDict]=None, path:List[str]=[]):
if not self._yaml_log:
return
if not exists_ok and key in self._cur():
raise KeyError(f'Key "{key}" already exists in log at path "{self.path()}" and cannot be updated with value {val} because it already has value "{self._cur()[key]}". Log is being saved at "{self._filepath}".')
node = node if node is not None else self._cur()
for p in path:
if p not in node:
node[p] = OrderedDict()
node = node[p]
node[str(key)] = val
def _ensure_paths(self)->None:
if not self._yaml_log:
return
if self._stack[-1] is not None:
return
last_od = None
for i, (path, od) in enumerate(zip(self._paths, self._stack)):
if od is None: # if corresponding dict is being delayed created
od = last_od
for key in path:
if key not in od:
od[key] = OrderedDict()
if not isinstance(od[key], OrderedDict):
raise RuntimeError(f'The key "{key}" is being used to store scaler value as well as in popd')
od = od[key]
self._stack[i] = od
last_od = od
def pushd(self, *keys:Any)->'OrderedDictLogger':
if not self._yaml_log:
return self
"""Creates new path as specified by the sequence of the keys"""
self._paths.append([str(k) for k in keys])
self._stack.append(None) # delay create
return self # this allows calling __enter__
def popd(self):
if not self._yaml_log:
return
if len(self._stack)==1:
raise RuntimeError('There is no child logger, popd() call is invalid')
self._stack.pop()
self._paths.pop()
def path(self)->str:
if not self._yaml_log:
return '/'
# flatten array of array
return '/'.join(itertools.chain.from_iterable(self._paths[1:]))
def __enter__(self)->'OrderedDictLogger':
return self
def __exit__(self, type, value, traceback):
self.popd()
def __contains__(self, key:Any):
return key in self._cur()
def __len__(self)->int:
return len(self._cur())
| StarcoderdataPython |
49667 | <filename>gallery/mode/photo_manager.py
# -*- coding: utf-8 -*-
'''
Created on Mar 19, 2015
@author: Bob.Chen
'''
import sys
import urllib2
import time
from PIL import Image
from constant import PHOTO_DATA_ROOT
from common import Logger, RandomID, getPhotoUrl, getPhotoPath
from error_api import Err
from gallery.models import Photo
from StringIO import StringIO
class PhotoManager(object):
@staticmethod
def addPhoto(content, title = "", comment = "", isUrl=False):
Logger.LogParameters(funcname = sys._getframe().f_code.co_name, func_vars = vars(), module = "PhotoManager")
try:
imageName = RandomID.gen()
if not isUrl:
fileObj = StringIO(content.read())
else:
#url = "http://www.didao8.com:8080/static/44/thumb/nvLcHMu1JS3mepZPkQBqriG4ANthz2s5.jpg"
fileObj = StringIO(urllib2.urlopen(content).read())
img = Image.open(fileObj)
width, height = img.size
fileName = "%s%s%s" % (imageName, ".", img.format)
filePath = (PHOTO_DATA_ROOT + "%s") % fileName
img.save(filePath)
photo = Photo(title=title, comment=comment, datetime = time.time(),
imageName=fileName, width = width, height = height)
photo.save()
return Err.genOK(photo.id)
except Exception, ex:
print ex
Logger.SaveLogDebug(ex, level=Logger.LEVEL_ERROR, module = "PhotoManager")
return Err.genErr(Err.ERR_ADD_PHOTO_FAIL)
@staticmethod
def getPhotos(page=1, prePage=5):
Logger.LogParameters(funcname = sys._getframe().f_code.co_name, func_vars = vars(), module = "PhotoManager")
try:
photos = []
intPage = int(page)
intPrePage = int(prePage)
photoItems = Photo.objects.all()[(intPage-1)*intPrePage:intPage*intPrePage]
attrList = ["id", "title", "comment", "datetime", "width", "height", "imageName"]
for item in photoItems:
photo = {key:getattr(item, key) for key in attrList}
photo["imageUrl"] = getPhotoUrl(item.imageName)
photos.append(photo)
return Err.genOK(photos)
except Exception, ex:
print ex
Logger.SaveLogDebug(ex, level=Logger.LEVEL_ERROR, module = "PhotoManager")
return Err.genErr(Err.ERR_GET_PHOTO_LIST_FAIL)
@staticmethod
def getPhoto(imageName, pointX=0, pointY=0, needWidth=0):
'''
Return a StringIO obj, use StringIO.getvalue() to get the content
'''
Logger.LogParameters(funcname = sys._getframe().f_code.co_name, func_vars = vars(), module = "PhotoManager")
try:
imagePath = getPhotoPath(imageName)
needWidth, pointX, pointY = int(needWidth), int(pointX), int(pointY)
im = Image.open(imagePath)
width, height = im.size
imgFormat = im.format
scale = float(height)/width
box = (0, 0, width, height)
if needWidth > 0 and pointX < width and pointY < height:
if needWidth + pointX > width:
needWidth = width - pointX
needHeight = needWidth * scale
if needHeight + pointY > height:
needHeight = height - pointY
needWidth = needHeight / scale
if needHeight < 1:
needHeight = 1
if needWidth < 1:
needWidth = 1
print needHeight, needWidth
#print needWidth, needHeight, scale
box = (pointX, pointY, int(pointX + needWidth), int(pointY + needHeight))
region = im.crop(box)
container = StringIO()
region.save(container, imgFormat)
return Err.genOK([container, imgFormat])
except Exception, ex:
print ex
Logger.SaveLogDebug(ex, level=Logger.LEVEL_ERROR, module = "PhotoManager")
return Err.genErr(Err.ERR_GET_PHOTO_DATA_FAIL)
| StarcoderdataPython |
3249721 | import os
from datetime import datetime
def log_parameters(filename, parameters, task_name):
filename = os.path.join(parameters["root_data"], filename)
with open(filename, "w") as fwlog:
fwlog.write(f"{task_name.upper()} LOG FILE\n")
fwlog.write(f"Date and time : {datetime.now()}\n")
fwlog.write(
f"#$#$#$#$#$#$#The arguments used for {task_name.lower()} are below: \n"
)
for name, value in parameters.items():
fwlog.write(f"{name} = {value}\n")
fwlog.write("************____________________________________**************\n")
| StarcoderdataPython |
3280050 |
def get_envlist(env_type):
""" get list of env names wrt the type of env """
try:
l = all_env_list[env_type]
except:
print('Env Type {:s} Not Found!'.format(env_type))
return l
all_env_list={
## Gym
# Atari
'atari':[ 'AirRaid-v0',
'AirRaid-v4',
'AirRaidDeterministic-v0',
'AirRaidDeterministic-v4',
'AirRaidNoFrameskip-v0',
'AirRaidNoFrameskip-v4',
'AirRaid-ram-v0',
'AirRaid-ram-v4',
'AirRaid-ramDeterministic-v0',
'AirRaid-ramDeterministic-v4',
'AirRaid-ramNoFrameskip-v0',
'AirRaid-ramNoFrameskip-v4',
'Alien-v0',
'Alien-v4',
'AlienDeterministic-v0',
'AlienDeterministic-v4',
'AlienNoFrameskip-v0',
'AlienNoFrameskip-v4',
'Alien-ram-v0',
'Alien-ram-v4',
'Alien-ramDeterministic-v0',
'Alien-ramDeterministic-v4',
'Alien-ramNoFrameskip-v0',
'Alien-ramNoFrameskip-v4',
'Amidar-v0',
'Amidar-v4',
'AmidarDeterministic-v0',
'AmidarDeterministic-v4',
'AmidarNoFrameskip-v0',
'AmidarNoFrameskip-v4',
'Amidar-ram-v0',
'Amidar-ram-v4',
'Amidar-ramDeterministic-v0',
'Amidar-ramDeterministic-v4',
'Amidar-ramNoFrameskip-v0',
'Amidar-ramNoFrameskip-v4',
'Assault-v0',
'Assault-v4',
'AssaultDeterministic-v0',
'AssaultDeterministic-v4',
'AssaultNoFrameskip-v0',
'AssaultNoFrameskip-v4',
'Assault-ram-v0',
'Assault-ram-v4',
'Assault-ramDeterministic-v0',
'Assault-ramDeterministic-v4',
'Assault-ramNoFrameskip-v0',
'Assault-ramNoFrameskip-v4',
'Asterix-v0',
'Asterix-v4',
'AsterixDeterministic-v0',
'AsterixDeterministic-v4',
'AsterixNoFrameskip-v0',
'AsterixNoFrameskip-v4',
'Asterix-ram-v0',
'Asterix-ram-v4',
'Asterix-ramDeterministic-v0',
'Asterix-ramDeterministic-v4',
'Asterix-ramNoFrameskip-v0',
'Asterix-ramNoFrameskip-v4',
'Asteroids-v0',
'Asteroids-v4',
'AsteroidsDeterministic-v0',
'AsteroidsDeterministic-v4',
'AsteroidsNoFrameskip-v0',
'AsteroidsNoFrameskip-v4',
'Asteroids-ram-v0',
'Asteroids-ram-v4',
'Asteroids-ramDeterministic-v0',
'Asteroids-ramDeterministic-v4',
'Asteroids-ramNoFrameskip-v0',
'Asteroids-ramNoFrameskip-v4',
'Atlantis-v0',
'Atlantis-v4',
'AtlantisDeterministic-v0',
'AtlantisDeterministic-v4',
'AtlantisNoFrameskip-v0',
'AtlantisNoFrameskip-v4',
'Atlantis-ram-v0',
'Atlantis-ram-v4',
'Atlantis-ramDeterministic-v0',
'Atlantis-ramDeterministic-v4',
'Atlantis-ramNoFrameskip-v0',
'Atlantis-ramNoFrameskip-v4',
'BankHeist-v0',
'BankHeist-v4',
'BankHeistDeterministic-v0',
'BankHeistDeterministic-v4',
'BankHeistNoFrameskip-v0',
'BankHeistNoFrameskip-v4',
'BankHeist-ram-v0',
'BankHeist-ram-v4',
'BankHeist-ramDeterministic-v0',
'BankHeist-ramDeterministic-v4',
'BankHeist-ramNoFrameskip-v0',
'BankHeist-ramNoFrameskip-v4',
'BattleZone-v0',
'BattleZone-v4',
'BattleZoneDeterministic-v0',
'BattleZoneDeterministic-v4',
'BattleZoneNoFrameskip-v0',
'BattleZoneNoFrameskip-v4',
'BattleZone-ram-v0',
'BattleZone-ram-v4',
'BattleZone-ramDeterministic-v0',
'BattleZone-ramDeterministic-v4',
'BattleZone-ramNoFrameskip-v0',
'BattleZone-ramNoFrameskip-v4',
'BeamRider-v0',
'BeamRider-v4',
'BeamRiderDeterministic-v0',
'BeamRiderDeterministic-v4',
'BeamRiderNoFrameskip-v0',
'BeamRiderNoFrameskip-v4',
'BeamRider-ram-v0',
'BeamRider-ram-v4',
'BeamRider-ramDeterministic-v0',
'BeamRider-ramDeterministic-v4',
'BeamRider-ramNoFrameskip-v0',
'BeamRider-ramNoFrameskip-v4',
'Berzerk-v0',
'Berzerk-v4',
'BerzerkDeterministic-v0',
'BerzerkDeterministic-v4',
'BerzerkNoFrameskip-v0',
'BerzerkNoFrameskip-v4',
'Berzerk-ram-v0',
'Berzerk-ram-v4',
'Berzerk-ramDeterministic-v0',
'Berzerk-ramDeterministic-v4',
'Berzerk-ramNoFrameskip-v0',
'Berzerk-ramNoFrameskip-v4',
'Bowling-v0',
'Bowling-v4',
'BowlingDeterministic-v0',
'BowlingDeterministic-v4',
'BowlingNoFrameskip-v0',
'BowlingNoFrameskip-v4',
'Bowling-ram-v0',
'Bowling-ram-v4',
'Bowling-ramDeterministic-v0',
'Bowling-ramDeterministic-v4',
'Bowling-ramNoFrameskip-v0',
'Bowling-ramNoFrameskip-v4',
'Boxing-v0',
'Boxing-v4',
'BoxingDeterministic-v0',
'BoxingDeterministic-v4',
'BoxingNoFrameskip-v0',
'BoxingNoFrameskip-v4',
'Boxing-ram-v0',
'Boxing-ram-v4',
'Boxing-ramDeterministic-v0',
'Boxing-ramDeterministic-v4',
'Boxing-ramNoFrameskip-v0',
'Boxing-ramNoFrameskip-v4',
'Breakout-v0',
'Breakout-v4',
'BreakoutDeterministic-v0',
'BreakoutDeterministic-v4',
'BreakoutNoFrameskip-v0',
'BreakoutNoFrameskip-v4',
'Breakout-ram-v0',
'Breakout-ram-v4',
'Breakout-ramDeterministic-v0',
'Breakout-ramDeterministic-v4',
'Breakout-ramNoFrameskip-v0',
'Breakout-ramNoFrameskip-v4',
'Carnival-v0',
'Carnival-v4',
'CarnivalDeterministic-v0',
'CarnivalDeterministic-v4',
'CarnivalNoFrameskip-v0',
'CarnivalNoFrameskip-v4',
'Carnival-ram-v0',
'Carnival-ram-v4',
'Carnival-ramDeterministic-v0',
'Carnival-ramDeterministic-v4',
'Carnival-ramNoFrameskip-v0',
'Carnival-ramNoFrameskip-v4',
'Centipede-v0',
'Centipede-v4',
'CentipedeDeterministic-v0',
'CentipedeDeterministic-v4',
'CentipedeNoFrameskip-v0',
'CentipedeNoFrameskip-v4',
'Centipede-ram-v0',
'Centipede-ram-v4',
'Centipede-ramDeterministic-v0',
'Centipede-ramDeterministic-v4',
'Centipede-ramNoFrameskip-v0',
'Centipede-ramNoFrameskip-v4',
'ChopperCommand-v0',
'ChopperCommand-v4',
'ChopperCommandDeterministic-v0',
'ChopperCommandDeterministic-v4',
'ChopperCommandNoFrameskip-v0',
'ChopperCommandNoFrameskip-v4',
'ChopperCommand-ram-v0',
'ChopperCommand-ram-v4',
'ChopperCommand-ramDeterministic-v0',
'ChopperCommand-ramDeterministic-v4',
'ChopperCommand-ramNoFrameskip-v0',
'ChopperCommand-ramNoFrameskip-v4',
'CrazyClimber-v0',
'CrazyClimber-v4',
'CrazyClimberDeterministic-v0',
'CrazyClimberDeterministic-v4',
'CrazyClimberNoFrameskip-v0',
'CrazyClimberNoFrameskip-v4',
'CrazyClimber-ram-v0',
'CrazyClimber-ram-v4',
'CrazyClimber-ramDeterministic-v0',
'CrazyClimber-ramDeterministic-v4',
'CrazyClimber-ramNoFrameskip-v0',
'CrazyClimber-ramNoFrameskip-v4',
'DemonAttack-v0',
'DemonAttack-v4',
'DemonAttackDeterministic-v0',
'DemonAttackDeterministic-v4',
'DemonAttackNoFrameskip-v0',
'DemonAttackNoFrameskip-v4',
'DemonAttack-ram-v0',
'DemonAttack-ram-v4',
'DemonAttack-ramDeterministic-v0',
'DemonAttack-ramDeterministic-v4',
'DemonAttack-ramNoFrameskip-v0',
'DemonAttack-ramNoFrameskip-v4',
'DoubleDunk-v0',
'DoubleDunk-v4',
'DoubleDunkDeterministic-v0',
'DoubleDunkDeterministic-v4',
'DoubleDunkNoFrameskip-v0',
'DoubleDunkNoFrameskip-v4',
'DoubleDunk-ram-v0',
'DoubleDunk-ram-v4',
'DoubleDunk-ramDeterministic-v0',
'DoubleDunk-ramDeterministic-v4',
'DoubleDunk-ramNoFrameskip-v0',
'DoubleDunk-ramNoFrameskip-v4',
'ElevatorAction-v0',
'ElevatorAction-v4',
'ElevatorActionDeterministic-v0',
'ElevatorActionDeterministic-v4',
'ElevatorActionNoFrameskip-v0',
'ElevatorActionNoFrameskip-v4',
'ElevatorAction-ram-v0',
'ElevatorAction-ram-v4',
'ElevatorAction-ramDeterministic-v0',
'ElevatorAction-ramDeterministic-v4',
'ElevatorAction-ramNoFrameskip-v0',
'ElevatorAction-ramNoFrameskip-v4',
'Enduro-v0',
'Enduro-v4',
'EnduroDeterministic-v0',
'EnduroDeterministic-v4',
'EnduroNoFrameskip-v0',
'EnduroNoFrameskip-v4',
'Enduro-ram-v0',
'Enduro-ram-v4',
'Enduro-ramDeterministic-v0',
'Enduro-ramDeterministic-v4',
'Enduro-ramNoFrameskip-v0',
'Enduro-ramNoFrameskip-v4',
'FishingDerby-v0',
'FishingDerby-v4',
'FishingDerbyDeterministic-v0',
'FishingDerbyDeterministic-v4',
'FishingDerbyNoFrameskip-v0',
'FishingDerbyNoFrameskip-v4',
'FishingDerby-ram-v0',
'FishingDerby-ram-v4',
'FishingDerby-ramDeterministic-v0',
'FishingDerby-ramDeterministic-v4',
'FishingDerby-ramNoFrameskip-v0',
'FishingDerby-ramNoFrameskip-v4',
'Freeway-v0',
'Freeway-v4',
'FreewayDeterministic-v0',
'FreewayDeterministic-v4',
'FreewayNoFrameskip-v0',
'FreewayNoFrameskip-v4',
'Freeway-ram-v0',
'Freeway-ram-v4',
'Freeway-ramDeterministic-v0',
'Freeway-ramDeterministic-v4',
'Freeway-ramNoFrameskip-v0',
'Freeway-ramNoFrameskip-v4',
'Frostbite-v0',
'Frostbite-v4',
'FrostbiteDeterministic-v0',
'FrostbiteDeterministic-v4',
'FrostbiteNoFrameskip-v0',
'FrostbiteNoFrameskip-v4',
'Frostbite-ram-v0',
'Frostbite-ram-v4',
'Frostbite-ramDeterministic-v0',
'Frostbite-ramDeterministic-v4',
'Frostbite-ramNoFrameskip-v0',
'Frostbite-ramNoFrameskip-v4',
'Gopher-v0',
'Gopher-v4',
'GopherDeterministic-v0',
'GopherDeterministic-v4',
'GopherNoFrameskip-v0',
'GopherNoFrameskip-v4',
'Gopher-ram-v0',
'Gopher-ram-v4',
'Gopher-ramDeterministic-v0',
'Gopher-ramDeterministic-v4',
'Gopher-ramNoFrameskip-v0',
'Gopher-ramNoFrameskip-v4',
'Gravitar-v0',
'Gravitar-v4',
'GravitarDeterministic-v0',
'GravitarDeterministic-v4',
'GravitarNoFrameskip-v0',
'GravitarNoFrameskip-v4',
'Gravitar-ram-v0',
'Gravitar-ram-v4',
'Gravitar-ramDeterministic-v0',
'Gravitar-ramDeterministic-v4',
'Gravitar-ramNoFrameskip-v0',
'Gravitar-ramNoFrameskip-v4',
'Hero-v0',
'Hero-v4',
'HeroDeterministic-v0',
'HeroDeterministic-v4',
'HeroNoFrameskip-v0',
'HeroNoFrameskip-v4',
'Hero-ram-v0',
'Hero-ram-v4',
'Hero-ramDeterministic-v0',
'Hero-ramDeterministic-v4',
'Hero-ramNoFrameskip-v0',
'Hero-ramNoFrameskip-v4',
'IceHockey-v0',
'IceHockey-v4',
'IceHockeyDeterministic-v0',
'IceHockeyDeterministic-v4',
'IceHockeyNoFrameskip-v0',
'IceHockeyNoFrameskip-v4',
'IceHockey-ram-v0',
'IceHockey-ram-v4',
'IceHockey-ramDeterministic-v0',
'IceHockey-ramDeterministic-v4',
'IceHockey-ramNoFrameskip-v0',
'IceHockey-ramNoFrameskip-v4',
'Jamesbond-v0',
'Jamesbond-v4',
'JamesbondDeterministic-v0',
'JamesbondDeterministic-v4',
'JamesbondNoFrameskip-v0',
'JamesbondNoFrameskip-v4',
'Jamesbond-ram-v0',
'Jamesbond-ram-v4',
'Jamesbond-ramDeterministic-v0',
'Jamesbond-ramDeterministic-v4',
'Jamesbond-ramNoFrameskip-v0',
'Jamesbond-ramNoFrameskip-v4',
'JourneyEscape-v0',
'JourneyEscape-v4',
'JourneyEscapeDeterministic-v0',
'JourneyEscapeDeterministic-v4',
'JourneyEscapeNoFrameskip-v0',
'JourneyEscapeNoFrameskip-v4',
'JourneyEscape-ram-v0',
'JourneyEscape-ram-v4',
'JourneyEscape-ramDeterministic-v0',
'JourneyEscape-ramDeterministic-v4',
'JourneyEscape-ramNoFrameskip-v0',
'JourneyEscape-ramNoFrameskip-v4',
'Kangaroo-v0',
'Kangaroo-v4',
'KangarooDeterministic-v0',
'KangarooDeterministic-v4',
'KangarooNoFrameskip-v0',
'KangarooNoFrameskip-v4',
'Kangaroo-ram-v0',
'Kangaroo-ram-v4',
'Kangaroo-ramDeterministic-v0',
'Kangaroo-ramDeterministic-v4',
'Kangaroo-ramNoFrameskip-v0',
'Kangaroo-ramNoFrameskip-v4',
'Krull-v0',
'Krull-v4',
'KrullDeterministic-v0',
'KrullDeterministic-v4',
'KrullNoFrameskip-v0',
'KrullNoFrameskip-v4',
'Krull-ram-v0',
'Krull-ram-v4',
'Krull-ramDeterministic-v0',
'Krull-ramDeterministic-v4',
'Krull-ramNoFrameskip-v0',
'Krull-ramNoFrameskip-v4',
'KungFuMaster-v0',
'KungFuMaster-v4',
'KungFuMasterDeterministic-v0',
'KungFuMasterDeterministic-v4',
'KungFuMasterNoFrameskip-v0',
'KungFuMasterNoFrameskip-v4',
'KungFuMaster-ram-v0',
'KungFuMaster-ram-v4',
'KungFuMaster-ramDeterministic-v0',
'KungFuMaster-ramDeterministic-v4',
'KungFuMaster-ramNoFrameskip-v0',
'KungFuMaster-ramNoFrameskip-v4',
'MontezumaRevenge-v0',
'MontezumaRevenge-v4',
'MontezumaRevengeDeterministic-v0',
'MontezumaRevengeDeterministic-v4',
'MontezumaRevengeNoFrameskip-v0',
'MontezumaRevengeNoFrameskip-v4',
'MontezumaRevenge-ram-v0',
'MontezumaRevenge-ram-v4',
'MontezumaRevenge-ramDeterministic-v0',
'MontezumaRevenge-ramDeterministic-v4',
'MontezumaRevenge-ramNoFrameskip-v0',
'MontezumaRevenge-ramNoFrameskip-v4',
'MsPacman-v0',
'MsPacman-v4',
'MsPacmanDeterministic-v0',
'MsPacmanDeterministic-v4',
'MsPacmanNoFrameskip-v0',
'MsPacmanNoFrameskip-v4',
'MsPacman-ram-v0',
'MsPacman-ram-v4',
'MsPacman-ramDeterministic-v0',
'MsPacman-ramDeterministic-v4',
'MsPacman-ramNoFrameskip-v0',
'MsPacman-ramNoFrameskip-v4',
'NameThisGame-v0',
'NameThisGame-v4',
'NameThisGameDeterministic-v0',
'NameThisGameDeterministic-v4',
'NameThisGameNoFrameskip-v0',
'NameThisGameNoFrameskip-v4',
'NameThisGame-ram-v0',
'NameThisGame-ram-v4',
'NameThisGame-ramDeterministic-v0',
'NameThisGame-ramDeterministic-v4',
'NameThisGame-ramNoFrameskip-v0',
'NameThisGame-ramNoFrameskip-v4',
'Phoenix-v0',
'Phoenix-v4',
'PhoenixDeterministic-v0',
'PhoenixDeterministic-v4',
'PhoenixNoFrameskip-v0',
'PhoenixNoFrameskip-v4',
'Phoenix-ram-v0',
'Phoenix-ram-v4',
'Phoenix-ramDeterministic-v0',
'Phoenix-ramDeterministic-v4',
'Phoenix-ramNoFrameskip-v0',
'Phoenix-ramNoFrameskip-v4',
'Pitfall-v0',
'Pitfall-v4',
'PitfallDeterministic-v0',
'PitfallDeterministic-v4',
'PitfallNoFrameskip-v0',
'PitfallNoFrameskip-v4',
'Pitfall-ram-v0',
'Pitfall-ram-v4',
'Pitfall-ramDeterministic-v0',
'Pitfall-ramDeterministic-v4',
'Pitfall-ramNoFrameskip-v0',
'Pitfall-ramNoFrameskip-v4',
'Pong-v0',
'Pong-v4',
'PongDeterministic-v0',
'PongDeterministic-v4',
'PongNoFrameskip-v0',
'PongNoFrameskip-v4',
'Pong-ram-v0',
'Pong-ram-v4',
'Pong-ramDeterministic-v0',
'Pong-ramDeterministic-v4',
'Pong-ramNoFrameskip-v0',
'Pong-ramNoFrameskip-v4',
'Pooyan-v0',
'Pooyan-v4',
'PooyanDeterministic-v0',
'PooyanDeterministic-v4',
'PooyanNoFrameskip-v0',
'PooyanNoFrameskip-v4',
'Pooyan-ram-v0',
'Pooyan-ram-v4',
'Pooyan-ramDeterministic-v0',
'Pooyan-ramDeterministic-v4',
'Pooyan-ramNoFrameskip-v0',
'Pooyan-ramNoFrameskip-v4',
'PrivateEye-v0',
'PrivateEye-v4',
'PrivateEyeDeterministic-v0',
'PrivateEyeDeterministic-v4',
'PrivateEyeNoFrameskip-v0',
'PrivateEyeNoFrameskip-v4',
'PrivateEye-ram-v0',
'PrivateEye-ram-v4',
'PrivateEye-ramDeterministic-v0',
'PrivateEye-ramDeterministic-v4',
'PrivateEye-ramNoFrameskip-v0',
'PrivateEye-ramNoFrameskip-v4',
'Qbert-v0',
'Qbert-v4',
'QbertDeterministic-v0',
'QbertDeterministic-v4',
'QbertNoFrameskip-v0',
'QbertNoFrameskip-v4',
'Qbert-ram-v0',
'Qbert-ram-v4',
'Qbert-ramDeterministic-v0',
'Qbert-ramDeterministic-v4',
'Qbert-ramNoFrameskip-v0',
'Qbert-ramNoFrameskip-v4',
'Riverraid-v0',
'Riverraid-v4',
'RiverraidDeterministic-v0',
'RiverraidDeterministic-v4',
'RiverraidNoFrameskip-v0',
'RiverraidNoFrameskip-v4',
'Riverraid-ram-v0',
'Riverraid-ram-v4',
'Riverraid-ramDeterministic-v0',
'Riverraid-ramDeterministic-v4',
'Riverraid-ramNoFrameskip-v0',
'Riverraid-ramNoFrameskip-v4',
'RoadRunner-v0',
'RoadRunner-v4',
'RoadRunnerDeterministic-v0',
'RoadRunnerDeterministic-v4',
'RoadRunnerNoFrameskip-v0',
'RoadRunnerNoFrameskip-v4',
'RoadRunner-ram-v0',
'RoadRunner-ram-v4',
'RoadRunner-ramDeterministic-v0',
'RoadRunner-ramDeterministic-v4',
'RoadRunner-ramNoFrameskip-v0',
'RoadRunner-ramNoFrameskip-v4',
'Robotank-v0',
'Robotank-v4',
'RobotankDeterministic-v0',
'RobotankDeterministic-v4',
'RobotankNoFrameskip-v0',
'RobotankNoFrameskip-v4',
'Robotank-ram-v0',
'Robotank-ram-v4',
'Robotank-ramDeterministic-v0',
'Robotank-ramDeterministic-v4',
'Robotank-ramNoFrameskip-v0',
'Robotank-ramNoFrameskip-v4',
'Seaquest-v0',
'Seaquest-v4',
'SeaquestDeterministic-v0',
'SeaquestDeterministic-v4',
'SeaquestNoFrameskip-v0',
'SeaquestNoFrameskip-v4',
'Seaquest-ram-v0',
'Seaquest-ram-v4',
'Seaquest-ramDeterministic-v0',
'Seaquest-ramDeterministic-v4',
'Seaquest-ramNoFrameskip-v0',
'Seaquest-ramNoFrameskip-v4',
'Skiing-v0',
'Skiing-v4',
'SkiingDeterministic-v0',
'SkiingDeterministic-v4',
'SkiingNoFrameskip-v0',
'SkiingNoFrameskip-v4',
'Skiing-ram-v0',
'Skiing-ram-v4',
'Skiing-ramDeterministic-v0',
'Skiing-ramDeterministic-v4',
'Skiing-ramNoFrameskip-v0',
'Skiing-ramNoFrameskip-v4',
'Solaris-v0',
'Solaris-v4',
'SolarisDeterministic-v0',
'SolarisDeterministic-v4',
'SolarisNoFrameskip-v0',
'SolarisNoFrameskip-v4',
'Solaris-ram-v0',
'Solaris-ram-v4',
'Solaris-ramDeterministic-v0',
'Solaris-ramDeterministic-v4',
'Solaris-ramNoFrameskip-v0',
'Solaris-ramNoFrameskip-v4',
'SpaceInvaders-v0',
'SpaceInvaders-v4',
'SpaceInvadersDeterministic-v0',
'SpaceInvadersDeterministic-v4',
'SpaceInvadersNoFrameskip-v0',
'SpaceInvadersNoFrameskip-v4',
'SpaceInvaders-ram-v0',
'SpaceInvaders-ram-v4',
'SpaceInvaders-ramDeterministic-v0',
'SpaceInvaders-ramDeterministic-v4',
'SpaceInvaders-ramNoFrameskip-v0',
'SpaceInvaders-ramNoFrameskip-v4',
'StarGunner-v0',
'StarGunner-v4',
'StarGunnerDeterministic-v0',
'StarGunnerDeterministic-v4',
'StarGunnerNoFrameskip-v0',
'StarGunnerNoFrameskip-v4',
'StarGunner-ram-v0',
'StarGunner-ram-v4',
'StarGunner-ramDeterministic-v0',
'StarGunner-ramDeterministic-v4',
'StarGunner-ramNoFrameskip-v0',
'StarGunner-ramNoFrameskip-v4',
'Tennis-v0',
'Tennis-v4',
'TennisDeterministic-v0',
'TennisDeterministic-v4',
'TennisNoFrameskip-v0',
'TennisNoFrameskip-v4',
'Tennis-ram-v0',
'Tennis-ram-v4',
'Tennis-ramDeterministic-v0',
'Tennis-ramDeterministic-v4',
'Tennis-ramNoFrameskip-v0',
'Tennis-ramNoFrameskip-v4',
'TimePilot-v0',
'TimePilot-v4',
'TimePilotDeterministic-v0',
'TimePilotDeterministic-v4',
'TimePilotNoFrameskip-v0',
'TimePilotNoFrameskip-v4',
'TimePilot-ram-v0',
'TimePilot-ram-v4',
'TimePilot-ramDeterministic-v0',
'TimePilot-ramDeterministic-v4',
'TimePilot-ramNoFrameskip-v0',
'TimePilot-ramNoFrameskip-v4',
'Tutankham-v0',
'Tutankham-v4',
'TutankhamDeterministic-v0',
'TutankhamDeterministic-v4',
'TutankhamNoFrameskip-v0',
'TutankhamNoFrameskip-v4',
'Tutankham-ram-v0',
'Tutankham-ram-v4',
'Tutankham-ramDeterministic-v0',
'Tutankham-ramDeterministic-v4',
'Tutankham-ramNoFrameskip-v0',
'Tutankham-ramNoFrameskip-v4',
'UpNDown-v0',
'UpNDown-v4',
'UpNDownDeterministic-v0',
'UpNDownDeterministic-v4',
'UpNDownNoFrameskip-v0',
'UpNDownNoFrameskip-v4',
'UpNDown-ram-v0',
'UpNDown-ram-v4',
'UpNDown-ramDeterministic-v0',
'UpNDown-ramDeterministic-v4',
'UpNDown-ramNoFrameskip-v0',
'UpNDown-ramNoFrameskip-v4',
'Venture-v0',
'Venture-v4',
'VentureDeterministic-v0',
'VentureDeterministic-v4',
'VentureNoFrameskip-v0',
'VentureNoFrameskip-v4',
'Venture-ram-v0',
'Venture-ram-v4',
'Venture-ramDeterministic-v0',
'Venture-ramDeterministic-v4',
'Venture-ramNoFrameskip-v0',
'Venture-ramNoFrameskip-v4',
'VideoPinball-v0',
'VideoPinball-v4',
'VideoPinballDeterministic-v0',
'VideoPinballDeterministic-v4',
'VideoPinballNoFrameskip-v0',
'VideoPinballNoFrameskip-v4',
'VideoPinball-ram-v0',
'VideoPinball-ram-v4',
'VideoPinball-ramDeterministic-v0',
'VideoPinball-ramDeterministic-v4',
'VideoPinball-ramNoFrameskip-v0',
'VideoPinball-ramNoFrameskip-v4',
'WizardOfWor-v0',
'WizardOfWor-v4',
'WizardOfWorDeterministic-v0',
'WizardOfWorDeterministic-v4',
'WizardOfWorNoFrameskip-v0',
'WizardOfWorNoFrameskip-v4',
'WizardOfWor-ram-v0',
'WizardOfWor-ram-v4',
'WizardOfWor-ramDeterministic-v0',
'WizardOfWor-ramDeterministic-v4',
'WizardOfWor-ramNoFrameskip-v0',
'WizardOfWor-ramNoFrameskip-v4',
'YarsRevenge-v0',
'YarsRevenge-v4',
'YarsRevengeDeterministic-v0',
'YarsRevengeDeterministic-v4',
'YarsRevengeNoFrameskip-v0',
'YarsRevengeNoFrameskip-v4',
'YarsRevenge-ram-v0',
'YarsRevenge-ram-v4',
'YarsRevenge-ramDeterministic-v0',
'YarsRevenge-ramDeterministic-v4',
'YarsRevenge-ramNoFrameskip-v0',
'YarsRevenge-ramNoFrameskip-v4',
'Zaxxon-v0',
'Zaxxon-v4',
'ZaxxonDeterministic-v0',
'ZaxxonDeterministic-v4',
'ZaxxonNoFrameskip-v0',
'ZaxxonNoFrameskip-v4',
'Zaxxon-ram-v0',
'Zaxxon-ram-v4',
'Zaxxon-ramDeterministic-v0',
'Zaxxon-ramDeterministic-v4',
'Zaxxon-ramNoFrameskip-v0',
'Zaxxon-ramNoFrameskip-v4'],
# Classic control
'classic_control':[
'Acrobot-v1',
'CartPole-v1',
'CartPole-v0',
'MountainCar-v0',
'MountainCarContinuous-v0',
'Pendulum-v0'
] ,
# Box2D
'box2d':[
'BipedalWalker-v2',
'BipedalWalkerHardcore-v2',
'CarRacing-v0',
'LunarLander-v2',
'LunarLanderContinuous-v2'
],
# MuJoCo
'mujoco':[
'Ant-v2',
'HalfCheetah-v2',
'Hopper-v2',
'Humanoid-v2',
'HumanoidStandup-v2',
'InvertedDoublePendulum-v2',
'InvertedPendulum-v2',
'Reacher-v2',
'Swimmer-v2',
'Walker2d-v2'
],
# Robotics
'robotics':[
'FetchPickAndPlace-v1',
'FetchPush-v1',
'FetchReach-v1',
'FetchSlide-v1',
'HandManipulateBlock-v0',
'HandManipulateEgg-v0',
'HandManipulatePen-v0',
'HandReach-v0'
],
## Deepmind Control Suite (need check!)
'dm_control':[
'AcrobotSparse-v0',
'BallincupCatch-v0',
'CartpoleSwingup-v0',
'FingerTurn-v0',
'FishSwim-v0',
'CheetahRun-v0',
'HopperHop-v0',
'HumanoidStand-v0',
'HumanoidWalk-v0',
'HumanoidRun-v0',
'ManipulatorBringball-v0',
'PendulumSwingup-v0',
'Pointmass-v0',
'ReacherHard-v0',
'Swimmer-v0',
'WalkerRun-v0'
],
## RLBench
'rlbench':[
'BeatTheBuzz',
'BlockPyramid',
'ChangeChannel',
'ChangeClock',
'CloseBox',
'CloseDoor',
'CloseDrawer',
'CloseFridge',
'CloseGrill',
'CloseJar',
'CloseLaptopLid',
'CloseMicrowave',
'EmptyContainer',
'EmptyDishwasher',
'GetIceFromFridge',
'HangFrameOnHanger',
'HannoiSquare',
'HitBallWithQueue',
'Hockey',
'InsertUsbInComputer',
'LampOff',
'LampOn',
'LightBulbIn',
'LightBulbOut',
'MeatOffGrill',
'MeatOnGrill',
'MoveHanger',
'OpenBox',
'OpenDoor',
'OpenDrawer',
'OpenFridge',
'OpenGrill',
'OpenJar',
'OpenMicrowave',
'OpenOven',
'OpenWindow',
'OpenWineBottle',
'PhoneOnBase',
'PickAndLift',
'PickUpCup',
'PlaceCups',
'PlaceHangerOnRack',
'PlaceShapeInShapeSorter',
'PlayJenga',
'PlugChargerInPowerSupply',
'PourFromCupToCup',
'PressSwitch',
'PushButton',
'PushButtons',
'PutBooksOnBookshelf',
'PutBottleInFridge',
'PutGroceriesInCupboard',
'PutItemInDrawer',
'PutKnifeInKnifeBlock',
'PutKnifeOnChoppingBoard',
'PutMoneyInSafe',
'PutPlateInColoredDishRack',
'PutRubbishInBin',
'PutShoesInBox',
'PutToiletRollOnStand',
'PutTrayInOven',
'PutUmbrellaInUmbrellaStand',
'ReachAndDrag',
'ReachTarget',
'RemoveCups',
'ScoopWithSpatula',
'ScrewNail',
'SetTheTable',
'SetupCheckers',
'SlideBlockToTarget',
'SlideCabinetOpen',
'SlideCabinetOpenAndPlaceCups',
'SolvePuzzle',
'StackBlocks',
'StackCups',
'StackWine',
'StraightenRope',
'SweepToDustpan',
'TakeCupOutFromCabinet',
'TakeFrameOffHanger',
'TakeItemOutOfDrawer',
'TakeLidOffSaucepan',
'TakeMoneyOutSafe',
'TakeOffWeighingScales',
'TakePlateOffColoredDishRack',
'TakeShoesOutOfBox',
'TakeToiletRollOffStand',
'TakeTrayOutOfOven',
'TakeUmbrellaOutOfUmbrellaStand',
'TakeUsbOutOfComputer',
'ToiletSeatDown',
'ToiletSeatUp',
'TurnOvenOn',
'TurnTap',
'TvOff',
'TvOn',
'UnplugCharger',
'WaterPlants',
'WeighingScales',
'WipeDesk'
]
}
| StarcoderdataPython |
1709912 | <reponame>PranjalPansuriya/JavaScriptEnhancements
import sublime, sublime_plugin
import os
from ..libs import NodeJS
from ..libs import util
from ..libs import FlowCLI
class JavascriptEnhancementsGoToDefinitionCommand(sublime_plugin.TextCommand):
def run(self, edit, **args):
view = self.view
if args and "point" in args :
point = args["point"]
else :
point = view.sel()[0].begin()
point = view.word(point).begin()
self.go_to_def(view, point)
def go_to_def(self, view, point):
view = sublime.active_window().active_view()
view.sel().clear()
#sublime.active_window().run_command("goto_definition")
#if view.sel()[0].begin() == point :
# try flow get-def
sublime.set_timeout_async(lambda : self.find_def(view, point))
def find_def(self, view, point) :
view.sel().add(point)
flow_cli = FlowCLI(view)
result = flow_cli.get_def()
if result[0] :
row = result[1]["line"] - 1
col = result[1]["start"] - 1
if row >= 0:
if result[1]["path"] != "-" and os.path.isfile(result[1]["path"]) :
view = sublime.active_window().open_file(result[1]["path"])
util.go_to_centered(view, row, col)
def is_enabled(self, **args):
view = self.view
if args and "point" in args :
point = args["point"]
else :
point = view.sel()[0].begin()
point = view.word(point).begin()
if not util.selection_in_js_scope(view, point):
return False
return True
def is_visible(self, **args):
view = self.view
if args and "point" in args :
point = args["point"]
else :
point = view.sel()[0].begin()
point = view.word(point).begin()
if not util.selection_in_js_scope(view, point, "- string - comment"):
return False
return True | StarcoderdataPython |
1654397 | # -*- coding: utf-8 -*-
"""
Copyright 2017 <NAME>
Created on Sun Apr 23 11:52:59 2017
@author: ekobylkin
This is an example on how to prepare data for autosklearn-zeroconf.
It is using a well known Adult (Salary) dataset from UCI https://archive.ics.uci.edu/ml/datasets/Adult .
"""
import pandas as pd
# wget https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data
# wget https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test
col_names=[
'age',
'workclass',
'fnlwgt',
'education',
'education-num',
'marital-status',
'occupation',
'relationship',
'race',
'sex',
'capital-gain',
'capital-loss',
'hours-per-week',
'native-country',
'category'
]
train = pd.read_csv(filepath_or_buffer='../data/adult.data',sep=',', error_bad_lines=False, index_col=False, names=col_names)
category_mapping={' >50K':1,' <=50K':0}
train['category']= train['category'].map(category_mapping)
#dataframe=train
test = pd.read_csv(filepath_or_buffer='../data/adult.test',sep=',', error_bad_lines=False, index_col=False, names=col_names, skiprows=1)
test['set_name']='test'
category_mapping={' >50K.':1,' <=50K.':0}
test['category']= test['category'].map(category_mapping)
dataframe=train.append(test)
# autosklearn-zeroconf requires cust_id and category (target or "y" variable) columns, the rest is optional
dataframe['cust_id']=dataframe.index
# let's save the test with the cus_id and binarized category for the validation of the prediction afterwards
test_df=dataframe.loc[dataframe['set_name']=='test'].drop(['set_name'], axis=1)
test_df.to_csv('../data/adult.test.withid', index=False, header=True)
# We will use the test.csv data to make a prediction. You can compare the predicted values with the ground truth yourself.
dataframe.loc[dataframe['set_name']=='test','category']=None
dataframe=dataframe.drop(['set_name'], axis=1)
print(dataframe)
store = pd.HDFStore('../data/Adult.h5') # this is the file cache for the data
store['data'] = dataframe
store.close()
#Now run 'python zeroconf.py Adult.h5' (python >=3.5)
| StarcoderdataPython |
59695 | <reponame>jmenzelupb/MSMP-xmas
# MSMP christmas challenge
# <NAME>, 20.12.2017
import numpy as np
import matplotlib.pyplot as plt
import pylab
# load Data
da = np.load('Daten.npz')
temps = np.array([5, 7.5, 10, 12.5, 15, 17.5, 20, 22.5, 25, 27.5, 30, 32.5, 35, 37.5, 40, 42.5, 45, 47.5, 50, 52.5, 55, 57.5, 60, 62.5, 65, 67.5, 70, 72.5, 75, 77.5, 80, 82.5, 85])
# plot
fig1, ax = plt.subplots()
fig1.subplots_adjust(left=0, right=1, top=1, bottom=0)
# stars
x = da['freq_all'].item()[5][2100:5500]
y_star = da['imp_all'].item()[5][2100:5500]+2000*abs(np.sin(0.05*x)+np.sin(0.05*2*x+2.5)+np.sin(0.05*2*x+5.8634))
ax.plot(x[::40], y_star[::40], linestyle='none', marker=(5, 1, 90), color=(1, 1, 0), markersize=15)
ax.plot(x[20::40], y_star[20::40], linestyle='none', marker='*', color=(0.95, 0.88, 0), markersize=15)
# snow
y_snow = da['imp_all'].item()[5][2100:5500]+2000*abs(np.sin(0.05*x)+np.sin(0.1*2*x+2.5)+np.sin(0.2*2*x+5.8634))
ax.plot(x[::2], y_snow[::2], linestyle='none', marker='.', color=(0.75, 1, 1))
ax.plot(x[1::2], y_snow[1::2], linestyle='none', marker='.', color=(1, 1, 1))
# mountain
for ind, t in enumerate(temps):
if ind == 0:
ax.semilogy(da['freq_all'].item()[t][2100:5500], da['imp_all'].item()[t][2100:5500], linewidth=5, color=(1, 1, 1))
elif ind < 8:
ax.semilogy(da['freq_all'].item()[t][2100:5500], da['imp_all'].item()[t][2100:5500], linewidth=1.5, color=(0.1, 1, 1))
elif ind < 16:
ax.semilogy(da['freq_all'].item()[t][2100:5500], da['imp_all'].item()[t][2100:5500], linewidth=1.5, color=(0.3, 1, 1))
elif ind < 24:
ax.semilogy(da['freq_all'].item()[t][2100:5500], da['imp_all'].item()[t][2100:5500], linewidth=1.5, color=(0.5, 1, 1))
else:
ax.semilogy(da['freq_all'].item()[t][2100:5500], da['imp_all'].item()[t][2100:5500], linewidth=1.5, color=(0.7, 1, 1))
ax.axis([da['freq_all'].item()[t][2100], da['freq_all'].item()[t][5500], 4, 2000])
ax.axis('off')
ax.semilogy(da['freq_all'].item()[t][2670:5500]-(da['freq_all'].item()[t][2600]-da['freq_all'].item()[t][2100]), da['imp_all'].item()[t][2670:5500]-15, linewidth=1.5, color=(0.9, 1, 1))
fig1.set_facecolor((0, 0, 0.1))
pylab.fill_between(da['freq_all'].item()[5][2100:5500], 4, da['imp_all'].item()[5][2100:5500], color=(0.8, 1, 1))
# text
plt.xkcd()
ax.text(2.2e6, 5, 'Frohe\nWeihnachten!', fontsize=80, color='w')
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
plt.show()
| StarcoderdataPython |
3228113 | <reponame>vespa-mrs/vespa<gh_stars>0
# Python modules
# 3rd party modules
import numpy as np
# Our modules
def minf_parabolic_info(xa, xb, xc, func, info, maxit=100,
tol=np.sqrt(1.e-7),
pn=0,
dirn=1):
'''
The Python version of this code was adapted from minf_parabolic.pro:
http://idlastro.gsfc.nasa.gov/ftp/pro/math/minf_parabolic.pro
The IDL version of this code is public domain:
http://idlastro.gsfc.nasa.gov/idlfaq.html#A14
This version is governed by the license found in the LICENSE file.
+-----------------------------------------------------------------------------
NAME:
MINF_PARABOLIC_INFO
Same as MinF_Parabolic, but passes a structure to the optimization
function, to allow additional info to be passed in.
PURPOSE:
Find a local minimum of a 1-D function up to specified tolerance.
This routine assumes that the function has a minimum nearby.
(recommend first calling minF_bracket, xa,xb,xc, to bracket minimum).
Routine can also be applied to a scalar function of many variables,
for such case the local minimum in a specified direction is found,
This routine is called by minF_conj_grad, to locate minimum in the
direction of the conjugate gradient of function of many variables.
CALLING EXAMPLES:
minf_parabolic_info, xa,xb,xc, xmin, fmin, FUNC="name", INFO=info ;for 1-D func.
or:
minf_parabolic_info, xa,xb,xc, xmin, fmin, FUNC="name", INFO=info $
POINT=[0,1,1], $
DIRECTION=[2,1,1] ;for 3-D func.
INPUTS:
xa,xb,xc = scalars, 3 points which bracket location of minimum,
that is, f(xb) < f(xa) and f(xb) < f(xc), so minimum exists.
When working with function of N variables
(xa,xb,xc) are then relative distances from POINT_NDIM,
in the direction specified by keyword DIRECTION,
with scale factor given by magnitude of DIRECTION.
KEYWORDS:
FUNC = function
Calling mechanism should be: F = func( px, INFO=info )
where:
px = scalar or vector of independent variables, input.
F = scalar value of function at px.
INFO = structure
INFO = structure containing additional info to be used in FUNC function
POINT_NDIM = when working with function of N variables,
use this keyword to specify the starting point in N-dim space.
Default = 0, which assumes function is 1-D.
DIRECTION = when working with function of N variables,
use this keyword to specify the direction in N-dim space
along which to bracket the local minimum, (default=1 for 1-D).
(xa, xb, xc, x_min are then relative distances from POINT_NDIM)
MAX_ITER = maximum allowed number iterations, default=100.
TOLERANCE = desired accuracy of minimum location, default=sqrt(1.e-7).
OUTPUTS:
xmin = estimated location of minimum.
When working with function of N variables,
xmin is the relative distance from POINT_NDIM,
in the direction specified by keyword DIRECTION,
with scale factor given by magnitude of DIRECTION,
so that min. Loc. Pmin = Point_Ndim + xmin * Direction.
iterations = the number of iterations performed. When this value is
> max_iter, the function was unable to find a satisfactory xmin.
PROCEDURE:
Brent's method to minimize a function by using parabolic interpolation,
from Numerical Recipes (by Press, et al.), sec.10.2 (p.285).
MODIFICATION HISTORY:
Written, <NAME> NASA/GSFC 1992.
'''
# WARNING: This function does not have functional equivalence to the IDL
# version since IDL uses floating point precision and Python uses double.
zeps = 1.e-7 # machine epsilon, smallest addition.
goldc = 1 - (np.sqrt(5)-1)/2 # complement of golden mean.
xLo = np.where(xa < xc, xa, xc)
xHi = np.where(xa > xc, xa, xc)
xmin = xb
fmin = func(pn + xmin * dirn, info)
xv = xmin
xw = xmin
fv = fmin
fw = fmin
es = 0.0
for iteration in range(maxit):
goldstep = 1
xm = (xLo + xHi)/2.0
TOL1 = tol * abs(xmin) + zeps
TOL2 = 2*TOL1
if (abs(xmin - xm) <= (TOL2 - (xHi-xLo)/2.0)):
return xmin, iteration
if (abs(es) > TOL1):
r = (xmin-xw) * (fmin-fv)
q = (xmin-xv) * (fmin-fw)
p = (xmin-xv) * q + (xmin-xw) * r
q = 2 * (q-r)
if (q > 0): p = -p
q = abs(q)
etemp = es
es = ds
if (p > q*(xLo-xmin)) and (p < q*(xHi-xmin)) and (abs(p) < abs(q*etemp/2)):
ds = p/q
xu = xmin + ds
if (xu-xLo < TOL2) or (xHi-xu < TOL2):
ds = TOL1 * (1-2*((xm-xmin) < 0))
goldstep = 0
if goldstep:
if (xmin >= xm):
es = xLo-xmin
else:
es = xHi-xmin
ds = goldc * es
xu = xmin + (1-2*(ds < 0)) * np.where(abs(ds) > TOL1, abs(ds), TOL1)
fu = func(pn + xu * dirn, info)
if (fu <= fmin):
if (xu >= xmin):
xLo=xmin
else:
xHi=xmin
xv = xw
fv = fw
xw = xmin
fw = fmin
xmin = xu
fmin = fu
else:
if (xu < xmin):
xLo=xu
else:
xHi=xu
if (fu <= fw) or (xw == xmin):
xv = xw
fv = fw
xw = xu
fw = fu
elif (fu <= fv) or (xv == xmin) or (xv == xw):
xv = xu
fv = fu
return xmin, (maxit + 1)
def _test():
import vespa.analysis.algos.shiftopt
import pylab
import vespa.common.util.generic_spectral as util_generic_spectral
xa = -11
xb = -15
xc = -20
func = shiftopt.shift_correlation_function
sw = 3906.25
dim0 = 4096
width = 5.0
shift = 15.2
xx = np.arange(dim0) / sw
lshape = util_generic_spectral.apodize(xx, width, 'Gaussian') # from 4DFT
data0 = np.exp(1j*2.0*np.pi*xx*shift)
data = data0 * lshape
pylab.plot(data0, 'b')
pylab.plot(data, 'r')
pylab.plot(lshape, 'g')
pylab.show()
info = { "data" : data,
"acqsw" : sw,
"expo" : lshape }
minshift, iter_ = minf_parabolic_info(xa, xb, xc, func, info)
print(minshift, ' ', iter_)
if __name__ == '__main__':
_test()
"""
Minf unit test result:
minshift = 2.16607634704e-005
""" | StarcoderdataPython |
1706557 | <filename>fusioncharts/samples/linked_chart_single_level.py
from django.shortcuts import render
from django.http import HttpResponse
# Include the `fusioncharts.py` file that contains functions to embed the charts.
from ..fusioncharts import FusionCharts
# Loading Data from a Static JSON String
# Example to create a Column 2D chart with the chart data passed in JSON string format.
# The `chart` method is defined to load chart data from a JSON string.
def chart(request):
# Create an object for the Column 2D chart using the FusionCharts class constructor
column2DChart = FusionCharts("column2d", "ex1", "600", "400", "chart-1", "json",
# The chart data is passed as a string to the `dataSource` parameter.
"""{
"chart": {
"caption": "Projected Global IP Traffic, 2016-2019",
"subcaption": "Click on a column to drill-down into type of traffic",
"yaxisname": "Total IP traffic (PetaByte per Month)",
"formatnumberscale": "1",
"plotgradientcolor": " ",
"bgcolor": "FFFFFF",
"showalternatehgridcolor": "0",
"showplotborder": "0",
"showvalues": "1",
"divlinecolor": "CCCCCC",
"divlinedashed": "1",
"showcanvasborder": "0",
"defaultnumberscale": "PB",
"yAxisMaxValue": "185000",
"numberscaleunit": "PB,EB",
"palettecolors": "34495e ",
"captionPadding": "20",
"showborder": "0",
"plotToolText": "<div><b>$label</b><br/>IP Traffic : <b>$datavalue</b></div>",
},
"data": [
{"label": "2016", "value": "88426", "link": "newchart-json-2016-type"}, {"label": "2017",
"value": "108988",
"link": "newchart-json-2017-type"
}, {
"label": "2018",
"value": "135483",
"link": "newchart-json-2018-type"
}, {
"label": "2019",
"value": "167978",
"link": "newchart-json-2019-type"
}],
"linkeddata": [{
"id": "2016-type",
"linkedchart": {
"chart": {
"caption": "Global IP Traffic, 2016",
"subcaption": "By Type (PB per Month)",
"formatnumberscale": "1",
"plotgradientcolor": " ",
"bgcolor": "FFFFFF",
"yaxismaxvalue": "55000",
"showalternatehgridcolor": "0",
"showplotborder": "0",
"showvalues": "1",
"labeldisplay": "WRAP",
"divlinecolor": "CCCCCC",
"divlinedashed": "1",
"showcanvasborder": "0",
"captionPadding": "20",
"defaultnumberscale": "PB",
"numberscalevalue": "1024,1024",
"numberscaleunit": "PB,EB",
"palettecolors": "34495e"
},
"data": [{
"label": "Fixed Internet",
"value": "58304"
}, {
"label": "Managed IP",
"value": "23371"
}, {
"label": "Mobile data",
"value": "6751"
}]
}
}, {
"id": "2017-type",
"linkedchart": {
"chart": {
"caption": "Global IP Traffic, 2017",
"subcaption": "By Type (PB per Month)",
"formatnumberscale": "1",
"plotgradientcolor": " ",
"yaxismaxvalue": "65000",
"bgcolor": "FFFFFF",
"showalternatehgridcolor": "0",
"showplotborder": "0",
"showvalues": "1",
"labeldisplay": "WRAP",
"divlinecolor": "CCCCCC",
"divlinedashed": "1",
"showcanvasborder": "0",
"captionPadding": "20",
"defaultnumberscale": "PB",
"numberscalevalue": "1024,1024",
"numberscaleunit": "PB,EB",
"palettecolors": "34495e"
},
"data": [{
"label": "Fixed Internet",
"value": "72251"
}, {
"label": "Managed IP",
"value": "26087"
}, {
"label": "Mobile data",
"value": "10650"
}]
}
}, {
"id": "2018-type",
"linkedchart": {
"chart": {
"caption": "Global IP Traffic, 2018",
"subcaption": "By Type (PB per Month)",
"formatnumberscale": "1",
"plotgradientcolor": " ",
"bgcolor": "FFFFFF",
"showalternatehgridcolor": "0",
"showplotborder": "0",
"yaxismaxvalue": "75000",
"showvalues": "1",
"labeldisplay": "WRAP",
"divlinecolor": "CCCCCC",
"divlinedashed": "1",
"showcanvasborder": "0",
"captionPadding": "20",
"defaultnumberscale": "PB",
"numberscalevalue": "1024,1024",
"numberscaleunit": "PB,EB",
"palettecolors": "34495e"
},
"data": [{
"label": "Fixed Internet",
"value": "90085"
}, {
"label": "Managed IP",
"value": "29274"
}, {
"label": "Mobile data",
"value": "16124"
}]
}
}, {
"id": "2019-type",
"linkedchart": {
"chart": {
"caption": "Global IP Traffic, 2019",
"subcaption": "By Type (PB per Month)",
"formatnumberscale": "1",
"plotgradientcolor": " ",
"bgcolor": "FFFFFF",
"showalternatehgridcolor": "0",
"showplotborder": "0",
"yaxismaxvalue": "75000",
"showvalues": "1",
"labeldisplay": "WRAP",
"divlinecolor": "CCCCCC",
"divlinedashed": "1",
"showcanvasborder": "0",
"captionPadding": "20",
"defaultnumberscale": "PB",
"numberscalevalue": "1024,1024",
"numberscaleunit": "PB,EB",
"palettecolors": "34495e"
},
"data": [{
"label": "Fixed Internet",
"value": "111899"
}, {
"label": "Managed IP",
"value": "31858"
}, {
"label": "Mobile data",
"value": "24221"
}]
}
}]
}""")
# Alternatively, you can assign this string to a string variable in a separate JSON file and
# pass the URL of that file to the `dataSource` parameter.
return render(request, 'index.html', {'output': column2DChart.render()})
| StarcoderdataPython |
1614811 | # Generated by Django 3.0.6 on 2020-05-13 22:15
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('gea', '0003_auto_20200506_1813'),
]
operations = [
migrations.AlterField(
model_name='antecedente',
name='expediente_modificado',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='expediente_modificado', to='gea.Expediente'),
),
]
| StarcoderdataPython |
1635303 | <reponame>Nurgak/IoT-RGB-LED-Matrix-Socket
#!/usr/bin/env python3
"""! Animation saving server script."""
import socket
import logging
from threading import Thread
import numpy as np
from PIL import Image
class Save(Thread):
"""! Animation saving server class."""
__frame_array = []
__TIMEOUT = 3
__FRAME_LENGTH = 48 * 32 + 1
def __init__(
self, name: str, frames: int = 1, duration: int = 40, port: int = 7777
):
"""! Constructor.
@param name File name to save as.
@param frames Number of frames to save.
@param duration Duration of the animated image.
@param port Port on which to advertise the saving server.
"""
Thread.__init__(self, target=self.__run)
self.__name = name
assert frames > 0, "Frame count must be greater than 0."
self.__frames = frames
self.__duration = duration
self.__server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.__server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.__server.settimeout(self.__TIMEOUT)
self.__server.bind(("0.0.0.0", port))
self.start()
def __run(self):
self.__server.listen(1)
while len(self.__frame_array) < self.__frames:
conn, _ = self.__server.accept()
with conn:
while len(self.__frame_array) < self.__frames:
data = conn.recv(self.__FRAME_LENGTH)
# Remove the terminator character.
data = data[:-1]
screen = self.unpack(data)
frame = Image.fromarray(screen)
self.__frame_array.append(frame)
# Acknowledge or terminate connection.
conn.send(
b"\n" if len(self.__frame_array) < self.__frames else b"0x4"
)
logging.debug(
"[%s] Progress: %.2f%%",
self.__class__.__name__,
100 * len(self.__frame_array) / self.__frames,
)
logging.debug("[%s] Saving image...", self.__class__.__name__)
filename = self.save()
logging.info("[%s] Saved image under %s", self.__class__.__name__, filename)
@staticmethod
def unpack(data: bytearray) -> np.ndarray:
"""! Parse a binary screen to a numpy array.
@param data Packed data as a byte array.
@return Unpacked data as a Numpy array.
"""
screen = np.array(list(data), dtype=np.uint8).reshape((48, 32))
bit2 = screen[0::3]
bit1 = screen[1::3]
bit0 = screen[2::3]
screen = np.zeros((32, 32, 3), dtype=np.uint8)
screen[:16, :, 0] = (
((bit0 & 0x4) << 5) | ((bit1 & 0x4) << 4) | ((bit2 & 0x4) << 3)
)
screen[:16, :, 1] = (
((bit0 & 0x8) << 4) | ((bit1 & 0x8) << 3) | ((bit2 & 0x8) << 2)
)
screen[:16, :, 2] = (
((bit0 & 0x10) << 3) | ((bit1 & 0x10) << 2) | ((bit2 & 0x10) << 1)
)
screen[16:, :, 0] = (
((bit0 & 0x20) << 2) | ((bit1 & 0x20) << 1) | ((bit2 & 0x20) << 0)
)
screen[16:, :, 1] = (
((bit0 & 0x40) << 1) | ((bit1 & 0x40) << 0) | ((bit2 & 0x40) >> 1)
)
screen[16:, :, 2] = (
((bit0 & 0x80) << 0) | ((bit1 & 0x80) >> 1) | ((bit2 & 0x80) >> 2)
)
return screen
def save(self) -> str:
"""! Save the animation.
@return The file name under which the image was saved.
"""
extention = "gif" if self.__frames > 1 else "png"
filename = f"{self.__name}.{extention}"
self.__frame_array[0].save(
filename,
save_all=True,
append_images=self.__frame_array[1:],
optimize=False,
duration=self.__duration,
loop=0,
)
return filename
| StarcoderdataPython |
1718501 | <filename>DEPRECATED/optimize_tau_c.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Written by <NAME> for
Low runoff variability driven by a dominance of snowmelt inhibits clear coupling of climate, tectonics, and topography in the Greater Caucasus Mountains
If you use this code or derivatives, please cite the original paper.
"""
import pandas as pd
import numpy as np
from scipy.optimize import minimize_scalar
from astropy.utils import NumpyRNGContext
import stochastic_threshold as stim
# Read in data
df=pd.read_csv('data_tables/gc_ero_master_table.csv')
mR=df['mean_runoff'].to_numpy()
ksn=df['mean_ksn'].to_numpy()
ksn_u=df['se_ksn'].to_numpy()
e=df['St_E_rate_m_Myr'].to_numpy()
e_u=df['St_Ext_Unc'].to_numpy()
# Choice of k estimation technique
k_var='k_z_est'
k_var1='k_SSN_est'
# Assigned k values
k_values=df[[k_var,k_var1]]
k=k_values.mean(1).to_numpy()
k_std=k_values.std(1)
# Set k_e
k_e=2.24e-10
# For reproducibility
seed=10
## OPTIMIZATION SCHEME FOR k_e
tau_c=np.zeros(mR.shape)
tau_c_simple=np.zeros(mR.shape)
est_err=np.zeros(mR.shape)
e_predicted=np.zeros(mR.shape)
num_synth=500
with NumpyRNGContext(seed):
for i in range(len(mR)):
mR_val=mR[i]
k_val=k[i]
ksn_val=ksn[i]
e_val=e[i]
# Generate distributions
ksn_dist=np.random.normal(ksn[i],ksn_u[i],num_synth)
e_dist=np.random.normal(e[i],e_u[i],num_synth)
def optim_tau_c(x):
con_list=stim.set_constants(mR_val,k_e,tau_c=x,k_w=5)
[E_pred,E_err,Q_starc]=stim.stim_one(ksn_val,k_val,con_list)
err=np.abs(E_pred-e_val)
return err
def optim_tau_c_dist(x):
con_list=stim.set_constants(mR_val,k_e,tau_c=x,k_w=5)
E_pred=np.zeros((num_synth))
for k in range(num_synth):
[E_pred[k],E_err,Q_starc]=stim.stim_one(ksn_dist[i],k_val,con_list)
rmse=np.sqrt(np.sum((e_dist-E_pred)**2)/num_synth)
return rmse
res=minimize_scalar(optim_tau_c,bounds=[10,100],method='bounded',
options={'maxiter':500000,'xatol':1e-5})
res_alt=minimize_scalar(optim_tau_c_dist,bounds=[10,100],method='bounded',
options={'maxiter':500000,'xatol':1e-5})
tau_c_simple[i]=res.x
tau_c[i]=res_alt.x
est_err[i]=res_alt.fun
cL=stim.set_constants(mR_val,k_e,tau_c=tau_c[i])
[e_predicted[i],E_err,Q_starc]=stim.stim_one(ksn_val,k_val,cL)
prog=np.round(i/len(mR)*100,2)
print('Current progress: '+str(prog)+'%')
tau_c_simple=tau_c_simple.reshape((len(mR),1))
tau_c=tau_c.reshape((len(mR),1))
est_err=est_err.reshape((len(mR),1))
e_predicted=e_predicted.reshape((len(mR),1))
data=np.concatenate((tau_c_simple,tau_c,est_err,e_predicted),axis=1)
dfout=pd.DataFrame(data,columns=['tau_c_simple','tau_c_boostrap','rmse_bootstrap','E_pred'])
dfout.to_csv('result_tables/tau_c_optim.csv',index=False) | StarcoderdataPython |
4414 | __author__ = "<NAME>"
__copyright__ = "Copyright 2017, Stanford University"
__license__ = "MIT"
import sys
from deepchem.models import KerasModel
from deepchem.models.layers import AtomicConvolution
from deepchem.models.losses import L2Loss
from tensorflow.keras.layers import Input, Layer
import numpy as np
import tensorflow as tf
import itertools
def initializeWeightsBiases(prev_layer_size,
size,
weights=None,
biases=None,
name=None):
"""Initializes weights and biases to be used in a fully-connected layer.
Parameters
----------
prev_layer_size: int
Number of features in previous layer.
size: int
Number of nodes in this layer.
weights: tf.Tensor, optional (Default None)
Weight tensor.
biases: tf.Tensor, optional (Default None)
Bias tensor.
name: str
Name for this op, optional (Defaults to 'fully_connected' if None)
Returns
-------
weights: tf.Variable
Initialized weights.
biases: tf.Variable
Initialized biases.
"""
if weights is None:
weights = tf.random.truncated_normal([prev_layer_size, size], stddev=0.01)
if biases is None:
biases = tf.zeros([size])
w = tf.Variable(weights, name='w')
b = tf.Variable(biases, name='b')
return w, b
class AtomicConvScore(Layer):
"""The scoring function used by the atomic convolution models."""
def __init__(self, atom_types, layer_sizes, **kwargs):
super(AtomicConvScore, self).__init__(**kwargs)
self.atom_types = atom_types
self.layer_sizes = layer_sizes
def build(self, input_shape):
self.type_weights = []
self.type_biases = []
self.output_weights = []
self.output_biases = []
n_features = int(input_shape[0][-1])
layer_sizes = self.layer_sizes
num_layers = len(layer_sizes)
weight_init_stddevs = [1 / np.sqrt(x) for x in layer_sizes]
bias_init_consts = [0.0] * num_layers
for ind, atomtype in enumerate(self.atom_types):
prev_layer_size = n_features
self.type_weights.append([])
self.type_biases.append([])
self.output_weights.append([])
self.output_biases.append([])
for i in range(num_layers):
weight, bias = initializeWeightsBiases(
prev_layer_size=prev_layer_size,
size=layer_sizes[i],
weights=tf.random.truncated_normal(
shape=[prev_layer_size, layer_sizes[i]],
stddev=weight_init_stddevs[i]),
biases=tf.constant(
value=bias_init_consts[i], shape=[layer_sizes[i]]))
self.type_weights[ind].append(weight)
self.type_biases[ind].append(bias)
prev_layer_size = layer_sizes[i]
weight, bias = initializeWeightsBiases(prev_layer_size, 1)
self.output_weights[ind].append(weight)
self.output_biases[ind].append(bias)
def call(self, inputs):
frag1_layer, frag2_layer, complex_layer, frag1_z, frag2_z, complex_z = inputs
atom_types = self.atom_types
num_layers = len(self.layer_sizes)
def atomnet(current_input, atomtype):
prev_layer = current_input
for i in range(num_layers):
layer = tf.nn.bias_add(
tf.matmul(prev_layer, self.type_weights[atomtype][i]),
self.type_biases[atomtype][i])
layer = tf.nn.relu(layer)
prev_layer = layer
output_layer = tf.squeeze(
tf.nn.bias_add(
tf.matmul(prev_layer, self.output_weights[atomtype][0]),
self.output_biases[atomtype][0]))
return output_layer
frag1_zeros = tf.zeros_like(frag1_z, dtype=tf.float32)
frag2_zeros = tf.zeros_like(frag2_z, dtype=tf.float32)
complex_zeros = tf.zeros_like(complex_z, dtype=tf.float32)
frag1_atomtype_energy = []
frag2_atomtype_energy = []
complex_atomtype_energy = []
for ind, atomtype in enumerate(atom_types):
frag1_outputs = tf.map_fn(lambda x: atomnet(x, ind), frag1_layer)
frag2_outputs = tf.map_fn(lambda x: atomnet(x, ind), frag2_layer)
complex_outputs = tf.map_fn(lambda x: atomnet(x, ind), complex_layer)
cond = tf.equal(frag1_z, atomtype)
frag1_atomtype_energy.append(tf.where(cond, frag1_outputs, frag1_zeros))
cond = tf.equal(frag2_z, atomtype)
frag2_atomtype_energy.append(tf.where(cond, frag2_outputs, frag2_zeros))
cond = tf.equal(complex_z, atomtype)
complex_atomtype_energy.append(
tf.where(cond, complex_outputs, complex_zeros))
frag1_outputs = tf.add_n(frag1_atomtype_energy)
frag2_outputs = tf.add_n(frag2_atomtype_energy)
complex_outputs = tf.add_n(complex_atomtype_energy)
frag1_energy = tf.reduce_sum(frag1_outputs, 1)
frag2_energy = tf.reduce_sum(frag2_outputs, 1)
complex_energy = tf.reduce_sum(complex_outputs, 1)
binding_energy = complex_energy - (frag1_energy + frag2_energy)
return tf.expand_dims(binding_energy, axis=1)
class AtomicConvModel(KerasModel):
"""Implements an Atomic Convolution Model.
Implements the atomic convolutional networks as introduced in
<NAME> al. "Atomic convolutional networks for predicting protein-ligand binding affinity." arXiv preprint arXiv:1703.10603 (2017).
The atomic convolutional networks function as a variant of
graph convolutions. The difference is that the "graph" here is
the nearest neighbors graph in 3D space. The AtomicConvModel
leverages these connections in 3D space to train models that
learn to predict energetic state starting from the spatial
geometry of the model.
"""
def __init__(self,
frag1_num_atoms=70,
frag2_num_atoms=634,
complex_num_atoms=701,
max_num_neighbors=12,
batch_size=24,
atom_types=[
6, 7., 8., 9., 11., 12., 15., 16., 17., 20., 25., 30., 35.,
53., -1.
],
radial=[[
1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0,
7.5, 8.0, 8.5, 9.0, 9.5, 10.0, 10.5, 11.0, 11.5, 12.0
], [0.0, 4.0, 8.0], [0.4]],
layer_sizes=[32, 32, 16],
learning_rate=0.001,
**kwargs):
"""
Parameters
----------
frag1_num_atoms: int
Number of atoms in first fragment
frag2_num_atoms: int
Number of atoms in sec
max_num_neighbors: int
Maximum number of neighbors possible for an atom. Recall neighbors
are spatial neighbors.
atom_types: list
List of atoms recognized by model. Atoms are indicated by their
nuclear numbers.
radial: list
TODO: add description
layer_sizes: list
TODO: add description
learning_rate: float
Learning rate for the model.
"""
# TODO: Turning off queue for now. Safe to re-activate?
self.complex_num_atoms = complex_num_atoms
self.frag1_num_atoms = frag1_num_atoms
self.frag2_num_atoms = frag2_num_atoms
self.max_num_neighbors = max_num_neighbors
self.batch_size = batch_size
self.atom_types = atom_types
rp = [x for x in itertools.product(*radial)]
frag1_X = Input(shape=(frag1_num_atoms, 3))
frag1_nbrs = Input(shape=(frag1_num_atoms, max_num_neighbors))
frag1_nbrs_z = Input(shape=(frag1_num_atoms, max_num_neighbors))
frag1_z = Input(shape=(frag1_num_atoms,))
frag2_X = Input(shape=(frag2_num_atoms, 3))
frag2_nbrs = Input(shape=(frag2_num_atoms, max_num_neighbors))
frag2_nbrs_z = Input(shape=(frag2_num_atoms, max_num_neighbors))
frag2_z = Input(shape=(frag2_num_atoms,))
complex_X = Input(shape=(complex_num_atoms, 3))
complex_nbrs = Input(shape=(complex_num_atoms, max_num_neighbors))
complex_nbrs_z = Input(shape=(complex_num_atoms, max_num_neighbors))
complex_z = Input(shape=(complex_num_atoms,))
self._frag1_conv = AtomicConvolution(
atom_types=self.atom_types, radial_params=rp,
boxsize=None)([frag1_X, frag1_nbrs, frag1_nbrs_z])
self._frag2_conv = AtomicConvolution(
atom_types=self.atom_types, radial_params=rp,
boxsize=None)([frag2_X, frag2_nbrs, frag2_nbrs_z])
self._complex_conv = AtomicConvolution(
atom_types=self.atom_types, radial_params=rp,
boxsize=None)([complex_X, complex_nbrs, complex_nbrs_z])
score = AtomicConvScore(self.atom_types, layer_sizes)([
self._frag1_conv, self._frag2_conv, self._complex_conv, frag1_z,
frag2_z, complex_z
])
model = tf.keras.Model(
inputs=[
frag1_X, frag1_nbrs, frag1_nbrs_z, frag1_z, frag2_X, frag2_nbrs,
frag2_nbrs_z, frag2_z, complex_X, complex_nbrs, complex_nbrs_z,
complex_z
],
outputs=score)
super(AtomicConvModel, self).__init__(
model, L2Loss(), batch_size=batch_size, **kwargs)
def default_generator(self,
dataset,
epochs=1,
mode='fit',
deterministic=True,
pad_batches=True):
batch_size = self.batch_size
def replace_atom_types(z):
def place_holder(i):
if i in self.atom_types:
return i
return -1
return np.array([place_holder(x) for x in z])
for epoch in range(epochs):
for ind, (F_b, y_b, w_b, ids_b) in enumerate(
dataset.iterbatches(
batch_size, deterministic=True, pad_batches=pad_batches)):
N = self.complex_num_atoms
N_1 = self.frag1_num_atoms
N_2 = self.frag2_num_atoms
M = self.max_num_neighbors
batch_size = F_b.shape[0]
num_features = F_b[0][0].shape[1]
frag1_X_b = np.zeros((batch_size, N_1, num_features))
for i in range(batch_size):
frag1_X_b[i] = F_b[i][0]
frag2_X_b = np.zeros((batch_size, N_2, num_features))
for i in range(batch_size):
frag2_X_b[i] = F_b[i][3]
complex_X_b = np.zeros((batch_size, N, num_features))
for i in range(batch_size):
complex_X_b[i] = F_b[i][6]
frag1_Nbrs = np.zeros((batch_size, N_1, M))
frag1_Z_b = np.zeros((batch_size, N_1))
for i in range(batch_size):
z = replace_atom_types(F_b[i][2])
frag1_Z_b[i] = z
frag1_Nbrs_Z = np.zeros((batch_size, N_1, M))
for atom in range(N_1):
for i in range(batch_size):
atom_nbrs = F_b[i][1].get(atom, "")
frag1_Nbrs[i, atom, :len(atom_nbrs)] = np.array(atom_nbrs)
for j, atom_j in enumerate(atom_nbrs):
frag1_Nbrs_Z[i, atom, j] = frag1_Z_b[i, atom_j]
frag2_Nbrs = np.zeros((batch_size, N_2, M))
frag2_Z_b = np.zeros((batch_size, N_2))
for i in range(batch_size):
z = replace_atom_types(F_b[i][5])
frag2_Z_b[i] = z
frag2_Nbrs_Z = np.zeros((batch_size, N_2, M))
for atom in range(N_2):
for i in range(batch_size):
atom_nbrs = F_b[i][4].get(atom, "")
frag2_Nbrs[i, atom, :len(atom_nbrs)] = np.array(atom_nbrs)
for j, atom_j in enumerate(atom_nbrs):
frag2_Nbrs_Z[i, atom, j] = frag2_Z_b[i, atom_j]
complex_Nbrs = np.zeros((batch_size, N, M))
complex_Z_b = np.zeros((batch_size, N))
for i in range(batch_size):
z = replace_atom_types(F_b[i][8])
complex_Z_b[i] = z
complex_Nbrs_Z = np.zeros((batch_size, N, M))
for atom in range(N):
for i in range(batch_size):
atom_nbrs = F_b[i][7].get(atom, "")
complex_Nbrs[i, atom, :len(atom_nbrs)] = np.array(atom_nbrs)
for j, atom_j in enumerate(atom_nbrs):
complex_Nbrs_Z[i, atom, j] = complex_Z_b[i, atom_j]
inputs = [
frag1_X_b, frag1_Nbrs, frag1_Nbrs_Z, frag1_Z_b, frag2_X_b,
frag2_Nbrs, frag2_Nbrs_Z, frag2_Z_b, complex_X_b, complex_Nbrs,
complex_Nbrs_Z, complex_Z_b
]
y_b = np.reshape(y_b, newshape=(batch_size, 1))
yield (inputs, [y_b], [w_b])
| StarcoderdataPython |
77020 | import logging
import numpy as np
import sklearn.preprocessing as prep
from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC
from sklearn.utils import check_random_state
from csrank.objectranking.object_ranker import ObjectRanker
from csrank.tunable import Tunable
from csrank.util import print_dictionary
from ..dataset_reader.objectranking.util import \
generate_complete_pairwise_dataset
__all__ = ['RankSVM']
class RankSVM(ObjectRanker, Tunable):
_tunable = None
def __init__(self, n_features, C=1.0, tol=1e-4, normalize=True,
fit_intercept=True, random_state=None, **kwargs):
""" Create an instance of the RankSVM model.
Parameters
----------
n_features : int
Number of features of the object space
C : float, optional
Penalty parameter of the error term
tol : float, optional
Optimization tolerance
normalize : bool, optional
If True, the regressors will be normalized before fitting.
fit_intercept : bool, optional
If True, the linear model will also fit an intercept.
random_state : int, RandomState instance or None, optional
Seed of the pseudorandom generator or a RandomState instance
**kwargs
Keyword arguments for the algorithms
References
----------
.. [1] <NAME>. (2002, July).
"Optimizing search engines using clickthrough data.",
Proceedings of the eighth ACM SIGKDD international conference on
Knowledge discovery and data mining (pp. 133-142). ACM.
"""
self.normalize = normalize
self.n_features = n_features
self.C = C
self.tol = tol
self.logger = logging.getLogger('RankSVM')
self.random_state = check_random_state(random_state)
self.threshold_instances = 1000000
self.fit_intercept = fit_intercept
def fit(self, X, Y, **kwargs):
self.logger.debug('Creating the Dataset')
X_train, garbage, garbage, garbage, Y_single = generate_complete_pairwise_dataset(
X, Y)
del garbage
assert X_train.shape[1] == self.n_features
self.logger.debug(
'Finished the Dataset with instances {}'.format(X_train.shape[0]))
if (X_train.shape[0] > self.threshold_instances):
self.model = LogisticRegression(C=self.C, tol=self.tol,
fit_intercept=self.fit_intercept,
random_state=self.random_state)
else:
self.model = LinearSVC(C=self.C, tol=self.tol,
fit_intercept=self.fit_intercept,
random_state=self.random_state)
if (self.normalize):
scaler = prep.StandardScaler()
X_train = scaler.fit_transform(X_train)
self.logger.debug('Finished Creating the model, now fitting started')
self.model.fit(X_train, Y_single)
self.weights = self.model.coef_.flatten()
if (self.fit_intercept):
self.weights = np.append(self.weights, self.model.intercept_)
self.logger.debug('Fitting Complete')
def _predict_scores_fixed(self, X, **kwargs):
n_instances, n_objects, n_features = X.shape
self.logger.info(
"For Test instances {} objects {} features {}".format(n_instances,
n_objects,
n_features))
scores = []
for data_test in X:
assert data_test.shape[1] == self.n_features
weights = np.array(self.model.coef_)[0]
try:
score = np.sum(weights * data_test, axis=1)
except ValueError:
score = np.sum(weights[1:] * data_test, axis=1)
scores.append(score)
self.logger.info("Done predicting scores")
return np.array(scores)
def predict_scores(self, X, **kwargs):
return super().predict_scores(X, **kwargs)
def predict(self, X, **kwargs):
return super().predict(X, **kwargs)
def predict_pair(self, a, b, **kwargs):
weights = np.array(self.model.coef_)[0]
score_a = np.sum(weights * a, axis=1)
score_b = np.sum(weights * b, axis=1)
return [score_a / (score_a + score_b), score_b / (score_a + score_b)]
def set_tunable_parameters(self, C=1.0, tol=1e-4, **point):
self.tol = tol
self.C = C
if len(point) > 0:
self.logger.warning('This ranking algorithm does not support'
' tunable parameters'
' called: {}'.format(print_dictionary(point)))
| StarcoderdataPython |
3323054 | from django.shortcuts import render
from bs4 import BeautifulSoup
import requests
# Create your views here.
def home(request):
return render(request, 'home.html')
def result(request):
search=request.GET['keyword']
url = 'https://search.naver.com/search.naver?where=news&sm=tab_jum&query={}'.format(search)
req = requests.get(url)
html = req.text
soup = BeautifulSoup(html, 'html.parser')
titles = soup.select('div.news_wrap.api_ani_send > div > a')
data = {}
for title in titles:
data[title.text]=title.get('href')
return render(request, 'result.html', {'data':data.items()}) | StarcoderdataPython |
129687 | from . import commands
from .task import BaseTask
from .utils import echo
from .worker import Worker
| StarcoderdataPython |
108428 | import unittest
import json
from stampman.helpers import mail_, config_
class EmailTest(unittest.TestCase):
"""Tests for the Email helper class"""
def setUp(self):
self._valid_sender = ("Test", "<EMAIL>")
self._invalid_sender = ("Test", "this_is_not_a_valid_e_mail_address")
self._valid_e_mail_list = ["<EMAIL>", "<EMAIL>"]
self._invalid_e_mail_list = ["<EMAIL>", "t@e.c"]
self._valid_string = "this_is_a_valid_string"
def test_empty_sender(self):
with self.assertRaises(TypeError):
mail_.Email(sender="")
def test_invalid_sender_address_length(self):
with self.assertRaises(AssertionError):
mail_.Email(sender=self._invalid_sender)
def test_invalid_sender_address(self):
with self.assertRaises(AssertionError):
mail_.Email(sender=self._invalid_sender)
def test_empty_recipients(self):
with self.assertRaises(TypeError):
mail_.Email(sender=self._valid_sender, recipients=[])
def test_invalid_recipients(self):
with self.assertRaises(AssertionError):
mail_.Email(sender=self._valid_sender,
recipients=self._invalid_e_mail_list)
def test_invalid_subject(self):
with self.assertRaises(TypeError):
mail_.Email(sender=self._valid_sender,
recipients=self._valid_e_mail_list, subject=1)
def test_invalid_content(self):
with self.assertRaises(TypeError):
mail_.Email(sender=self._valid_sender,
recipients=self._valid_e_mail_list,
subject=self._valid_string, content=1)
def test_invalid_cc(self):
with self.assertRaises(TypeError):
mail_.Email(sender=self._valid_sender,
recipients=self._valid_e_mail_list,
subject=self._valid_string, content=self._valid_string,
cc="")
def test_invalid_bcc(self):
with self.assertRaises(TypeError):
mail_.Email(sender=self._valid_sender,
recipients=self._valid_e_mail_list,
subject=self._valid_string, content=self._valid_string,
cc=self._valid_e_mail_list, bcc="")
def test_invalid_reply_to(self):
with self.assertRaises(AssertionError):
mail_.Email(sender=self._valid_sender,
recipients=self._valid_e_mail_list,
subject=self._valid_string, content=self._valid_string,
cc=self._valid_e_mail_list,
bcc=self._valid_e_mail_list,
reply_to="")
def test_message_creation(self):
_message = mail_.Email(sender=self._valid_sender,
recipients=self._valid_e_mail_list,
subject=self._valid_string,
content=self._valid_string,
cc=self._valid_e_mail_list,
bcc=self._valid_e_mail_list,
reply_to=self._valid_sender[1])
self.assertEqual(self._valid_sender[0], _message._from_name)
self.assertEqual(self._valid_sender[1], _message._from_address)
self.assertEqual(self._valid_e_mail_list, _message._to)
self.assertEqual(self._valid_string, _message._subject)
self.assertEqual(self._valid_string, _message._body)
self.assertEqual(self._valid_e_mail_list, _message._cc)
self.assertEqual(self._valid_e_mail_list, _message._bcc)
self.assertEqual(self._valid_sender[1], _message._reply_to)
def test_serialization(self):
_message = mail_.Email(sender=self._valid_sender,
recipients=self._valid_e_mail_list,
subject=self._valid_string,
content=self._valid_string,
cc=self._valid_e_mail_list,
bcc=self._valid_e_mail_list,
reply_to=self._valid_sender[1])
expected_output_dict = {
"sender": _message._from_address,
"recipients": _message._to,
"subject": _message._subject,
"content": _message._body,
"cc": _message._cc,
"bcc": _message._bcc,
"reply_to": _message._reply_to
}
self.assertEqual(json.dumps(expected_output_dict), str(_message))
class ConfigTest(unittest.TestCase):
"""Tests for the ServiceConfig helper namedtuple"""
def setUp(self):
self._valid_string = "this_is_an_api_key"
self._valid_domain = "_mail.sshukla.de"
self._config_file = "config.json"
self._service = "sendgrid"
self._services = {
"sendgrid": {
"api_key": "INSERT_KEY_HERE",
"priority": 1,
"enabled": True
},
"mailgun": {
"api_key": "INSERT_KEY_HERE",
"priority": 2,
"enabled": True
},
"mandrill": {
"api_key": "INSERT_KEY_HERE",
"priority": 3,
"enabled": False
},
"amazon_ses": {
"api_key": "INSERT_KEY_HERE",
"priority": 4,
"enabled": False
}
}
def test_config_creation(self):
config = config_.ServiceConfig(name=self._service,
api_key=self._valid_string,
priority=1)
self.assertEqual(self._service, config.name)
self.assertEqual(self._valid_string, config.api_key)
self.assertEqual(1, config.priority)
def test_config_load(self):
config_dict = config_.load_json_file(self._config_file)
pools = config_.get_domain_pools(config_dict)
for pool in pools:
for service in pool.services:
for key, value in self._services.items():
if key == service.name:
self.assertEqual(value["api_key"], service.api_key)
self.assertEqual(value["priority"], service.priority)
| StarcoderdataPython |
1789814 | import numpy as np
from collections import Counter
import collections
import csv
import re
def lottery_analysis():
counter = 0
list_counter = 0
output_list = []
pre_change_list = []
post_change_list = []
raw_list = np.loadtxt(open("/home/rane/testing/winning_numbers.csv", "rb"), dtype='str', delimiter=',')
string_version = str(raw_list)
version0 = re.sub(r" [0-9][0-9]'","'",string_version)
alt_version1 = version0.replace("' '","','")
alt_version2 = alt_version1.replace("'\n '","','")
back = eval(alt_version2)
for element in back:
if list_counter < 591:
pre_change_list.append(element)
list_counter += 1
elif list_counter >= 591:
post_change_list.append(element)
list_counter += 1
pre_change_str = str(pre_change_list)
post_change_str = str(post_change_list)
version1 = post_change_str.replace("'","")
version2 = version1.replace(" ",",")
version3 = version2.replace(",,",",")
version4 = version3.replace(",0",",")
list_version = eval(version4)
check = (len(list_version))/5
if check == 291.0:
print("Parsed the correct number of elements.")
else:
print("Parsed as incorrect number of elements. Expected 291.0, got "+str(check)+".")
new_dictionary = dict(Counter(list_version))
for key, value in new_dictionary.items():
counter += value
for key, value in new_dictionary.items():
output_list.append([key,(value/counter)])
if counter == 1455:
print("Correct total of numbers returned.")
else:
print("Incorrect total of numbers returned. Expected 1455, got "+str(counter)+".")
with open("/home/rane/testing/post_change_lottery.csv", "w") as file:
writer = csv.writer(file)
writer.writerows(output_list)
lottery_analysis()
| StarcoderdataPython |
1769832 | import os
import pytest
from bw2data.tests import bw2test
import bw2regional
from bw2regional.base_data import (
Topography,
create_world_collections,
create_ecoinvent_collections,
create_restofworlds_collections,
geocollections,
topocollections,
)
def nope(*args, **kwargs):
return os.path.join(os.path.dirname(__file__), "data", "test_countries.gpkg")
@pytest.fixture
@bw2test
def no_download(monkeypatch):
monkeypatch.setattr(bw2regional.base_data, "download_file", nope)
@pytest.mark.xfail
@bw2test
def test_row_only():
create_restofworlds_collections()
assert len(geocollections) == 1
assert len(topocollections) == 1
assert Topography("RoW").load()
assert not geocollections["RoW"]
def test_world_only(no_download):
create_world_collections()
assert len(geocollections) == 1
assert len(topocollections) == 1
assert Topography("world").load()
assert geocollections["world"]["field"] == "isotwolettercode"
def test_ecoinvent_only(no_download):
create_ecoinvent_collections()
assert len(geocollections) == 1
assert len(topocollections) == 1
assert Topography("ecoinvent").load()
assert geocollections["ecoinvent"]["field"] == "shortname"
@pytest.mark.xfail
def test_all_basic_data(no_download):
create_world_collections()
create_ecoinvent_collections()
create_restofworlds_collections()
assert len(geocollections) == 3
assert len(topocollections) == 3
# class Callable:
# def __init__(self, name):
# self.name = name
# self.called = False
# def __call__(self):
# self.called = True
# @pytest.fixture
# @bw2test
# def fake_functions(monkeypatch):
# fake_world = Callable("world")
# fake_ei = Callable("ecoinvent")
# fake_row = Callable("RoW")
# monkeypatch.setattr(bw2regional.base_data, "create_world", fake_world)
# monkeypatch.setattr(bw2regional.base_data, "create_ecoinvent", fake_ei)
# monkeypatch.setattr(bw2regional.base_data, "create_RoW", fake_row)
# return fake_world, fake_ei, fake_row
# @bw2test
# def test_regional_setup_error():
# with pytest.raises(ValueError):
# bw2regionalsetup("foo")
# def test_regional_setup_default(fake_functions):
# for x in fake_functions:
# assert not x.called
# bw2regionalsetup()
# for x in fake_functions:
# assert x.called
# def test_regional_setup_specific(fake_functions):
# bw2regionalsetup("ecoinvent")
# w, e, r = fake_functions
# assert not w.called
# assert not r.called
# assert e.called
# def test_regional_setup_no_overwrite(fake_functions):
# geocollections["ecoinvent"] = {}
# bw2regionalsetup("ecoinvent")
# for x in fake_functions:
# assert not x.called
# def test_regional_setup_overwrite(fake_functions):
# geocollections["ecoinvent"] = {}
# bw2regionalsetup("ecoinvent", overwrite=True)
# w, e, r = fake_functions
# assert not w.called
# assert not r.called
# assert e.called
| StarcoderdataPython |
12391 | <gh_stars>1000+
#from http://rosettacode.org/wiki/Greatest_subsequential_sum#Python
#pythran export maxsum(int list)
#pythran export maxsumseq(int list)
#pythran export maxsumit(int list)
#runas maxsum([0, 1, 0])
#runas maxsumseq([-1, 2, -1, 3, -1])
#runas maxsumit([-1, 1, 2, -5, -6])
def maxsum(sequence):
"""Return maximum sum."""
maxsofar, maxendinghere = 0, 0
for x in sequence:
# invariant: ``maxendinghere`` and ``maxsofar`` are accurate for ``x[0..i-1]``
maxendinghere = max(maxendinghere + x, 0)
maxsofar = max(maxsofar, maxendinghere)
return maxsofar
def maxsumseq(sequence):
start, end, sum_start = -1, -1, -1
maxsum_, sum_ = 0, 0
for i, x in enumerate(sequence):
sum_ += x
if maxsum_ < sum_: # found maximal subsequence so far
maxsum_ = sum_
start, end = sum_start, i
elif sum_ < 0: # start new sequence
sum_ = 0
sum_start = i
assert maxsum_ == maxsum(sequence)
assert maxsum_ == sum(sequence[start + 1:end + 1])
return sequence[start + 1:end + 1]
def maxsumit(iterable):
maxseq = seq = []
start, end, sum_start = -1, -1, -1
maxsum_, sum_ = 0, 0
for i, x in enumerate(iterable):
seq.append(x); sum_ += x
if maxsum_ < sum_:
maxseq = seq; maxsum_ = sum_
start, end = sum_start, i
elif sum_ < 0:
seq = []; sum_ = 0
sum_start = i
assert maxsum_ == sum(maxseq[:end - start])
return maxseq[:end - start]
| StarcoderdataPython |
33641 | from django.conf.urls import patterns, url
# App specific URL patterns
urlpatterns = patterns("djkatta.cabshare.views",
# post new req
url(r'new_post/$', 'new_post', name='new_post'),
# view posts by the user
url(r'my_posts/$', 'my_posts', name='my_posts'),
# modify old req
url(r'(?P<post_id>[\d]+)/edit/$', 'edit', name='edit'),
# view individual req
url(r'(?P<post_id>[\d]+)/$', 'indi', name='indi'),
)
| StarcoderdataPython |
1661326 | from data_facility_admin.models import Dataset, DataProvider, Category, Keyword
from collections import namedtuple
import json
import logging
logger = logging.getLogger(__name__)
FieldMapping = namedtuple('FieldMapping', ['dataset', 'gmeta', 'to_model', 'to_json'])
DATA_CLASSIFICATION_MAPPING = [
FieldMapping(Dataset.DATA_CLASSIFICATION_GREEN, 'Public', None, None),
FieldMapping(Dataset.DATA_CLASSIFICATION_RESTRICTED_GREEN, 'Restricted', None, None),
FieldMapping(Dataset.DATA_CLASSIFICATION_YELLOW, 'Private', None, None),
FieldMapping(Dataset.DATA_CLASSIFICATION_RED, None, None, None),
]
DATA_PROVIDER_KEY = 'data_provider'
CATEGORY_KEY = 'category'
def data_classification_to_metadata(data_classification=None):
map = {mapping.dataset: mapping.gmeta for mapping in DATA_CLASSIFICATION_MAPPING}
# print map
# print('metadata_data_classification=', metadata_data_classification)
return map.get(data_classification, Dataset.DATA_CLASSIFICATION_RED)
def data_classification_to_model(data_classification=None):
map = {mapping.gmeta.lower(): mapping.dataset for mapping in DATA_CLASSIFICATION_MAPPING if mapping.gmeta is not None}
# print map
value = map.get(data_classification.lower(), None)
# print('data_classification_to_model(%s)=%s' % (data_classification, map.get(data_classification, None)))
return value
def __get_classification_model(gmeta_classification):
return data_classification_to_model(gmeta_classification)
def __get_data_provider(data_provider_name):
logger.debug('Data Provider: %s' % data_provider_name)
try:
return DataProvider.objects.get(name=data_provider_name)
except DataProvider.DoesNotExist:
logger.info('Created Data Provider: %s' % data_provider_name)
dp = DataProvider(name=data_provider_name)
dp.save()
return dp
def __get_category(category_name):
logger.debug('Category: %s' % category_name)
try:
return Category.objects.get(name=category_name)
except Category.DoesNotExist:
logger.info('Created Category: %s' % category_name)
o = Category(name=category_name)
o.save()
return o
def __name_if_not_none(value):
logger.debug('Value to get name or None: %s' % value)
return value.name if value else None
def __to_date(s):
import datetime
try:
if not s: return None
elif '/' in s:
return datetime.datetime.strptime(s, "%m/%d/%y").date()
elif '-' not in s:
return datetime.datetime.strptime(s, "%Y").date()
elif len(s.split('-')) == 2:
return datetime.datetime.strptime(s, "%Y-%m").date()
elif len(s.split('-')) == 3:
try:
return datetime.datetime.strptime(s, "%Y-%d-%m").date()
except:
return datetime.datetime.strptime(s, "%Y-%m-%d").date()
except:
logger.error('Error translating %s to date.' % s)
raise
return None
def __get_year(d):
return d.year if d is not None else None
def __to_keywords(keywords_list):
keywords = []
for keywork in keywords_list:
try:
k = Keyword.objects.get(name=keywork)
except Keyword.DoesNotExist:
k = Keyword(name=keywork)
k.save()
keywords.append(k)
return keywords
def __keywords_to_list(dataset_keywords):
return [k.name for k in dataset_keywords.all()] if keywords else []
DATASET_ID_FIELD = 'dataset_id'
DIRECT_FIELD_MAPPINGS = [
FieldMapping('name', 'title', None, None),
FieldMapping('description', 'description', None, None),
FieldMapping(DATASET_ID_FIELD, DATASET_ID_FIELD, None, None),
FieldMapping('version', 'dataset_version', None, None),
FieldMapping('dataset_citation', 'dataset_citation', None, None),
FieldMapping('source_url', 'source_url', None, None),
FieldMapping('source_archive', 'source_archive', None, None),
# FieldMapping('keywords', 'keywords', __to_keywords, __keywords_to_list),
FieldMapping('temporal_coverage_start', 'temporal_coverage_start', __to_date, __get_year),
FieldMapping('temporal_coverage_end', 'temporal_coverage_end', __to_date, __get_year),
FieldMapping('category', 'category', __get_category, __name_if_not_none),
FieldMapping('data_provider', 'data_provider', __get_data_provider, __name_if_not_none),
FieldMapping('data_classification', 'data_classification',
__get_classification_model, data_classification_to_metadata),
# FieldMapping('keywords', 'keywords'),
]
def load(search_gmeta, detailed_gmeta=None, given_dataset=None):
"""
Loads a DFAdmin datateset from a gmeta dictionary (JSON).
:param search_gmeta: inpuot JSON to create a dataset with.
:return:
"""
# print('Gmeta: \n %s' % json.dumps(search_gmeta, indent=4))
# The first key on gmeta is the item id. Gmeta is prepared to return a list of metadata.
# So we need to get the first in this case.
gmeta_data = search_gmeta[0][search_gmeta[0].keys()[0]]
if detailed_gmeta is not None:
detailed_gmeta_data = detailed_gmeta[0][search_gmeta[0].keys()[0]]
detailed_content = detailed_gmeta_data['content']
else:
detailed_content = {}
mimetype = gmeta_data['mimetype']
search_content = gmeta_data['content']
# Clear duplicates in detailed content and search_content
for key in search_content:
try:
del detailed_content[key]
except:
pass #this just means that the detailed metadata does not have some key from the search. Not a problem.
# Prep dataset if not given.
if given_dataset:
dataset = given_dataset
else:
try:
dataset = Dataset.objects.get(dataset_id=search_content[DATASET_ID_FIELD])
except Dataset.DoesNotExist:
dataset = Dataset()
# Load fields with direct Mapping
for field_mapping in DIRECT_FIELD_MAPPINGS:
try:
value = search_content[field_mapping.gmeta]
# If there is a method to map, call it.
logger.debug('Dataset field "{0}" from gmeta field "{1}" = {2}'.format(field_mapping.dataset,
field_mapping.gmeta,
value))
if field_mapping.to_model:
value = field_mapping.to_model(value)
# Set attribute on dataset and then remove the field from gmeta to avoid duplicates
setattr(dataset, field_mapping.dataset, value)
search_content.pop(field_mapping.gmeta, None)
detailed_content.pop(field_mapping.gmeta, None)
except UnicodeEncodeError as ex:
setattr(dataset, field_mapping.dataset, value.encode('ascii', 'ignore'))
dataset.search_gmeta = search_content
dataset.detailed_gmeta = detailed_content
return dataset
def dumps(dataset):
"""
Generate a metadata representation of the dataset.
:param dataset:
:return:
"""
metadata = {}
if dataset.search_gmeta:
metadata.update(dataset.search_gmeta)
for field_mapping in DIRECT_FIELD_MAPPINGS:
value = getattr(dataset, field_mapping.dataset, None)
if field_mapping.to_json:
value = field_mapping.to_json(value)
metadata[field_mapping.gmeta] = value
return metadata
| StarcoderdataPython |
1665296 | '''
This module implements routines use to construct the yy_action[] table.
'''
from struct import *
from ccruft import struct
# The state of the yy_action table under construction is an instance
# of the following structure.
#
# The yy_action table maps the pair (state_number, lookahead) into an
# action_number. The table is an array of integers pairs. The state_number
# determines an initial offset into the yy_action array. The lookahead
# value is then added to this initial offset to get an index X into the
# yy_action array. If the aAction[X].lookahead equals the value of the
# of the lookahead input, then the value of the action_number output is
# aAction[X].action. If the lookaheads do not match then the
# default action for the state_number is returned.
#
# All actions associated with a single state_number are first entered
# into aLookahead[] using multiple calls to acttab_action(). Then the
# actions for that single state_number are placed into the aAction[]
# array with a single call to acttab_insert(). The acttab_insert() call
# also resets the aLookahead[] array in preparation for the next
# state number.
acttab = struct(
'acttab',
(
'nAction', # Number of used slots in aAction[]
'nActionAlloc', # Slots allocated for aAction[]
'aAction', # The yy_action[] table under construction
'aLookahead', # A single new transaction set
'mnLookahead', # Minimum aLookahead[].lookahead
'mnAction', # Action associated with mnLookahead
'mxLookahead', # Maximum aLookahead[].lookahead
'nLookahead', # Used slots in aLookahead[]
'nLookaheadAlloc', # Slots allocated in aLookahead[]
)
)
action = struct(
'action',
(
'lookahead', # Value of the lookahead token
'action', # Action to take on the given lookahead
)
)
def acttab_size(X):
'''Return the number of entries in the yy_action table.'''
return X.nAction
def acttab_yyaction(X, N):
'''The value for the N-th entry in yy_action.'''
return X.aAction[N].action
def acttab_yylookahead(X,N):
'''The value for the N-th entry in yy_lookahead.'''
return X.aAction[N].lookahead
def acttab_free(p):
return
def acttab_alloc():
return acttab(0, 0, [], [], 0, 0, 0, 0, 0)
def acttab_action(p, lookahead, _action):
'''Add a new action to the current transaction set.
This routine is called once for each lookahead for a particular
state.
'''
if p.nLookahead >= p.nLookaheadAlloc:
p.nLookaheadAlloc += 25
p.aLookahead.extend([action(0,0) for i in range(25)])
if p.nLookahead == 0:
p.mxLookahead = lookahead
p.mnLookahead = lookahead
p.mnAction = _action
else:
if p.mxLookahead < lookahead:
p.mxLookahead = lookahead
if p.mnLookahead > lookahead:
p.mnLookahead = lookahead
p.mnAction = _action
p.aLookahead[p.nLookahead].lookahead = lookahead
p.aLookahead[p.nLookahead].action = _action
p.nLookahead += 1
return
def acttab_insert(p):
'''Add the transaction set built up with prior calls to
acttab_action() into the current action table. Then reset the
transaction set back to an empty set in preparation for a new
round of acttab_action() calls.
Return the offset into the action table of the new transaction.
'''
assert p.nLookahead > 0
# Make sure we have enough space to hold the expanded action table
# in the worst case. The worst case occurs if the transaction set
# must be appended to the current action table.
n = p.mxLookahead + 1
if p.nAction + n >= p.nActionAlloc:
oldAlloc = p.nActionAlloc
p.nActionAlloc = p.nAction + n + p.nActionAlloc + 20
p.aAction.extend([action(-1,-1) for i in range(p.nActionAlloc - oldAlloc)])
# Scan the existing action table looking for an offset that is a
# duplicate of the current transaction set. Fall out of the loop
# if and when the duplicate is found.
#
# i is the index in p.aAction[] where p.mnLookahead is inserted.
for i in range(p.nAction - 1, -1, -1):
if p.aAction[i].lookahead == p.mnLookahead:
# All lookaheads and actions in the aLookahead[] transaction
# must match against the candidate aAction[i] entry.
if p.aAction[i].action != p.mnAction:
continue
for j in range(p.nLookahead):
k = p.aLookahead[j].lookahead - p.mnLookahead + i
if k < 0 or k >= p.nAction:
break
if p.aLookahead[j].lookahead != p.aAction[k].lookahead:
break
if p.aLookahead[j].action != p.aAction[k].action:
break
else:
# No possible lookahead value that is not in the aLookahead[]
# transaction is allowed to match aAction[i].
n = 0
for j in range(p.nAction):
if p.aAction[j].lookahead < 0:
continue
if p.aAction[j].lookahead == j + p.mnLookahead - i:
n += 1
if n == p.nLookahead:
break # An exact match is found at offset i
else:
# If no existing offsets exactly match the current transaction, find an
# an empty offset in the aAction[] table in which we can add the
# aLookahead[] transaction.
#
# Look for holes in the aAction[] table that fit the current
# aLookahead[] transaction. Leave i set to the offset of the hole.
# If no holes are found, i is left at p.nAction, wihch means the
# transaction will be appended.
for i in range(p.nActionAlloc - p.mxLookahead):
if p.aAction[i].lookahead < 0:
for j in range(p.nLookahead):
k = p.aLookahead[j].lookahead - p.mnLookahead + i
if k < 0:
break
if p.aAction[k].lookahead >= 0:
break
else:
for j in range(p.nAction):
if p.aAction[j].lookahead == j + p.mnLookahead - i:
break
else:
break # Fits in empty slots
else:
i = p.nAction
# Insert transaction set at index i.
for j in range(p.nLookahead):
k = p.aLookahead[j].lookahead - p.mnLookahead + i
p.aAction[k].lookahead = p.aLookahead[j].lookahead
p.aAction[k].action = p.aLookahead[j].action
if k >= p.nAction:
p.nAction = k + 1
p.nLookahead = 0
# Return the offset that is added to the lookahead in order to get
# the index into yy_action of the action.
return i - p.mnLookahead
| StarcoderdataPython |
3247216 | import unittest
from katas.kyu_7.every_archer_has_its_arrows import archers_ready
class ArchersReadyTestCase(unittest.TestCase):
def test_true(self):
self.assertTrue(archers_ready([5, 6, 7, 8]))
def test_false(self):
self.assertFalse(archers_ready([]))
def test_false_2(self):
self.assertFalse(archers_ready([1, 2, 3, 4]))
| StarcoderdataPython |
1698881 | <filename>DriveDownloader/netdrives/sharepoint.py
#############################################
# Author: <NAME> #
# E-mail: <EMAIL> #
# Homepage: https://github.com/hwfan #
#############################################
import urllib.parse as urlparse
from DriveDownloader.netdrives.basedrive import DriveSession
class SharePointSession(DriveSession):
def __init__(self, proxy, chunk_size=32768):
DriveSession.__init__(self, proxy, chunk_size)
def generate_url(self, url):
'''
Solution provided by:
https://www.qian.blue/archives/OneDrive-straight.html
'''
parsed_url = urlparse.urlparse(url)
path = parsed_url.path
netloc = parsed_url.netloc
splitted_path = path.split('/')
personal_attr, domain, sharelink = splitted_path[3:6]
resultUrl = f"https://{netloc}/{personal_attr}/{domain}/_layouts/52/download.aspx?share={sharelink}"
return resultUrl
def connect(self, url, custom_filename=''):
onedrive_url = self.generate_url(url)
DriveSession.connect(self, onedrive_url, download=True, custom_filename=custom_filename) | StarcoderdataPython |
3215841 | from biothings.hub.datatransform.datatransform import DataTransform
from biothings.hub.datatransform.datatransform import IDStruct
from biothings.hub.datatransform.datatransform import DataTransformEdge
from biothings.hub.datatransform.datatransform import RegExEdge
from biothings.hub.datatransform.datatransform import nested_lookup
# only for testing purpose, this one is not optimized
#from biothings.hub.datatransform.datatransform_serial import DataTransformSerial
from biothings.hub.datatransform.datatransform_mdb import DataTransformMDB
from biothings.hub.datatransform.datatransform_mdb import MongoDBEdge
# this involved biothings client dependency, skip it for now
#from biothings.hub.datatransform.datatransform_api import MyChemInfoEdge
#from biothings.hub.datatransform.datatransform_api import MyGeneInfoEdge
| StarcoderdataPython |
1614894 | <reponame>jergeno/DadBotV2.0
from collections import defaultdict
import re
import yaml
import sys
import os
import mysql.connector
import random
if "DadBot" not in str(os.getcwd()):
os.chdir("./DadBot")
with open("config.yaml") as file:
config = yaml.load(file, Loader=yaml.FullLoader)
class ImChecker:
def __init__(self):
self.imList = [" im ", " i'm ", " Im ", " I'm ", " IM ", " I'M ", " i am ", " I am ", " I AM ", " lm ", " l'm ", " lM ", " l'M ", " l am ", " l AM "]
self.confusables = Confusables('./resources/likeness.txt')
async def checkIm(self, message):
for string in self.imList:
cpattern = self.confusables.confusables_regex(string)
r = re.compile(cpattern)
fake_string = " " + message.content
res = r.match(fake_string)
rand = random.randint(0, 9)
if res and rand == 3:
typeIm = res.group().strip() + " "
await message.reply("Hi " + str(message.content).split(typeIm, 1)[1] + ", I'm Dad")
mydb = mysql.connector.connect(
host=config["dbhost"],
user=config["dbuser"],
password=config["<PASSWORD>"],
database=config["databasename"]
)
mycursor = mydb.cursor(buffered=True)
mycursor.execute("SELECT * FROM caught WHERE user = '" + str(message.author) + "'")
hascolumn = False
for m in mycursor:
hascolumn = True
if not hascolumn:
mycursor.execute("INSERT INTO caught (user, count) VALUES ('"+ str(message.author) +"', 1)")
else:
mycursor.execute("UPDATE caught SET count = count + 1 WHERE user = '" + str(message.author) + "'")
mydb.commit()
mycursor.close()
mydb.close()
break
class Confusables:
def __init__(self, confusables_filename):
f = open(confusables_filename, 'r', encoding="utf-8")
confusables_dict = defaultdict(list)
pattern = re.compile(r'(.) → (.)')
for line in f:
r = pattern.search(line)
if r:
fake = r.group(1)
auth = r.group(2)
confusables_dict[auth].append(fake)
self.confusables_dict = confusables_dict
def expand_char_to_confusables(self, c):
if c in self.confusables_dict:
return '[{}{}]'.format(re.escape(c), re.escape("".join(self.confusables_dict[c])))
else:
return c
def confusables_regex(self, pattern, letter_test_function=None):
new = ""
for c in pattern:
if ((not letter_test_function) or
(letter_test_function and letter_test_function(c))):
new += self.expand_char_to_confusables(c)
else:
new += c
return new
| StarcoderdataPython |
173148 | <filename>phoenix/tests/integration/test_datadog.py
from unittest.mock import patch
from phoenix.integration.datadog import get_all_slack_channels
@patch("phoenix.integration.datadog.api.Monitor.get_all")
def test_get_all_slack_channels(mocked_get_all):
mocked_get_all.return_value = (
"@slack-alerts{{/is_warning}}{{#is_warning_"
"recovery}}@slack-alerts{{/is_warning_recov"
"ery}}{{#is_alert}}@slack-alerts-a{{/is_alert"
"}}{{#is_alert_recovery}}@slack-alerts-test{{"
"/is_alert_recovery}}"
)
data = get_all_slack_channels()
test_data = ["alerts-test", "alerts", "alerts-a"]
assert data.sort() == test_data.sort()
| StarcoderdataPython |
33830 | <reponame>DiegoDBLe/Python-Linkedin
#
# Escrevendo arquivos com funções do Python
#
def escreveArquivo():
arquivo = open('NovoArquivo.txt', 'w+')
arquivo.write('Linha gerada com a função Escrevendo Arquivo \r\n')
arquivo.close()
#escreveArquivo()]
def alteraArquivo():
arquivo = open('NovoArquivo.txt', 'a+') # a de append que dizer escreva nas proximas linhas do arquivo
arquivo.write('Linha gerada com a função Altera Arquivo \r\n')
arquivo.close()
alteraArquivo()
| StarcoderdataPython |
51389 | from __future__ import absolute_import, unicode_literals
import logging
from django import forms
from django.core.exceptions import PermissionDenied
from django.utils.translation import ugettext_lazy as _
from acls.models import AccessEntry
from permissions.models import Permission
from .models import Folder
from .permissions import PERMISSION_FOLDER_VIEW
logger = logging.getLogger(__name__)
class FolderForm(forms.ModelForm):
class Meta:
model = Folder
fields = ('title',)
class FolderListForm(forms.Form):
def __init__(self, *args, **kwargs):
user = kwargs.pop('user', None)
logger.debug('user: %s', user)
super(FolderListForm, self).__init__(*args, **kwargs)
queryset = Folder.objects.all()
try:
Permission.objects.check_permissions(user, [PERMISSION_FOLDER_VIEW])
except PermissionDenied:
queryset = AccessEntry.objects.filter_objects_by_access(PERMISSION_FOLDER_VIEW, user, queryset)
self.fields['folder'] = forms.ModelChoiceField(
queryset=queryset,
label=_('Folder'))
| StarcoderdataPython |
135474 | #!/usr/bin/python3
# -*- coding: utf-8 -*-
# continuously publish VE.Direct data to the topic prefix specified
import argparse, os
import paho.mqtt.client as mqtt
from vedirect import VEDirect
import logging
log = logging.getLogger(__name__)
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Process VE.Direct protocol')
parser.add_argument('--port', help='Serial port')
parser.add_argument('--timeout', help='Serial port read timeout', type=int, default='60')
parser.add_argument('--mqttbroker', help='MQTT broker address', type=str, default='test.mosquitto.org')
parser.add_argument('--mqttbrokerport', help='MQTT broker port', type=int, default='1883')
parser.add_argument('--topicprefix', help='MQTT topic prefix', type=str, default='vedirect_device/')
parser.add_argument('--emulate', help='emulate one of [ALL, BMV_600, BMV_700, MPPT, PHX_INVERTER]',
default='', type=str)
parser.add_argument('--loglevel', help='logging level - one of [DEBUG, INFO, WARNING, ERROR, CRITICAL]',
default='ERROR')
args = parser.parse_args()
logging.basicConfig(level=args.loglevel.upper())
ve = VEDirect(args.port, args.timeout, args.emulate)
client = mqtt.Client()
client.connect(args.mqttbroker, args.mqttbrokerport, 60)
client.loop_start()
def mqtt_send_callback(packet):
for key, value in packet.items():
if key != 'SER#': # topic cannot contain MQTT wildcards
log.info(f"{args.topicprefix + key}: {value}")
client.publish(args.topicprefix + key, value)
ve.read_data_callback(mqtt_send_callback)
| StarcoderdataPython |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.