content
stringlengths 5
1.05M
|
|---|
#coding=utf-8
from util.read_ini import ReadIni
class FindElement(object):
def __init__(self,driver):
self.driver = driver
def get_element(self,key):
read_ini = ReadIni()
value = read_ini.get_value(key)
try:
return self.driver.find_element_by_xpath(value)
except:
return None
def my_get_element(driver, key):
"""定位element"""
find_element = FindElement(driver)
element = find_element.get_element(key)
return element |
# coding=utf-8
import datetime
import json
import os
import time
import analyze
import search
import utils
'''
主要思路：
1. 答题时使用adb截图并将图片pull到本机
2. 通过ocr图片识别题目
3. 百度题目
4. 百度后结果与选项做匹配，匹配度最高的即为推荐答案
注： 部分题目由于识别或题目本身无法问题，可能搜索不到答案或推荐有误差，需自己根据题目情况进行抉择
'''
question_sleep_time = 10
default_search_engine = 'www.baidu.com'
# 获取配置文件
def get_config():
config_file = 'config.json'
if os.path.exists(config_file):
with open(config_file, 'r') as f:
return json.load(f)
else:
print('请检查根目录下是否存在配置文件 config.json')
exit(-1)
def main():
config = get_config()
is_auto = config['auto']
is_baidu_ocr = config['baidu_ocr']
is_debug = config['debug']
is_ios = config['is_ios']
size = utils.check_os(is_ios)
baidu_ocr_clint = None
if is_baidu_ocr:
baidu_cor_config = config['baidu_ocr_config']
baidu_ocr_clint = utils.init_baidu_ocr(baidu_cor_config)
pixel_json = utils.get_pixel_config(size)
blank_area = pixel_json['blank_area']
question_area = pixel_json['question_area']
blank_area_point = blank_area['x1'], blank_area['y1'], blank_area['x2'], blank_area['y2']
question_area_point = question_area['x1'], question_area['y1'], question_area['x2'], question_area['y2']
question_num = 0
crop_img_name = 'image/crop.png'
while True:
while True:
print('开始答题')
img = analyze.tell_and_get_image(is_auto, blank_area_point, is_ios)
if img is not None:
question_num += 1
break
else: # 若不是答题页
if not is_auto:
print('没有发现题目页面')
exit(-1)
print('没有发现答题页面，继续')
time.sleep(1) # 不是题目页面，休眠0.8秒后继续判断
# 获取题目及选项
print('发现题目')
start = datetime.datetime.now() # 记录开始时间
crop_obj = utils.crop_image(img, question_area_point, crop_img_name)
question, option_arr, is_negative = analyze.image_to_str(crop_obj, is_baidu_ocr, baidu_ocr_clint) # 图片转文字
print('搜索的题目是：{} '.format(question))
print('选项为：{} '.format(option_arr))
if question is None or question == '':
print('没有识别题目')
continue
result_list = search.search(question, option_arr, is_negative) # 搜索结果
if result_list is None:
print('\n没有答案')
else:
print('最佳答案是： \033[1;31m{}\033[0m'.format(result_list))
run_time = (datetime.datetime.now() - start).seconds
print('本次运行时间为：{}秒'.format(run_time))
crop_img = crop_obj[0]
if is_debug:
img.save('image/question_{}.png'.format(question_num))
crop_img.save('image/question_crop_{}.png'.format(question_num))
crop_img.close()
img.close()
if is_auto:
print('休息：{}秒后继续'.format(question_sleep_time))
time.sleep(question_sleep_time) # 每一道题结束，休息10秒
else:
break
if __name__ == '__main__':
main()
|
__all__ = [
"LemmInflect"
]
from .module import Module
from pyinflect import getInflection
# https://github.com/bjascob/pyInflect
class PyInflect(Module):
# START OF NOUN
# Conversions
def noun_to_singular(self, term: str, *args, **kwargs) -> str:
o = getInflection(term, tag="NN")
if o:
return o[0]
return None
def noun_to_plural(self, term: str, *args, **kwargs) -> str:
o = getInflection(term, tag="NNS")
if o:
return o[0]
return None
def noun_to_classical_plural(self, term: str, *args, **kwargs) -> str:
o = getInflection(term, tag="NNS")
if o:
return o[-1]
return None
# Checking
def noun_is_singular(self, term: str, *args, **kwargs) -> bool:
raise NotImplementedError()
def noun_is_plural(self, term: str, *args, **kwargs) -> bool:
raise NotImplementedError()
# END OF NOUN
# START OF VERB
# Conversions
def verb_to_singular(self, term: str, *args, **kwargs) -> str:
o = getInflection(term, tag="VBZ")
if o:
return o[0]
return None
def verb_to_plural(self, term: str, *args, **kwargs) -> str:
o = getInflection(term, tag="VB")
if o:
return o[0]
return None
def verb_to_pret(self, term: str, *args, **kwargs) -> str:
o = getInflection(term, tag="VBD")
if o:
return o[0]
return None
def verb_to_past_part(self, term: str, *args, **kwargs) -> str:
o = getInflection(term, tag="VBN")
if o:
return o[0]
return None
def verb_to_pres_part(self, term: str, *args, **kwargs) -> str:
o = getInflection(term, tag="VBG")
if o:
return o[0]
return None
# Checking
def verb_is_singular(self, term: str, *args, **kwargs) -> bool:
raise NotImplementedError()
def verb_is_plural(self, term: str, *args, **kwargs) -> bool:
raise NotImplementedError()
def verb_is_pret(self, term: str, *args, **kwargs) -> str:
raise NotImplementedError()
def verb_is_past_part(self, term: str, *args, **kwargs) -> str:
raise NotImplementedError()
def verb_is_pres_part(self, term: str, *args, **kwargs) -> str:
raise NotImplementedError()
# END OF VERB
# START OF ADJECTIVE
# Conversions
def adj_to_singular(self, term: str, *args, **kwargs) -> str:
raise NotImplementedError()
def adj_to_plural(self, term: str, *args, **kwargs) -> str:
raise NotImplementedError()
# Checking
def adj_is_singular(self, term: str, *args, **kwargs) -> bool:
raise NotImplementedError()
def adj_is_plural(self, term: str, *args, **kwargs) -> bool:
raise NotImplementedError()
def adj_to_comparative(self, term: str, *args, **kwargs) -> str:
o = getInflection(term, tag="JJR")
if o:
return o[0]
return None
def adj_to_superlative(self, term: str, *args, **kwargs) -> str:
o = getInflection(term, tag="JJS")
if o:
return o[0]
return None
# END OF ADJECTIVE
|
from __future__ import print_function, division
from future.utils import iteritems
from builtins import range, input
# Note: you may need to update your version of future
# sudo pip install -U future
import numpy as np
import matplotlib.pyplot as plt
# generate unlabeled data
N = 2000
X = np.random.random((N, 2))*2 - 1
# generate labels
Y = np.zeros(N)
Y[(X[:,0] < 0) & (X[:,1] > 0)] = 1
Y[(X[:,0] > 0) & (X[:,1] < 0)] = 1
# plot it
plt.scatter(X[:,0], X[:,1], c=Y)
plt.show() |
from fdrtd.plugins.simon.accumulators.accumulator import Accumulator
class AccumulatorStatisticsFrequency(Accumulator):
def __init__(self, _=None):
self.samples = 0
self.histogram = {}
self.mode = None
def serialize(self):
return {'samples': self.samples,
'mode': self.mode,
'histogram': self.histogram}
@staticmethod
def deserialize(dictionary):
accumulator = AccumulatorStatisticsFrequency()
accumulator.samples = dictionary['samples']
accumulator.mode = dictionary['mode']
accumulator.histogram = dictionary['histogram']
return accumulator
def add(self, other):
self.samples += other.samples
for item in other.histogram:
self.histogram[item] = self.histogram.get(item, 0) + other.histogram[item]
def update(self, key, value=1):
self.samples = self.samples + value
self.histogram[key] = self.histogram.get(key, 0) + value
def finalize(self):
maximum = 0
for item in self.histogram:
if self.histogram[item] > maximum:
maximum = self.histogram[item]
self.mode = item
def get_histogram(self):
return self.histogram
def get_samples(self):
return self.samples
def get_mode(self):
return self.mode
|
# Generated by Django 3.0 on 2020-05-11 16:27
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('asper', '0007_auto_20200511_2115'),
]
operations = [
migrations.DeleteModel(
name='Category',
),
]
|
__version__ = "1.0.0"
PROMETHEUS_NAMESPACE = "scribe"
|
# Generated by Django 3.0.3 on 2020-03-28 20:08
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('pages', '0002_auto_20200328_2247'),
]
operations = [
migrations.AlterField(
model_name='customer',
name='mobile',
field=models.CharField(max_length=15),
),
migrations.AlterField(
model_name='customer',
name='number',
field=models.CharField(max_length=20),
),
]
|
import gzip
import json
from pathlib import Path
from typing import Union, Any, Dict, List, NamedTuple
def load_one_assertion_file(filename: Union[str, Path]) -> List[Dict[str, Any]]:
assertions = []
with gzip.open(filename, "rt") as f:
for line in f:
assertions.append(json.loads(line))
return assertions
class AssertionId(NamedTuple):
c4_id: int
part_id: int
asst_id: int
def __str__(self):
return f"{self.c4_id:05d}-{self.part_id:03d}-{self.asst_id:07d}"
def convert_id(aid: str) -> AssertionId:
toks = aid.split("-")
assert len(toks) == 3
assert len(toks[0]) == 5
assert len(toks[1]) == 3
assert len(toks[2]) == 7
c4_id = int(toks[0])
part_id = int(toks[1])
asst_id = int(toks[2])
assert 0 <= c4_id < 1024
assert 0 <= part_id < 64
assert asst_id >= 0
return AssertionId(c4_id=c4_id, part_id=part_id, asst_id=asst_id)
|
# Generated by Django 3.2.6 on 2021-08-13 03:54
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
('merchants', '0001_initial'),
('employees', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Transactions',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('debit', models.BooleanField()),
('credit', models.BooleanField()),
('amount', models.FloatField()),
('updated', models.DateTimeField(auto_now=True)),
('timestamp', models.DateTimeField(auto_now_add=True)),
('merchant', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='merchants.merchants')),
('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='employees.employees')),
],
),
]
|
# Programa que cria uma Progressão Aritmética com base em inputs do usuário
print('Vamos descobrir qual os 10 primeiros termos de uma progressão geométrica?')
primeiro = abs(int(input('Digite o primeiro termo da PA: ')))
razao = abs(int(input('Digite a razão da PA: ')))
decimo = primeiro + 10 * razao # fórmula para cacular o enésimo termo de uma PA, no caso o décimo.
for elemento in range(primeiro, decimo, razao):
print(elemento, end=' ')
print('ACABOU!')
# fim do programa |
from kivy.app import App
from kivy.uix.label import Label
from kivy.uix.gridlayout import GridLayout
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button
import requests
url = 'https://api.thingspeak.com/channels/1211372/feeds.json?api_key=8ZPLECEO2HMX8JFV&results=2'
r = requests.get(url)
class MySearch(GridLayout):
def __init__(self, **kwargs):
super(MySearch, self).__init__(**kwargs)
self.cols = 1
self.inside = GridLayout()
self.inside.cols = 2
self.inside.add_widget(Label(text='Temperatura', font_size=25))
self.temperatura = TextInput(text='0', font_size=20, multiline=True)
self.inside.add_widget(self.temperatura)
self.inside.add_widget(Label(text='Umidade', font_size=25))
self.umidade = TextInput(text='0', font_size=20, multiline=True)
self.inside.add_widget(self.umidade)
self.add_widget(self.inside)
self.buscar = Button(text="Buscar", font_size=50, size_hint=(.2, .5))
self.buscar.bind(on_press=self.pressionar) # Ignorar erro
self.add_widget(self.buscar)
def pressionar(self, instance):
# Transformando data em um dicionário
data = r.json()
print(data)
feeds = data['feeds']
print(feeds[-1]['field2'])
self.temperatura.text = str(feeds[-1]['field1'])
self.umidade.text = str(feeds[-1]['field2'])
class SearchThingSpeak(App):
def build(self):
return MySearch()
SearchThingSpeak().run()
|
from datetime import datetime
from config import db
class Users(db.Model):
'__users__'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.TEXT(80))
username = db.Column(db.TEXT(80), unique=True)
email = db.Column(db.TEXT(120), unique=True)
password = db.Column(db.TEXT(120))
comments = db.relationship('Comments', backref='users', lazy='dynamic')
@staticmethod
def get_comments():
return Comments.query.filter_by(user_id=users.id).order_by(Comments.timestamp.desc())
def __init__(self, name, username, email, password):
self.name = name
self.username = username
self.email = email
self.password = password
def __repr__(self):
return '<Users {}'.format(self.username)
class Videos(db.Model):
'__videos__'
id = db.Column(db.Integer, primary_key=True, autoincrement=True, unique=True)
title = db.Column(db.TEXT, unique=True)
link = db.Column(db.String)
author = db.Column(db.TEXT)
# likes = db.Column(db.Integer)
create_date = db.Column(db.TIMESTAMP, default=datetime.now)
comments = db.relationship('Comments', backref='videos', lazy='dynamic')
# @staticmethod
# def like_video():
# Videos.likes += 1
# @staticmethod
# def dislike_video():
# Videos.likes -= 1
@staticmethod
def get_comments():
return Comments.query.filter_by(video_id=Videos.id).order_by(Comments.timestamp.desc())
def __init__(self, title, link, author):
self.title = title
self.link = link
self.author = author
def __repr__(self):
return '<Videos {}>'.format(self.title)
class Comments(db.Model):
'__comments__'
id = db.Column(db.Integer, primary_key=True, autoincrement=True, unique=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.TIMESTAMP, default=datetime.now)
video_id = db.Column(db.Integer, db.ForeignKey('videos.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, body, video_id, user_id):
self.body = body
self.video_id = video_id
self.user_id = user_id
def __repr__(self):
return 'Comments {}>'.format(self.body)
|
from typing import Any
from discord.ext import commands
from uec22.role_panel.role_panel import RolePanelView
async def set_board(bot: commands.Bot, panel: dict[Any, Any]) -> None:
_guild = await bot.fetch_guild(int(panel["guild_id"]))
_roles = []
panel_length = confirm_panel_length(panel)
for num in range(panel_length):
_role_id = panel[f"role_{num+1}"]
if _role_id == "":
continue
_role = _guild.get_role(int(panel[f"role_{num+1}"]))
if _role is not None:
_roles.append(_role)
else:
continue
bot.add_view(RolePanelView(roles=_roles), message_id=int(panel["message_id"]))
def confirm_panel_length(dict: dict):
return len({k: v for k, v in dict.items() if k.startswith("role_")})
|
import tensorflow as tf
import numpy as np
import os
import time
def get_timestamp(name):
timestamp = time.asctime().replace(" ", "_").replace(":", "_")
unique_name = f"{name}_at_{timestamp}"
return unique_name
def get_callbacks(config, x_train):
logs = config['logs']
unique_dir_name = get_timestamp("tb_logs")
tensorboard_root_log_dir = os.path.join(logs['logs_dir'], logs['tensorboard_root_log_dir'], unique_dir_name)
os.makedirs(tensorboard_root_log_dir, exist_ok=True)
tensorboard_cb = tf.keras.callbacks.TensorBoard(log_dir=tensorboard_root_log_dir)
file_writer = tf.summary.create_file_writer(logdir=tensorboard_root_log_dir)
with file_writer.as_default():
images = np.reshape(x_train[10:30], (-1, 28, 28, 1))
tf.summary.image("20 Handwritten digit samples", images, max_outputs=25, step=0)
early_stopping_cb = tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True)
checkpt_dir = os.path.join(config['artifacts']['artifacts_dir'], config['artifacts']['checkpoint_dir'])
os.makedirs(checkpt_dir, exist_ok=True)
checkpt_path = os.path.join(checkpt_dir, "model_checkpt.h5")
checkpointing_cb = tf.keras.callbacks.ModelCheckpoint(checkpt_path, save_best_weights_only=True)
return [tensorboard_cb, early_stopping_cb, checkpointing_cb]
|
# -*- coding: utf-8 -*-
#!/usr/bin/python
import sys
import os
import cv2 as cv
import numpy as np
def main():
print('\nDeeptextdetection.py')
print(' A demo script of text box alogorithm of the paper:')
print(' * Minghui Liao et al.: TextBoxes: A Fast Text Detector with a Single Deep Neural Network https://arxiv.org/abs/1611.06779\n')
if (len(sys.argv) < 2):
print(' (ERROR) You must call this script with an argument (path_to_image_to_be_processed)\n')
quit()
if not os.path.isfile('TextBoxes_icdar13.caffemodel') or not os.path.isfile('textbox.prototxt'):
print " Model files not found in current directory. Aborting"
print " See the documentation of text::TextDetectorCNN class to get download links."
quit()
img = cv.imread(str(sys.argv[1]))
textSpotter = cv.text.TextDetectorCNN_create("textbox.prototxt", "TextBoxes_icdar13.caffemodel")
rects, outProbs = textSpotter.detect(img);
vis = img.copy()
thres = 0.6
for r in range(np.shape(rects)[0]):
if outProbs[r] > thres:
rect = rects[r]
cv.rectangle(vis, (rect[0],rect[1]), (rect[0] + rect[2], rect[1] + rect[3]), (255, 0, 0), 2)
cv.imshow("Text detection result", vis)
cv.waitKey()
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: file_create.proto
"""Generated protocol buffer code."""
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobuf import reflection as _reflection
from google.protobuf import symbol_database as _symbol_database
# @@protoc_insertion_point(imports)
_sym_db = _symbol_database.Default()
import basic_types_pb2 as basic__types__pb2
import timestamp_pb2 as timestamp__pb2
DESCRIPTOR = _descriptor.FileDescriptor(
name='file_create.proto',
package='proto',
syntax='proto3',
serialized_options=b'\n\"com.hederahashgraph.api.proto.javaP\001',
create_key=_descriptor._internal_create_key,
serialized_pb=b'\n\x11\x66ile_create.proto\x12\x05proto\x1a\x11\x62\x61sic_types.proto\x1a\x0ftimestamp.proto\"\xeb\x01\n\x19\x46ileCreateTransactionBody\x12(\n\x0e\x65xpirationTime\x18\x02 \x01(\x0b\x32\x10.proto.Timestamp\x12\x1c\n\x04keys\x18\x03 \x01(\x0b\x32\x0e.proto.KeyList\x12\x10\n\x08\x63ontents\x18\x04 \x01(\x0c\x12\x1f\n\x07shardID\x18\x05 \x01(\x0b\x32\x0e.proto.ShardID\x12\x1f\n\x07realmID\x18\x06 \x01(\x0b\x32\x0e.proto.RealmID\x12$\n\x10newRealmAdminKey\x18\x07 \x01(\x0b\x32\n.proto.Key\x12\x0c\n\x04memo\x18\x08 \x01(\tB&\n\"com.hederahashgraph.api.proto.javaP\x01\x62\x06proto3'
,
dependencies=[basic__types__pb2.DESCRIPTOR,timestamp__pb2.DESCRIPTOR,])
_FILECREATETRANSACTIONBODY = _descriptor.Descriptor(
name='FileCreateTransactionBody',
full_name='proto.FileCreateTransactionBody',
filename=None,
file=DESCRIPTOR,
containing_type=None,
create_key=_descriptor._internal_create_key,
fields=[
_descriptor.FieldDescriptor(
name='expirationTime', full_name='proto.FileCreateTransactionBody.expirationTime', index=0,
number=2, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
_descriptor.FieldDescriptor(
name='keys', full_name='proto.FileCreateTransactionBody.keys', index=1,
number=3, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
_descriptor.FieldDescriptor(
name='contents', full_name='proto.FileCreateTransactionBody.contents', index=2,
number=4, type=12, cpp_type=9, label=1,
has_default_value=False, default_value=b"",
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
_descriptor.FieldDescriptor(
name='shardID', full_name='proto.FileCreateTransactionBody.shardID', index=3,
number=5, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
_descriptor.FieldDescriptor(
name='realmID', full_name='proto.FileCreateTransactionBody.realmID', index=4,
number=6, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
_descriptor.FieldDescriptor(
name='newRealmAdminKey', full_name='proto.FileCreateTransactionBody.newRealmAdminKey', index=5,
number=7, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
_descriptor.FieldDescriptor(
name='memo', full_name='proto.FileCreateTransactionBody.memo', index=6,
number=8, type=9, cpp_type=9, label=1,
has_default_value=False, default_value=b"".decode('utf-8'),
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key),
],
extensions=[
],
nested_types=[],
enum_types=[
],
serialized_options=None,
is_extendable=False,
syntax='proto3',
extension_ranges=[],
oneofs=[
],
serialized_start=65,
serialized_end=300,
)
_FILECREATETRANSACTIONBODY.fields_by_name['expirationTime'].message_type = timestamp__pb2._TIMESTAMP
_FILECREATETRANSACTIONBODY.fields_by_name['keys'].message_type = basic__types__pb2._KEYLIST
_FILECREATETRANSACTIONBODY.fields_by_name['shardID'].message_type = basic__types__pb2._SHARDID
_FILECREATETRANSACTIONBODY.fields_by_name['realmID'].message_type = basic__types__pb2._REALMID
_FILECREATETRANSACTIONBODY.fields_by_name['newRealmAdminKey'].message_type = basic__types__pb2._KEY
DESCRIPTOR.message_types_by_name['FileCreateTransactionBody'] = _FILECREATETRANSACTIONBODY
_sym_db.RegisterFileDescriptor(DESCRIPTOR)
FileCreateTransactionBody = _reflection.GeneratedProtocolMessageType('FileCreateTransactionBody', (_message.Message,), {
'DESCRIPTOR' : _FILECREATETRANSACTIONBODY,
'__module__' : 'file_create_pb2'
# @@protoc_insertion_point(class_scope:proto.FileCreateTransactionBody)
})
_sym_db.RegisterMessage(FileCreateTransactionBody)
DESCRIPTOR._options = None
# @@protoc_insertion_point(module_scope)
|
from django.contrib import admin
from .models import Image,Profile,tags,Comment
# Register your models here.
admin.site.register(Image)
admin.site.register(Profile)
admin.site.register(tags)
admin.site.register(Comment)
|
from pycule import MCuleWrapper
import os
from ..utils import canonSmiles
class MCuleAPI(object):
"""
Creates an MCuleAPI object for calling Mcule API
"""
def __init__(self):
"""
MCule API constructor
"""
self.mculewrapper = MCuleWrapper(
authorisation_token=os.environ["MCULE_API_KEY"]
)
def getMCuleInfo(self, smiles: str):
"""
Get compound info from Mcule
Args:
smiles (str): SMILES string of compound to search MCule DB for
Returns:
mculeid: MCule ID for compound
mculeurl: MCule url for compound
None: If no inof is found, returns None
"""
try:
response_dict = self.mculewrapper.singlequerysearch(query=smiles)
results = response_dict["response"]["results"]
if results:
mculeid = results[0]["mcule_id"]
mculeurl = results[0]["url"]
return mculeid, mculeurl
except Exception as e:
try:
response_dict = self.mculewrapper.similaritysearch(
query=smiles, limit=1, threshold=0.7
)
print(smiles)
print(response_dict)
results = response_dict["response"]["results"]
if results:
smiles_test = canonSmiles(results[0]["smiles"])
print(smiles_test)
if smiles_test == smiles:
mculeid = results[0]["mcule_id"]
mculeurl = results[0]["url"]
return mculeid, mculeurl
else:
return None
except Exception as e:
print(e)
return None
def getMCulePrice(self, mculeid: str, amount: float):
"""
Get compound pricing info from Mcule for 1, 5 and 10 mg amounts
Args:
mculeid (str): MCule ID for compound
amount (floatt): Amount required
Returns:
price: MCule price in USD for comppound and amount set in iput argument
"""
if amount < 1:
amount = 1
try:
response_dict = self.mculewrapper.compoundpricesamount(
mcule_id=mculeid, amount=amount
)
price_info = response_dict["response"]["best_prices"][0]
if price_info:
price = price_info["price"]
deliverytime = price_info["delivery_time_working_days"]
return price, deliverytime
except Exception as e:
print(e)
print(response_dict)
return None
def getTotalQuote(
self,
mculeids: list,
amount: float = 1,
delivery_country: str = "GB",
target_volume: float = None,
target_cc: float = None,
):
"""
Get quote from MCule for list of mcule ids
Args:
mculeids (list): List of MCule IDs
amount (float): Amount per compound for quote
delivery_country (str): ISO 3166-1 alpha-2 code of the delivery country. Default GB
target_volume (float): Total volume in ml requested. Default None
target_cc (float): Target concentration in mM. Default None
Returns:
quote (dict): MCule quote info as a dictionary
"""
quote_info = {}
try:
response_dict = self.mculewrapper.quoterequest(
mcule_ids=mculeids,
delivery_country=delivery_country,
amount=amount,
)
quote_id = response_dict["response"]["id"]
quote_state_response = self.mculewrapper.quoterequeststatus(
quote_id=quote_id
)
quote_state = quote_state_response["response"]["state"]
while quote_state != 30:
if quote_state == 40:
return None
else:
quote_state_response = self.mculewrapper.quoterequeststatus(
quote_id=quote_id
)
quote_state = quote_state_response["response"]["state"]
quote_info["quoteid"] = quote_state_response["response"]["group"]["quotes"][
0
]["id"]
quote_info["quoteurl"] = quote_state_response["response"]["group"][
"quotes"
][0]["site_url"]
quote_info["quotecost"] = quote_state_response["response"]["group"][
"quotes"
][0]["total_cost"]
quote_info["quotevaliduntil"] = quote_state_response["response"]["group"][
"quotes"
][0]["valid_until"]
return quote_info
except Exception as e:
print(e)
|
from datasets.general_dataset import *
|
import time
from threading import Thread, Event
import socket
import cv2
import pickle
import struct
from detection import Obj_Detection
"""
COPYRIGHT @ Grebtsew 2019
TfServer recieves a couple of connections, reads images from incomming streams
and send detections to the QtServer
"""
QtServer_address= [["127.0.0.1",8081]]
class TfServer(Thread):
HOST = '127.0.0.1' # Standard loopback interface address (localhost)
PORT = 8585 # Port to listen on (non-privileged ports are > 1023)
def __init__(self):
super(TfServer, self).__init__()
print("Tensorflow Server started at ", self.HOST, self.PORT)
# Start detections
self.tf_thread = Obj_Detection()
# Setup output socket
print("Tensorflow Server try connecting to Qt Server ", QtServer_address[0][0],QtServer_address[0][1])
self.outSocket = socket.socket()
self.outSocket.connect((QtServer_address[0][0],QtServer_address[0][1]))
print("SUCCESS : Tensorflow Server successfully connected to Qt Server!", )
def handle_connection(self, conn):
with conn:
data = b""
payload_size = struct.calcsize(">L")
while True:
# Recieve image package size
while len(data) < payload_size:
#print("Recv: {}".format(len(data)))
data += conn.recv(4096)
packed_msg_size = data[:payload_size]
data = data[payload_size:]
msg_size = struct.unpack(">L", packed_msg_size)[0]
#print("msg_size: {}".format(msg_size))
# Recieve image
while len(data) < msg_size:
data += conn.recv(4096)
frame_data = data[:msg_size]
data = data[msg_size:]
# Decode image
frame=pickle.loads(frame_data, fix_imports=True, encoding="bytes")
frame = cv2.imdecode(frame, cv2.IMREAD_COLOR)
# do detetions
self.tf_thread.frame = frame
self.tf_thread.run_async()
detect_res = self.tf_thread.get_result()
# send detection result to QtServer
if detect_res is not None:
self.send(detect_res)
def send(self, data):
self.outSocket.sendall(pickle.dumps(data))
def run(self):
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as inSocket:
inSocket.bind((self.HOST, self.PORT))
inSocket.listen()
while True:
conn, addr = inSocket.accept()
Thread(target=self.handle_connection, args=(conn,)).start()
if __name__ == '__main__':
tfserver = TfServer().start()
|
import unittest
import numpy as np
from blmath.geometry import Polyline
class TestPolyline(unittest.TestCase):
def test_edges(self):
v = np.array([
[0., 0., 0.],
[1., 0., 0.],
[1., 1., 0.],
[1., 2., 0.],
[1., 3., 0.],
])
expected_open = np.array([
[0, 1],
[1, 2],
[2, 3],
[3, 4],
])
np.testing.assert_array_equal(Polyline(v).e, expected_open)
expected_closed = np.array([
[0, 1],
[1, 2],
[2, 3],
[3, 4],
[4, 0],
])
np.testing.assert_array_equal(Polyline(v, closed=True).e, expected_closed)
def test_length_of_empty_polyline(self):
polyline = Polyline(None)
self.assertEqual(polyline.total_length, 0)
polyline = Polyline(None, closed=True)
self.assertEqual(polyline.total_length, 0)
def test_partition_by_length_noop(self):
original = Polyline(np.array([
[0., 0., 0.],
[1., 0., 0.],
[1., 1., 0.],
[1., 2., 0.],
[1., 3., 0.],
]))
result = original.copy()
indices = result.partition_by_length(1., ret_indices=True)
expected_indices = np.array([0, 1, 2, 3, 4])
np.testing.assert_array_almost_equal(result.v, original.v)
np.testing.assert_array_equal(result.e, original.e)
np.testing.assert_array_equal(indices, expected_indices)
def test_partition_by_length_degenerate(self):
'''
This covers a bug that arose from a numerical stability issue in
measurement on EC2 / MKL.
'''
original = Polyline(np.array([
[0., 0., 0.],
[1., 0., 0.],
[1., 0., 0.],
]))
result = original.copy()
indices = result.partition_by_length(1., ret_indices=True)
expected_indices = np.array([0, 1, 2])
np.testing.assert_array_almost_equal(result.v, original.v)
np.testing.assert_array_equal(result.e, original.e)
np.testing.assert_array_equal(indices, expected_indices)
def test_partition_by_length_divide_by_two(self):
original = Polyline(np.array([
[0., 0., 0.],
[1., 0., 0.],
[1., 1., 0.],
[1., 2., 0.],
[1., 3., 0.],
]))
expected = Polyline(np.array([
[0., 0., 0.],
[0.5, 0., 0.],
[1., 0., 0.],
[1., 0.5, 0.],
[1., 1., 0.],
[1., 1.5, 0.],
[1., 2., 0.],
[1., 2.5, 0.],
[1., 3., 0.],
]))
expected_indices = np.array([0, 2, 4, 6, 8])
for max_length in (0.99, 0.75, 0.5):
result = original.copy()
indices = result.partition_by_length(max_length, ret_indices=True)
np.testing.assert_array_almost_equal(result.v, expected.v)
np.testing.assert_array_equal(result.e, expected.e)
np.testing.assert_array_equal(indices, expected_indices)
def test_partition_length_divide_by_five(self):
original = Polyline(np.array([
[0., 0., 0.],
[1., 0., 0.],
[1., 1., 0.],
[1., 2., 0.],
[1., 3., 0.],
]))
expected = Polyline(np.array([
[0., 0., 0.],
[0.2, 0., 0.],
[0.4, 0., 0.],
[0.6, 0., 0.],
[0.8, 0., 0.],
[1., 0., 0.],
[1., 0.2, 0.],
[1., 0.4, 0.],
[1., 0.6, 0.],
[1., 0.8, 0.],
[1., 1., 0.],
[1., 1.2, 0.],
[1., 1.4, 0.],
[1., 1.6, 0.],
[1., 1.8, 0.],
[1., 2., 0.],
[1., 2.2, 0.],
[1., 2.4, 0.],
[1., 2.6, 0.],
[1., 2.8, 0.],
[1., 3., 0.],
]))
expected_indices = np.array([0, 5, 10, 15, 20])
for max_length in (0.2, 0.24):
result = original.copy()
indices = result.partition_by_length(max_length, ret_indices=True)
np.testing.assert_array_almost_equal(result.v, expected.v)
np.testing.assert_array_equal(result.e, expected.e)
np.testing.assert_array_equal(indices, expected_indices)
def test_partition_by_length_divide_some_leave_some(self):
original = Polyline(np.array([
[0., 0., 0.],
[1., 0., 0.],
[1., 1., 0.],
[1., 7., 0.],
[1., 8., 0.],
]))
expected = Polyline(np.array([
[0., 0., 0.],
[1., 0., 0.],
[1., 1., 0.],
[1., 3., 0.],
[1., 5., 0.],
[1., 7., 0.],
[1., 8., 0.],
]))
expected_indices = np.array([0, 1, 2, 5, 6])
for max_length in (2., 2.99):
result = original.copy()
indices = result.partition_by_length(max_length, ret_indices=True)
np.testing.assert_array_almost_equal(result.v, expected.v)
np.testing.assert_array_equal(result.e, expected.e)
np.testing.assert_array_equal(indices, expected_indices)
def test_partition_by_length_closed(self):
original = Polyline(np.array([
[0., 0., 0.],
[1., 0., 0.],
[1., 1., 0.],
[1., 7., 0.],
[1., 8., 0.],
[0., 8., 0.],
]), closed=True)
expected = Polyline(np.array([
[0., 0., 0.],
[1., 0., 0.],
[1., 1., 0.],
[1., 3., 0.],
[1., 5., 0.],
[1., 7., 0.],
[1., 8., 0.],
[0., 8., 0.],
[0., 6., 0.],
[0., 4., 0.],
[0., 2., 0.],
]), closed=True)
expected_indices = np.array([0, 1, 2, 5, 6, 7])
for max_length in (2., 2.5, 2.6):
result = original.copy()
indices = result.partition_by_length(max_length, ret_indices=True)
np.testing.assert_array_almost_equal(result.v, expected.v)
np.testing.assert_array_equal(result.e, expected.e)
np.testing.assert_array_equal(indices, expected_indices)
|
# -*- coding: utf-8 -*-
"""
Created on Wed Oct 16
Keras Implementation of Deep Multiple Graph Convolution Neural Network (DMGCN) model in:
Hu Yang, Wei Pan, Zhong Zhuang.
@author: Hu Yang ([email protected])
"""
from keras.layers import Layer
from keras import activations, initializers, constraints
from keras import regularizers
import keras.backend as K
import tensorflow as tf
class GCN(Layer):
def __init__(self, output_dim, graphs,
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None, **kwargs):
if 'input_shape' not in kwargs and 'input_dim' in kwargs:
kwargs['input_shape'] = (kwargs.pop('input_dim'),)
self.graphs = graphs
self.output_dim = output_dim
self.activation = activations.get(activation)
self.use_bias = use_bias
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.supports_masking = True
super(GCN, self).__init__(**kwargs)
def build(self, input_shape):
# Create a trainable weight variable for this layer.
self.kernel = self.add_weight(name='kernel',
shape=(input_shape[1], self.output_dim),
initializer='uniform',
trainable=True)
if self.use_bias:
self.bias = self.add_weight(shape=(self.output_dim,),
initializer=self.bias_initializer,
name='bias',
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
else:
self.bias = None
super(GCN, self).build(input_shape)
def call(self, x):
xl = tf.matmul(tf.cast(x,tf.float32), tf.cast(self.graphs,tf.float32))
xl = K.dot(xl, self.kernel)
if self.bias:
xl += self.bias
return self.activation(xl)
def compute_output_shape(self, input_shape):
return (input_shape[0], self.output_dim) |
from django.db import models
from django.conf import settings
from jobs.models import Order
# Create your models here.
#contact model
def save_one_only(model_name):
def save(self, *args, **kwargs):
if not self.pk and model_name.objects.exists():
# if you'll not check for self.pk
# then error will also raised in update of exists model
raise ValidationError('There is can be only one '+model_name+' instance')
return super(model_name, self).save(*args, **kwargs)
class Contact (models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField( max_length=50)
email = models.EmailField( max_length=254)
message = models.TextField()
date = models.DateTimeField(auto_now_add=True)
#snippet utils
def __str__(self):
return self.name
class Whatsapp (models.Model):
id = models.AutoField(primary_key=True)
number = models.CharField(max_length=50)
save_one_only("Whatsapp")
def __str__(self):
return self.number
class UserProfile(models.Model):
id = models.AutoField(primary_key=True)
user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
orders = models.ManyToManyField(Order, blank=True)
def __str__(self):
return self.user.username
|
import multiprocessing
from itertools import repeat
import openpyxl
import excel
def _read_sheet(filename, sheetname):
# The leading underscore in the function name is used by convention
# to mark it as "private", i.e., it shouldn't be used directly outside
# of this module.
book = openpyxl.load_workbook(filename,
read_only=True, data_only=True)
sheet = book[sheetname]
data = excel.read(sheet)
book.close()
return sheet.title, data
def load_workbook(filename, sheetnames=None):
if sheetnames is None:
book = openpyxl.load_workbook(filename,
read_only=True, data_only=True)
sheetnames = book.sheetnames
book.close()
with multiprocessing.Pool() as pool:
# By default, Pool spawns as many processes as there are CPU cores.
# starmap maps a tuple of arguments to a function. The zip expression
# produces a list with tuples of the following form:
# [('filename.xlsx', 'Sheet1'), ('filename.xlsx', 'Sheet2)]
data = pool.starmap(_read_sheet, zip(repeat(filename), sheetnames))
return {i[0]: i[1] for i in data}
|
# Analog Device
# author: ulno
# created: 2017-04-28
from machine import ADC
from uiot.device import Device
class Analog(Device):
# Handle devices connected to the analog port
# offers a digital mode through using threshold
def __init__(self, name, precision=1, threshold=None,
on_change=None, report_change=True, filter=None):
self.precision = precision
self.threshold = None
if threshold is not None:
self.threshold = max(1, min(threshold, 1023))
self.last_value = None
Device.__init__(self, name, ADC(0), on_change=on_change,
report_change=report_change, filter=filter)
def measure(self):
value = self.port.read()
if self.last_value is None \
or abs(value - self.last_value) >= self.precision:
self.last_value = value
if self.threshold is None:
return self.last_value # just return value
else:
if self.last_value > self.threshold - self.precision: # behave like a digital sensor
return 1
else:
return 0
return self.last_value
|
"""
Copyright (c) 2017-2018 Starwolf Ltd and Richard Freeman. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License.
A copy of the License is located at http://www.apache.org/licenses/LICENSE-2.0
or in the "license" file accompanying this file. This file is distributed
on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
express or implied. See the License for the specific language governing
permissions and limitations under the License.
Created on 01 Mar 2018
@author: Richard Freeman
This Lambda processes DynamoDB Streams records,
and persists them into another DynamoDB.
There are no need to specify the source table as that is part of the event source, and
the target table is the same as the source with -replicated postfix. This means
that the lambda can be reused for the replication of similar tables without changes.
"""
from __future__ import print_function
from boto3 import resource
class DynamoRepository:
def __init__(self):
self.dynamodb = resource(service_name='dynamodb', region_name='eu-west-1')
def update_dynamo_event_counter(self, table_name, full_parsed_row):
table = self.dynamodb.Table(table_name)
response = table.put_item(Item=full_parsed_row)
print(response)
dynamoRepository = DynamoRepository()
class Controller:
def __init__(self):
pass
@staticmethod
def parse_dynamo_type(item):
datatype = item.keys()[0]
if datatype == 'S':
value = str(item.values()[0])
elif datatype == 'N':
value = int(item.values()[0])
else:
print('Datatype not supported yet!')
value = None
return value
@staticmethod
def replicate_dynamo_to_dynamo(event, context):
processed_event_count = 0
exception_counter = 0
exception_counter_limit = 20
target_table_name = ''
for record in event['Records']:
try:
full_parsed_row = {}
target_table_name = record['eventSourceARN'].split('/')[1] + '-replicated'
for key, item in record['dynamodb']['NewImage'].iteritems():
value = Controller.parse_dynamo_type(item)
full_parsed_row[key] = value
dynamoRepository.update_dynamo_event_counter(target_table_name, full_parsed_row)
processed_event_count += 1
except Exception as e:
exception_counter += 1
print('Exception DynamoDB update error')
if exception_counter < exception_counter_limit:
print(''.join(['Exception ', str(record)]))
print_exception(e)
# uncomment for large number of records
print('Target Table %s %s/%s record(s)' % (target_table_name,
processed_event_count,
len(event['Records'])))
def print_exception(e):
print(''.join(['Exception ', str(type(e))]))
print(''.join(['Exception ', str(e.__doc__)]))
print(''.join(['Exception ', str(e.message)]))
def lambda_handler(event, context):
Controller.replicate_dynamo_to_dynamo(event, context)
return 'done'
|
# -*- coding: utf-8 -*-
# Generated by Django 1.11.7 on 2017-12-02 09:02
from __future__ import unicode_literals
import django.core.validators
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Room',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('room_name', models.CharField(max_length=300)),
('room_descpription', models.TextField()),
('room_accesability', models.BooleanField()),
('room_light', models.IntegerField(validators=[django.core.validators.MaxValueValidator(100), django.core.validators.MinValueValidator(1)])),
],
options={
'db_table': 'rooms',
},
),
]
|
from flopy.mbase import Package
class ModflowGmg(Package):
'''GMG package
Only programmed to work with the default values; may need work for other options'''
def __init__(self, model, mxiter=50, iiter=30, iadamp=0, \
hclose=1e-5, rclose=1e-5, relax=1.0, ioutgmg=0, \
ism=0, isc=0, damp=1.0,dup=0.75,dlow=0.01,\
chglimit=1.0,extension='gmg', unitnumber=27):
Package.__init__(self, model, extension, 'GMG', unitnumber) # Call ancestor's init to set self.parent, extension, name and unit number
self.heading = '# GMG for MODFLOW, generated by Flopy.'
self.url = 'gmg.htm'
self.mxiter = mxiter
self.iiter = iiter
self.iadamp = iadamp
self.hclose = hclose
self.rclose = rclose
self.relax = relax
self.ism = ism
self.isc = isc
self.dup = dup
self.dlow = dlow
self.chglimit = chglimit
self.damp = damp
self.ioutgmg = ioutgmg
self.iunitmhc = 0
self.parent.add_package(self)
def __repr__( self ):
return 'Geometric multigrid solver package class'
def write_file(self):
# Open file for writing
f_gmg = open(self.fn_path, 'w')
f_gmg.write('%s\n' % self.heading)
#--ds0
f_gmg.write('{0:9.3e} {1:9d} {2:9.3e} {3:9d}\n'\
.format(self.rclose,self.iiter,self.hclose,self.mxiter))
#--ds1
f_gmg.write('{0:9.3e} {1:9d} {2:9d} {3:9d}\n'\
.format(self.damp,self.iadamp,self.ioutgmg,self.iunitmhc))
#--ds2
f_gmg.write('{0:9d} {1:9d} {2:9.3e} {3:9.3e} {4:9.3e}\n'\
.format(self.ism,self.isc,self.dup,self.dlow,self.chglimit))
#--ds3
f_gmg.write('{0:10.3e}\n'.format(self.relax))
f_gmg.close()
|
"""flint Construct class
:copyright: Copyright 2021 Marshall Ward, see AUTHORS for details.
:license: Apache License, Version 2.0, see LICENSE for details.
"""
from flint.calls import get_callable_symbols
from flint.statement import Statement
class Construct(object):
construct_types = [
'associate',
'block',
'critical',
'do',
'if',
'forall',
'where',
# Proxy for keyword pairs below
'change'
'select',
]
# TODO: Ignore these for now
construct_kw_pairs = [
('change', 'team'),
('select', 'case'),
('select', 'rank'),
('select', 'type'),
]
# TODO: Override for individual constructs?
@staticmethod
def construct_stmt(stmt):
# Pop off construct label
if stmt[0][-1] == ':':
stmt = stmt[1:]
# TODO: Actual rules vary for every construct type, not just 'if'
if stmt[0] in Construct.construct_types:
if stmt[0] == 'if':
return (stmt[0], stmt[-1]) == ('if', 'then')
elif stmt[0] == 'where':
assert stmt[1] == '('
par_count = 1
for idx, tok in enumerate(stmt[2:], start=2):
if tok == '(':
par_count += 1
elif tok == ')':
par_count -= 1
if par_count == 0:
break
return idx == len(stmt) - 1
# XXX: Need to figure this out!
return
else:
return True
def end_statement(self, stmt):
if stmt[0].startswith('end'):
if len(stmt) == 1 and stmt[0] in ('end', 'end' + self.ctype):
return True
elif len(stmt) == 2 and (stmt[0], stmt[1]) == ('end', self.ctype):
return True
else:
return False
elif self.ctype == 'do' and len(stmt) > 1 and stmt[1] == 'continue':
# TODO: Will stmt[0] always be a label?
# TODO: Check if label is inside the 'do' construct?
return True
else:
return False
def __init__(self, unit, depth=1):
self.ctype = None
self.name = None
# Program unit containing the construct
self.unit = unit
# Testing
self.depth = depth
self.statements = []
def parse(self, statements):
stmt = statements.current_line
# Check for construct label (and pop off)
if stmt[0][-1] == ':':
self.name = stmt[0][:-1]
stmt = stmt[1:]
if stmt[0] == 'select':
self.ctype = stmt[1]
else:
self.ctype = stmt[0]
stmt.tag = 'C'
self.statements.append(stmt)
# Generate the list of variable names
var_names = [v.name for v in self.unit.variables]
# Parse the contents of the construct
for stmt in statements:
self.unit.callees.update(get_callable_symbols(stmt, var_names))
if Construct.construct_stmt(stmt):
cons = Construct(self.unit, depth=self.depth + 1)
cons.parse(statements)
self.statements.extend(cons.statements)
elif self.end_statement(stmt):
stmt.tag = 'C'
self.statements.append(stmt)
break
else:
# Unhandled
stmt.tag = 'e'
self.statements.append(stmt)
|
import numpy as np
import time
import os
import tensorflow as tf
from tf_rl.common.utils import sync_main_target, soft_target_model_update, huber_loss, logging
class _Duelling_Double_DQN_PER:
"""
Boilerplate for DQN Agent with PER
"""
def __init__(self):
"""
define your model here!
"""
pass
def predict(self, sess, state):
"""
predict q-values given a state
:param sess:
:param state:
:return:
"""
return sess.run(self.pred, feed_dict={self.state: state})
def update(self, sess, state, action, Y):
feed_dict = {self.state: state, self.action: action, self.Y: Y}
summaries, total_t, _, loss, batch_loss = sess.run(
[self.summaries, tf.train.get_global_step(), self.train_op, self.loss, self.losses], feed_dict=feed_dict)
self.summary_writer.add_summary(summaries, total_t)
return loss, batch_loss
class Duelling_Double_DQN_PER_Atari(_Duelling_Double_DQN_PER):
"""
DQN Agent with PER for Atari Games
"""
def __init__(self, scope, dueling_type, env, loss_fn="MSE", grad_clip_flg=True):
self.scope = scope
self.num_action = env.action_space.n
self.summaries_dir = "../logs/summary_{}".format(scope)
self.grad_clip_flg = grad_clip_flg
if self.summaries_dir:
summary_dir = os.path.join(self.summaries_dir, "summaries_{}".format(scope))
if not os.path.exists(summary_dir):
os.makedirs(summary_dir)
self.summary_writer = tf.summary.FileWriter(summary_dir)
with tf.variable_scope(scope):
self.state = tf.placeholder(shape=[None, 84, 84, 1], dtype=tf.float32, name="X")
self.Y = tf.placeholder(shape=[None], dtype=tf.float32, name="Y")
self.action = tf.placeholder(shape=[None], dtype=tf.int32, name="action")
conv1 = tf.keras.layers.Conv2D(32, kernel_size=8, strides=8, activation=tf.nn.relu)(self.state)
conv2 = tf.keras.layers.Conv2D(64, kernel_size=4, strides=2, activation=tf.nn.relu)(conv1)
conv3 = tf.keras.layers.Conv2D(64, kernel_size=3, strides=1, activation=tf.nn.relu)(conv2)
flat = tf.keras.layers.Flatten()(conv3)
fc1 = tf.keras.layers.Dense(512, activation=tf.nn.relu)(flat)
self.pred = tf.keras.layers.Dense(self.num_action, activation=tf.nn.relu)(fc1)
self.state_value = tf.keras.layers.Dense(1, activation=tf.nn.relu)(fc1)
# ===== Duelling DQN part =====
if dueling_type == "avg":
# Q(s,a;theta) = V(s;theta) + (A(s,a;theta)-Avg_a(A(s,a;theta)))
self.output = tf.math.add(self.state_value, tf.math.subtract(self.pred, tf.reduce_mean(self.pred)))
elif dueling_type == "max":
# Q(s,a;theta) = V(s;theta) + (A(s,a;theta)-max_a(A(s,a;theta)))
self.output = tf.math.add(self.state_value, tf.math.subtract(self.pred, tf.math.reduce_max(self.pred)))
elif dueling_type == "naive":
# Q(s,a;theta) = V(s;theta) + A(s,a;theta)
self.output = tf.math.add(self.state_value, self.pred)
else:
assert False, "dueling_type must be one of {'avg','max','naive'}"
# indices of the executed actions
idx_flattened = tf.range(0, tf.shape(self.pred)[0]) * tf.shape(self.pred)[1] + self.action
# passing [-1] to tf.reshape means flatten the array
# using tf.gather, associate Q-values with the executed actions
self.action_probs = tf.gather(tf.reshape(self.pred, [-1]), idx_flattened)
if loss_fn == "huber_loss":
# use huber loss
self.losses = tf.subtract(self.Y, self.action_probs)
self.loss = huber_loss(self.losses)
# self.loss = tf.reduce_mean(huber_loss(self.losses))
elif loss_fn == "MSE":
# use MSE
self.losses = tf.squared_difference(self.Y, self.action_probs)
self.loss = tf.reduce_mean(self.losses)
else:
assert False
# you can choose whatever you want for the optimiser
# self.optimizer = tf.train.RMSPropOptimizer(0.00025, 0.99, 0.0, 1e-6)
self.optimizer = tf.train.AdamOptimizer()
if self.grad_clip_flg:
# to apply Gradient Clipping, we have to directly operate on the optimiser
# check this: https://www.tensorflow.org/api_docs/python/tf/train/Optimizer#processing_gradients_before_applying_them
# https://stackoverflow.com/questions/49987839/how-to-handle-none-in-tf-clip-by-global-norm
self.gradients, self.variables = zip(*self.optimizer.compute_gradients(self.loss))
# self.clipped_grads_and_vars = [(ClipIfNotNone(grad, -1., 1.), var) for grad, var in self.grads_and_vars]
self.gradients, _ = tf.clip_by_global_norm(self.gradients, 2.5)
self.train_op = self.optimizer.apply_gradients(zip(self.gradients, self.variables))
for i, grad in enumerate(self.gradients):
if grad is not None:
mean = tf.reduce_mean(tf.abs(grad))
tf.summary.scalar('mean_{}'.format(i + 1), mean)
tf.summary.histogram('histogram_{}'.format(i + 1), grad)
else:
self.train_op = self.optimizer.minimize(self.loss)
tf.summary.scalar("loss", tf.reduce_mean(self.loss))
tf.summary.histogram("loss_hist", self.losses)
tf.summary.histogram("q_values_hist", self.pred)
tf.summary.scalar("mean_q_value", tf.math.reduce_mean(self.pred))
tf.summary.scalar("var_q_value", tf.math.reduce_variance(self.pred))
tf.summary.scalar("max_q_value", tf.reduce_max(self.pred))
self.summaries = tf.summary.merge_all()
class Duelling_Double_DQN_PER_CartPole(_Duelling_Double_DQN_PER):
"""
DQN Agent with PER for CartPole game
"""
def __init__(self, scope, dueling_type, env, loss_fn="MSE", grad_clip_flg=True):
self.scope = scope
self.num_action = env.action_space.n
self.summaries_dir = "../logs/summary_{}".format(scope)
self.grad_clip_flg = grad_clip_flg
if self.summaries_dir:
summary_dir = os.path.join(self.summaries_dir, "summaries_{}".format(scope))
if not os.path.exists(summary_dir):
os.makedirs(summary_dir)
self.summary_writer = tf.summary.FileWriter(summary_dir)
with tf.variable_scope(scope):
self.state = tf.placeholder(shape=[None, 4], dtype=tf.float32, name="X")
self.Y = tf.placeholder(shape=[None], dtype=tf.float32, name="Y")
self.action = tf.placeholder(shape=[None], dtype=tf.int32, name="action")
fc1 = tf.keras.layers.Dense(16, activation=tf.nn.relu)(self.state)
fc2 = tf.keras.layers.Dense(16, activation=tf.nn.relu)(fc1)
self.pred = tf.keras.layers.Dense(self.num_action, activation=tf.nn.relu)(fc2)
self.state_value = tf.keras.layers.Dense(1, activation=tf.nn.relu)(fc2)
# ===== Duelling DQN part =====
if dueling_type == "avg":
# Q(s,a;theta) = V(s;theta) + (A(s,a;theta)-Avg_a(A(s,a;theta)))
self.output = tf.math.add(self.state_value, tf.math.subtract(self.pred, tf.reduce_mean(self.pred)))
elif dueling_type == "max":
# Q(s,a;theta) = V(s;theta) + (A(s,a;theta)-max_a(A(s,a;theta)))
self.output = tf.math.add(self.state_value, tf.math.subtract(self.pred, tf.math.reduce_max(self.pred)))
elif dueling_type == "naive":
# Q(s,a;theta) = V(s;theta) + A(s,a;theta)
self.output = tf.math.add(self.state_value, self.pred)
else:
assert False, "dueling_type must be one of {'avg','max','naive'}"
# indices of the executed actions
idx_flattened = tf.range(0, tf.shape(self.pred)[0]) * tf.shape(self.pred)[1] + self.action
# passing [-1] to tf.reshape means flatten the array
# using tf.gather, associate Q-values with the executed actions
self.action_probs = tf.gather(tf.reshape(self.pred, [-1]), idx_flattened)
if loss_fn == "huber_loss":
# use huber loss
self.losses = tf.subtract(self.Y, self.action_probs)
self.loss = huber_loss(self.losses)
# self.loss = tf.reduce_mean(huber_loss(self.losses))
elif loss_fn == "MSE":
# use MSE
self.losses = tf.squared_difference(self.Y, self.action_probs)
self.loss = tf.reduce_mean(self.losses)
else:
assert False
# you can choose whatever you want for the optimiser
# self.optimizer = tf.train.RMSPropOptimizer(0.00025, 0.99, 0.0, 1e-6)
self.optimizer = tf.train.AdamOptimizer()
if self.grad_clip_flg:
# to apply Gradient Clipping, we have to directly operate on the optimiser
# check this: https://www.tensorflow.org/api_docs/python/tf/train/Optimizer#processing_gradients_before_applying_them
# https://stackoverflow.com/questions/49987839/how-to-handle-none-in-tf-clip-by-global-norm
self.gradients, self.variables = zip(*self.optimizer.compute_gradients(self.loss))
# self.clipped_grads_and_vars = [(ClipIfNotNone(grad, -1., 1.), var) for grad, var in self.grads_and_vars]
self.gradients, _ = tf.clip_by_global_norm(self.gradients, 2.5)
self.train_op = self.optimizer.apply_gradients(zip(self.gradients, self.variables))
for i, grad in enumerate(self.gradients):
if grad is not None:
mean = tf.reduce_mean(tf.abs(grad))
tf.summary.scalar('mean_{}'.format(i + 1), mean)
tf.summary.histogram('histogram_{}'.format(i + 1), grad)
else:
self.train_op = self.optimizer.minimize(self.loss)
tf.summary.scalar("loss", tf.reduce_mean(self.loss))
tf.summary.histogram("loss_hist", self.losses)
tf.summary.histogram("q_values_hist", self.pred)
tf.summary.scalar("mean_q_value", tf.math.reduce_mean(self.pred))
tf.summary.scalar("var_q_value", tf.math.reduce_variance(self.pred))
tf.summary.scalar("max_q_value", tf.reduce_max(self.pred))
self.summaries = tf.summary.merge_all()
def train_Duelling_Double_DQN_PER(main_model, target_model, env, replay_buffer, policy, Beta, params):
"""
Train DQN agent which defined above
:param main_model:
:param target_model:
:param env:
:param params:
:return:
"""
# log purpose
losses, all_rewards, cnt_action = [], [], []
episode_reward, index_episode = 0, 0
# Create a glboal step variable
global_step = tf.Variable(0, name='global_step', trainable=False)
with tf.Session() as sess:
# initialise all variables used in the model
sess.run(tf.global_variables_initializer())
state = env.reset()
start = time.time()
global_step = sess.run(tf.train.get_global_step())
for frame_idx in range(1, params.num_frames + 1):
action = policy.select_action(sess, main_model, state.reshape(params.state_reshape))
cnt_action.append(action)
next_state, reward, done, _ = env.step(action)
replay_buffer.add(state, action, reward, next_state, done)
state = next_state
episode_reward += reward
global_step += 1
if done:
index_episode += 1
policy.index_episode = index_episode
state = env.reset()
all_rewards.append(episode_reward)
if frame_idx > params.learning_start and len(replay_buffer) > params.batch_size:
# ===== Prioritised Experience Replay part =====
# PER returns: state, action, reward, next_state, done, weights(a weight for a timestep), indices(indices for a batch of timesteps)
states, actions, rewards, next_states, dones, weights, indices = replay_buffer.sample(
params.batch_size, Beta.get_value(frame_idx))
# ===== Double DQN part =====
next_Q_main = main_model.predict(sess, next_states)
next_Q = target_model.predict(sess, next_states)
Y = rewards + params.gamma * next_Q[
np.arange(params.batch_size), np.argmax(next_Q_main, axis=1)] * np.logical_not(dones)
# we get a batch of loss for updating PER memory
loss, batch_loss = main_model.update(sess, states, actions, Y)
# add noise to the priorities
batch_loss = np.abs(batch_loss) + params.prioritized_replay_noise
# Update a prioritised replay buffer using a batch of losses associated with each timestep
replay_buffer.update_priorities(indices, batch_loss)
# Logging and refreshing log purpose values
losses.append(loss)
logging(frame_idx, params.num_frames, index_episode, time.time() - start, episode_reward,
np.mean(loss), policy.current_epsilon(), cnt_action)
episode_summary = tf.Summary()
episode_summary.value.add(simple_value=episode_reward, node_name="episode_reward",
tag="episode_reward")
episode_summary.value.add(simple_value=index_episode, node_name="episode_length",
tag="episode_length")
main_model.summary_writer.add_summary(episode_summary, global_step)
episode_reward = 0
cnt_action = []
start = time.time()
if np.random.rand() > 0.5:
# soft update means we partially add the original weights of target model instead of completely
# sharing the weights among main and target models
if params.update_hard_or_soft == "hard":
sync_main_target(sess, target_model, main_model)
elif params.update_hard_or_soft == "soft":
soft_target_model_update(sess, target_model, main_model, tau=params.soft_update_tau)
return all_rewards, losses
|
#!/usr/bin/env python
import os
import sys
import pkg_resources
PROJECTS = [
['common', 'steelscript', 'SteelScript Common', '..'],
['netprofiler', 'steelscript.netprofiler', 'SteelScript NetProfiler', '../../steelscript-netprofiler'],
['appresponse', 'steelscript.appresponse', 'SteelScript AppResponse', '../../steelscript-appresponse'],
['steelhead', 'steelscript.steelhead', 'SteelScript SteelHead', '../../steelscript-steelhead'],
['scc', 'steelscript.scc', 'SteelScript SteelCentral Controller', '../../steelscript-scc'],
['cmdline', 'steelscript.cmdline', 'SteelScript Command Line', '../../steelscript-cmdline'],
['reschema', 'reschema', 'Reschema', '../../reschema'],
['sleepwalker', 'sleepwalker', 'Sleepwalker', '../../sleepwalker']
]
for p in PROJECTS:
proj, pkg, title, path = p
if proj == 'common':
continue
package = pkg_resources.get_distribution(pkg)
if package.location != os.path.abspath(path):
p[3] = package.location
def create_symlinks():
for proj, pkg, title, path in PROJECTS:
# Create a symlink, ignore common since its part of package
if proj == 'common':
continue
try:
os.unlink(proj)
except OSError:
pass
src = '{path}/docs'.format(path=path)
if os.path.exists(src):
os.symlink(src, proj)
else:
from IPython import embed;embed()
raise Exception(
'Could not find related project source tree: %s' % src)
def write_toc_templates():
if not os.path.exists('_templates'):
os.mkdir('_templates')
for proj, pkg, title, path in PROJECTS:
# Write a custom TOC template file
tocfile = '%s_toc.html' % proj
template_tocfile = '_templates/%s' % tocfile
if not os.path.exists(template_tocfile):
with open(template_tocfile, 'w') as f:
f.write("""{{%- if display_toc %}}
<h3><a href="{{{{ pathto('{proj}/overview.html', 1) }}}}">{{{{ _('{title}') }}}}</a></h3>
{{{{ toc }}}}
{{%- endif %}}""".format(proj=proj, title=title))
def setup_html_sidebards(html_sidebars):
for proj, pkg, title, path in PROJECTS:
tocfile = '%s_toc.html' % proj
html_sidebars['%s/*' % proj] = \
[tocfile, 'relations.html', 'sourcelink.html',
'searchbox.html', 'license.html']
def setup_sys_path():
for proj, pkg, title, path in PROJECTS:
if not os.path.exists(path):
raise Exception('Could not find related project source tree: %s' % path)
sys.path.insert(0, os.path.abspath(path))
|
import pytest
import time
import syft as sy
import torch as th
from syft.workers import WebsocketClientWorker
from syft.workers import WebsocketServerWorker
def test_create_already_existing_worker(hook):
# Shares tensor with bob
bob = sy.VirtualWorker(hook, "bob")
x = th.tensor([1, 2, 3]).send(bob)
# Recreates bob and shares a new tensor
bob = sy.VirtualWorker(hook, "bob")
y = th.tensor([2, 2, 2]).send(bob)
# Recreates bob and shares a new tensor
bob = sy.VirtualWorker(hook, "bob")
z = th.tensor([2, 2, 10]).send(bob)
# Both workers should be the same, so the following operation should be valid
_ = x + y * z
def test_create_already_existing_worker_with_different_type(hook, start_proc):
# Shares tensor with bob
bob = sy.VirtualWorker(hook, "bob")
_ = th.tensor([1, 2, 3]).send(bob)
kwargs = {"id": "fed1", "host": "localhost", "port": 8765, "hook": hook}
server = start_proc(WebsocketServerWorker, kwargs)
time.sleep(0.1)
# Recreates bob as a different type of worker
kwargs = {"id": "bob", "host": "localhost", "port": 8765, "hook": hook}
with pytest.raises(RuntimeError):
bob = WebsocketClientWorker(**kwargs)
server.terminate()
|
# Copyright 2014 Open Source Robotics Foundation, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import shutil
import subprocess
import sys
import tempfile
from catkin_tools.argument_parsing import handle_make_arguments
from catkin_tools.common import mkdir_p
from .commands.cmake import CMAKE_EXEC
from .commands.cmake import CMAKE_INSTALL_MANIFEST_FILENAME
from .commands.cmake import CMakeIOBufferProtocol
from .commands.cmake import CMakeMakeIOBufferProtocol
from .commands.cmake import get_installed_files
from .commands.make import MAKE_EXEC
from .utils import copyfiles
from .utils import loadenv
from .utils import makedirs
from .utils import require_command
from .utils import rmfiles
from catkin_tools.execution.jobs import Job
from catkin_tools.execution.stages import CommandStage
from catkin_tools.execution.stages import FunctionStage
from catkin_tools.terminal_color import ColorMapper
mapper = ColorMapper()
clr = mapper.clr
# FileNotFoundError from Python3
try:
FileNotFoundError
except NameError:
class FileNotFoundError(OSError):
pass
def copy_install_manifest(
logger, event_queue,
src_install_manifest_path,
dst_install_manifest_path):
"""Copy the install manifest file from one path to another,"""
# Get file paths
src_install_manifest_file_path = os.path.join(src_install_manifest_path, CMAKE_INSTALL_MANIFEST_FILENAME)
dst_install_manifest_file_path = os.path.join(dst_install_manifest_path, CMAKE_INSTALL_MANIFEST_FILENAME)
# Create the directory for the manifest if it doesn't exist
mkdir_p(dst_install_manifest_path)
if os.path.exists(src_install_manifest_file_path):
# Copy the install manifest
shutil.copyfile(src_install_manifest_file_path, dst_install_manifest_file_path)
else:
# Didn't actually install anything, so create an empty manifest for completeness
logger.err("Warning: No targets installed.")
with open(dst_install_manifest_file_path, 'a'):
os.utime(dst_install_manifest_file_path, None)
return 0
def get_python_install_dir(context):
"""Returns the same value as the CMake variable PYTHON_INSTALL_DIR
The PYTHON_INSTALL_DIR variable is normally set from the CMake file:
catkin/cmake/python.cmake
:returns: Python install directory for the system Python
:rtype: str
"""
cmake_command = [CMAKE_EXEC]
cmake_command.extend(context.cmake_args)
script_path = os.path.join(os.path.dirname(__file__), 'cmake', 'python_install_dir.cmake')
cmake_command.extend(['-P', script_path])
p = subprocess.Popen(
cmake_command,
cwd=os.path.join(os.path.dirname(__file__), 'cmake'),
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
# only our message (containing the install directory) is written to stderr
_, out = p.communicate()
return out.decode().strip()
def get_multiarch():
"""This function returns the suffix for lib directories on supported
systems or an empty string it uses two step approach to look for multiarch:
first run gcc -print-multiarch and if failed try to run
dpkg-architecture."""
if not sys.platform.lower().startswith('linux'):
return ''
error_thrown = False
try:
p = subprocess.Popen(
['gcc', '-print-multiarch'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = p.communicate()
except (OSError, FileNotFoundError):
error_thrown = True
if error_thrown or p.returncode != 0:
try:
out, err = subprocess.Popen(
['dpkg-architecture', '-qDEB_HOST_MULTIARCH'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
except (OSError, FileNotFoundError):
return ''
# be sure to return empty string or a valid multiarch tuple
decoded = out.decode().strip()
assert(not decoded or decoded.count('-') == 2)
return decoded
def generate_env_file(logger, event_queue, context, install_target):
env_file_path = os.path.join(install_target, 'env.sh')
if os.path.exists(env_file_path):
return 0
env_file_directory = os.path.dirname(env_file_path)
if not os.path.exists(env_file_directory):
os.makedirs(env_file_directory)
logger.out(clr("Generating env file: @!@{yf}{}@|").format(env_file_path))
# Create a temporary file in the setup_file_directory, so os.rename cannot fail
tmp_dst_handle, tmp_dst_path = tempfile.mkstemp(
dir=env_file_directory,
prefix=os.path.basename(env_file_path) + '.')
# Write the filled template to the file
subs = {}
data = ENV_FILE_TEMPLATE.format(**subs)
os.write(tmp_dst_handle, data.encode('utf-8'))
os.close(tmp_dst_handle)
# Make the file executable without overwriting the permissions for
# the group and others (copy r flags to x)
mode = os.stat(tmp_dst_path).st_mode
mode |= (mode & 0o444) >> 2
os.chmod(tmp_dst_path, mode)
# Do an atomic rename with os.rename
os.rename(tmp_dst_path, env_file_path)
return 0
def generate_setup_file(logger, event_queue, context, install_target):
# Create full path to setup file
setup_file_path = os.path.join(install_target, 'setup.sh')
# Check if the setup file needs to be generated
if context.install:
# Create the setup file in the install space
setup_file_needed = context.isolate_install or not os.path.exists(setup_file_path)
else:
# Do not replace existing setup.sh if devel space is merged
setup_file_needed = not context.link_devel and context.isolate_devel or not os.path.exists(setup_file_path)
if not setup_file_needed:
logger.out("Setup file does not need to be generated.")
return 0
else:
logger.out(clr("Generating setup file: @!@{yf}{}@|").format(setup_file_path))
# Create the setup file that dependent packages will source
arch = get_multiarch()
subs = {}
subs['cmake_prefix_path'] = install_target + ":"
subs['ld_path'] = os.path.join(install_target, 'lib') + ":"
pythonpath = os.path.join(install_target, get_python_install_dir(context))
subs['pythonpath'] = pythonpath + ':'
subs['pkgcfg_path'] = os.path.join(install_target, 'lib', 'pkgconfig') + ":"
subs['path'] = os.path.join(install_target, 'bin') + ":"
subs['cpath'] = os.path.join(install_target, 'include') + ":"
subs['library_path'] = os.path.join(install_target, 'lib') + ":"
if arch:
subs['ld_path'] += os.path.join(install_target, 'lib', arch) + ":"
subs['pkgcfg_path'] += os.path.join(install_target, 'lib', arch, 'pkgconfig') + ":"
setup_file_directory = os.path.dirname(setup_file_path)
if not os.path.exists(setup_file_directory):
os.makedirs(setup_file_directory)
# Create a temporary file in the setup_file_directory, so os.rename cannot fail
tmp_dst_handle, tmp_dst_path = tempfile.mkstemp(
dir=setup_file_directory,
prefix=os.path.basename(setup_file_path) + '.')
# Write the filled template to the file
data = SETUP_FILE_TEMPLATE.format(**subs)
os.write(tmp_dst_handle, data.encode('utf-8'))
os.close(tmp_dst_handle)
# Do an atomic rename with os.rename
os.rename(tmp_dst_path, setup_file_path)
return 0
def create_cmake_build_job(context, package, package_path, dependencies, force_cmake, pre_clean):
# Package source space path
pkg_dir = os.path.join(context.source_space_abs, package_path)
# Package build space path
build_space = context.package_build_space(package)
# Package metadata path
metadata_path = context.package_metadata_path(package)
# Environment dictionary for the job, which will be built
# up by the executions in the loadenv stage.
job_env = dict(os.environ)
# Get actual staging path
dest_path = context.package_dest_path(package)
final_path = context.package_final_path(package)
# Create job stages
stages = []
# Load environment for job.
stages.append(FunctionStage(
'loadenv',
loadenv,
locked_resource='installspace',
job_env=job_env,
package=package,
context=context
))
# Create package build space
stages.append(FunctionStage(
'mkdir',
makedirs,
path=build_space
))
# Create package metadata dir
stages.append(FunctionStage(
'mkdir',
makedirs,
path=metadata_path
))
# Copy source manifest
stages.append(FunctionStage(
'cache-manifest',
copyfiles,
source_paths=[os.path.join(context.source_space_abs, package_path, 'package.xml')],
dest_path=os.path.join(metadata_path, 'package.xml')
))
require_command('cmake', CMAKE_EXEC)
# CMake command
makefile_path = os.path.join(build_space, 'Makefile')
if not os.path.isfile(makefile_path) or force_cmake:
stages.append(CommandStage(
'cmake',
([CMAKE_EXEC,
pkg_dir,
'--no-warn-unused-cli',
'-DCMAKE_INSTALL_PREFIX=' + final_path] +
context.cmake_args),
cwd=build_space,
logger_factory=CMakeIOBufferProtocol.factory_factory(pkg_dir)
))
else:
stages.append(CommandStage(
'check',
[MAKE_EXEC, 'cmake_check_build_system'],
cwd=build_space,
logger_factory=CMakeIOBufferProtocol.factory_factory(pkg_dir)
))
# Pre-clean command
if pre_clean:
make_args = handle_make_arguments(
context.make_args + context.catkin_make_args)
stages.append(CommandStage(
'preclean',
[MAKE_EXEC, 'clean'] + make_args,
cwd=build_space,
))
require_command('make', MAKE_EXEC)
# Make command
stages.append(CommandStage(
'make',
[MAKE_EXEC] + handle_make_arguments(context.make_args),
cwd=build_space,
logger_factory=CMakeMakeIOBufferProtocol.factory
))
# Make install command (always run on plain cmake)
stages.append(CommandStage(
'install',
[MAKE_EXEC, 'install'],
cwd=build_space,
logger_factory=CMakeMakeIOBufferProtocol.factory,
locked_resource='installspace'
))
# Copy install manifest
stages.append(FunctionStage(
'register',
copy_install_manifest,
src_install_manifest_path=build_space,
dst_install_manifest_path=context.package_metadata_path(package)
))
# Determine the location where the setup.sh file should be created
stages.append(FunctionStage(
'setupgen',
generate_setup_file,
context=context,
install_target=dest_path
))
stages.append(FunctionStage(
'envgen',
generate_env_file,
context=context,
install_target=dest_path
))
return Job(
jid=package.name,
deps=dependencies,
env=job_env,
stages=stages)
def create_cmake_clean_job(
context,
package,
package_path,
dependencies,
dry_run,
clean_build,
clean_devel,
clean_install):
"""Generate a Job to clean a cmake package"""
# Package build space path
build_space = context.package_build_space(package)
# Package metadata path
metadata_path = context.package_metadata_path(package)
# Environment dictionary for the job, empty for a clean job
job_env = {}
stages = []
if clean_install and context.install:
installed_files = get_installed_files(context.package_metadata_path(package))
stages.append(FunctionStage(
'cleaninstall',
rmfiles,
paths=sorted(installed_files),
remove_empty=True,
empty_root=context.install_space_abs,
dry_run=dry_run))
if clean_devel and not context.install:
installed_files = get_installed_files(context.package_metadata_path(package))
stages.append(FunctionStage(
'cleandevel',
rmfiles,
paths=sorted(installed_files),
remove_empty=True,
empty_root=context.devel_space_abs,
dry_run=dry_run))
if clean_build:
stages.append(FunctionStage(
'rmbuild',
rmfiles,
paths=[build_space],
dry_run=dry_run))
# Remove cached metadata
if clean_build and clean_devel and clean_install:
stages.append(FunctionStage(
'rmmetadata',
rmfiles,
paths=[metadata_path],
dry_run=dry_run))
return Job(
jid=package.name,
deps=dependencies,
env=job_env,
stages=stages)
description = dict(
build_type='cmake',
description="Builds a plain CMake package.",
create_build_job=create_cmake_build_job,
create_clean_job=create_cmake_clean_job
)
SETUP_FILE_TEMPLATE = """\
#!/usr/bin/env sh
# generated from catkin_tools.jobs.cmake python module
# remember type of shell if not already set
if [ -z "$CATKIN_SHELL" ]; then
CATKIN_SHELL=sh
fi
# detect if running on Darwin platform
_UNAME=`uname -s`
IS_DARWIN=0
if [ "$_UNAME" = "Darwin" ]; then
IS_DARWIN=1
fi
# Prepend to the environment
export CMAKE_PREFIX_PATH="{cmake_prefix_path}$CMAKE_PREFIX_PATH"
if [ $IS_DARWIN -eq 0 ]; then
export LD_LIBRARY_PATH="{ld_path}$LD_LIBRARY_PATH"
else
export DYLD_LIBRARY_PATH="{ld_path}$DYLD_LIBRARY_PATH"
fi
export CPATH="{cpath}$CPATH"
export LIBRARY_PATH="{library_path}$LIBRARY_PATH"
export PATH="{path}$PATH"
export PKG_CONFIG_PATH="{pkgcfg_path}$PKG_CONFIG_PATH"
export PYTHONPATH="{pythonpath}$PYTHONPATH"
"""
ENV_FILE_TEMPLATE = """\
#!/usr/bin/env sh
# generated from catkin_tools.jobs.cmake
if [ $# -eq 0 ] ; then
/bin/echo "Usage: env.sh COMMANDS"
/bin/echo "Calling env.sh without arguments is not supported anymore. Instead\
spawn a subshell and source a setup file manually."
exit 1
fi
# ensure to not use different shell type which was set before
CATKIN_SHELL=sh
# source setup.sh from same directory as this file
_CATKIN_SETUP_DIR=$(cd "`dirname "$0"`" > /dev/null && pwd)
. "$_CATKIN_SETUP_DIR/setup.sh"
exec "$@"
"""
|
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.axes import Axes
from layout import Layout
from src.simulation import Simulation
from src.utils import count_people, get_population_health_status, get_population_health_status_keys
matplotlib.use("Qt5Agg")
# TODO add animation
# TODO add controls for animation
# TODO add restart (generate new simulation and apply current conditions)
# TODO add functionality to sliders
# TODO remove unnecessary buttons (EMPTY)
layout = Layout()
fig = layout.fig
scatter_axis = layout.scatter_axis
scatter_axis.set_xlim(0, 1)
scatter_axis.set_ylim(0, 1)
graph_axis = layout.graph_axis
class Callbacks:
def __init__(self, scatter_ax: Axes, graph_ax: Axes):
self.play = False
self.scatter = None
self.plots = {}
self.scatter_ax = scatter_ax
self.graph_ax = graph_ax
self.idx = 0
self.population = 50
self.sick = 1
self.steps = 10
self.contact_range = 0.02
self.simulation = Simulation(
self.population, self.sick, self.steps, contact_radius=self.contact_range
)
self.init_plots()
self.update_line_plot_data()
def init_plots(self):
x, y, c = self.simulation[0]
self.scatter = self.scatter_ax.scatter(x=x, y=y, c=c)
for key, (y, c) in count_people(c).items():
plot, = self.graph_ax.plot(0, y, c=c, label=key)
self.plots[key] = {"plot": plot}
self.graph_ax.set_xlim(0, max(5, self.idx + 1))
def update_line_plot_data(self):
health_status_tuples = [get_population_health_status(fc) for _, _, fc in self.simulation]
health_statuses = zip(get_population_health_status_keys(), zip(*health_status_tuples))
for key, value in health_statuses:
self.plots[key]["data"] = value
def generate(self, _):
self.simulation = Simulation(
self.population, self.sick, self.steps, contact_radius=self.contact_range
)
self.update_line_plot_data()
self.graph_ax.set_ylim(0, self.population)
self.update()
def next(self, _):
if self.idx >= self.steps:
return
self.idx = self.idx + 1
self.update()
def back(self, _):
if self.idx <= 0:
return
self.idx = self.idx - 1
self.update()
def play(self, _):
self.play = True
if self.idx >= self.steps:
self.idx = 0
# TODO Some magic
def update_population(self, value):
self.population = value
def update_sick(self, value):
self.sick = value
def update_steps(self, value):
self.steps = value
def update_contact_range(self, value):
self.contact_range = value / 100
def pause(self, _):
self.play = False
def update(self):
x, y, c = self.simulation[self.idx]
self.scatter.set_offsets(list(zip(x, y)))
self.scatter.set_color(np.array(c))
for key, (y, _) in count_people(c).items():
x_data = range(self.idx + 1)
y_data = self.plots[key]["data"][:self.idx+1]
self.plots[key]["plot"].set_data(x_data, y_data)
self.graph_ax.set_xlim(0, max(5, self.idx + 1))
self.scatter_ax.figure.canvas.draw()
self.graph_ax.figure.canvas.draw()
callbacks = Callbacks(scatter_axis, graph_axis)
layout.button_next.on_clicked(callbacks.next)
layout.button_back.on_clicked(callbacks.back)
layout.button_play.on_clicked(callbacks.play)
layout.button_stop.on_clicked(callbacks.pause)
layout.button_16.on_clicked(callbacks.generate)
layout.button_01.on_changed(callbacks.update_sick)
# layout.button_02.on_changed(call)
# layout.button_03.on_changed()
layout.button_04.on_changed(callbacks.update_contact_range)
layout.button_05.on_changed(callbacks.update_steps)
layout.button_06.on_changed(callbacks.update_population)
# layout.button_11.on_changed()
# layout.button_12.on_changed()
plt.show()
|
from functools import reduce
from itertools import groupby
from sqlalchemy.orm import contains_eager, joinedload, subqueryload_all
from zeus.constants import Status, Result
from zeus.models import Build, Source
def merge_builds(target, build):
# Store the original build so we can retrieve its ID or number later, or
# show a list of all builds in the UI
target.original.append(build)
# These properties should theoretically always be the same within a build
# group, so merging is not necessary. We assign here so the initial build
# gets populated.
target.source = build.source
target.label = build.source.revision.message
# Merge properties, if they already exist. In the first run, everything
# will be empty, since every group is initialized with an empty build.
# Afterwards, we always use the more extreme value (e.g. earlier start
# date or worse result).
target.stats = target.stats + build.stats if target.stats else build.stats
target.status = Status(
max(target.status.value, build.status.value)
) if target.status else build.status
target.result = Result(
max(target.result.value, build.result.value)
) if target.result else build.result
target.date_started = min(
target.date_started, build.date_started
) if target.date_started else build.date_started
target.date_finished = max(
target.date_finished, build.date_finished
) if target.date_finished else build.date_finished
target.provider = "%s, %s" % (
target.provider, build.provider
) if target.provider else build.provider
# NOTE: The build number is not merged, as it would not convey any meaning
# in the context of a build group. In that fashion, build numbers should
# not be used in the UI, until we create a better interface.
# NOTE: We do not merge data here, as it is not really used in the UI
# If there is an actual use for data, then it should be merged or appended
return target
def merge_build_group(build_group):
if len(build_group) == 1:
build = build_group[0]
build.original = [build]
return build
providers = groupby(build_group, lambda build: build.provider)
latest_builds = [
max(build, key=lambda build: build.number) for _, build in providers
]
if len(latest_builds) == 1:
build = latest_builds[0]
build.original = [build]
return build
build = Build()
build.original = []
return reduce(merge_builds, latest_builds, build)
def fetch_builds_for_revisions(repo, revisions):
# we query extra builds here, but its a lot easier than trying to get
# sqlalchemy to do a ``select (subquery)`` clause and maintain tenant
# constraints
builds = Build.query.options(
contains_eager("source"),
joinedload("source").joinedload("author"),
joinedload("source").joinedload("revision"),
joinedload("source").joinedload("patch"),
subqueryload_all("stats"),
).join(
Source, Build.source_id == Source.id
).filter(
Build.repository_id == repo.id,
Source.repository_id == repo.id,
Source.revision_sha.in_([r.sha for r in revisions]),
Source.patch_id == None, # NOQA
).order_by(
Source.revision_sha
)
groups = groupby(builds, lambda build: build.source.revision_sha)
return [(sha, merge_build_group(list(group))) for sha, group in groups]
def fetch_build_for_revision(repo, revision):
builds = fetch_builds_for_revisions(revision.repository, [revision])
if len(builds) < 1:
return None
return builds[0][1]
|
import pytest
from cayennelpp.lpp_type import LppType
@pytest.fixture
def load():
return LppType.get_lpp_type(122)
def test_load(load):
val = (-5.432,)
aio_buf = load.encode(val)
assert load.decode(aio_buf) == val
val = (160.987,)
aio_buf = load.encode(val)
assert load.decode(aio_buf) == val
def test_load_invalid_buf(load):
with pytest.raises(Exception):
load.decode(bytearray([0x00]))
def test_load_invalid_val_type(load):
with pytest.raises(Exception):
load.encode([0, 1])
def test_load_invalid_val(load):
with pytest.raises(Exception):
load.encode((0, 1))
|
# -*- coding: utf-8 -*-
"""
Utilitybelt
~~~~~
:copyright: (c) 2015 by Halfmoon Labs
:license: MIT, see LICENSE for more details.
"""
import string
from .charsets import change_charset
B16_CHARS = string.hexdigits[0:16]
B16_REGEX = '^[0-9a-f]*$'
def hex_to_int(s):
try:
return int(s, 16)
except:
raise ValueError("Value must be in hex format")
def int_to_hex(i):
try:
return hex(i).rstrip('L').lstrip('0x')
except:
raise ValueError("Value must be in int format")
def is_hex(s):
# make sure that s is a string
if not isinstance(s, str):
return False
# if there's a leading hex string indicator, strip it
if s[0:2] == '0x':
s = s[2:]
# try to cast the string as an int
try:
i = hex_to_int(s)
except ValueError:
return False
else:
return True
def is_int(i):
return isinstance(i, (int,long))
def is_valid_int(i):
if is_int(i):
return True
elif isinstance(i, str):
try:
int_i = int(i)
except:
return False
else:
return True
return False
def hexpad(x):
return ('0' * (len(x) % 2)) + x
def charset_to_hex(s, original_charset):
return hexpad(change_charset(s, original_charset, B16_CHARS))
def hex_to_charset(s, destination_charset):
if not is_hex(s):
raise ValueError("Value must be in hex format")
s = s.lower()
return change_charset(s, B16_CHARS, destination_charset)
|
import unittest
import requests
from apprtc import get_room_parameters
class MyTestCase(unittest.TestCase):
def test_something(self):
res = requests.get("https://jie8.cc/api/utils/turnserver/auth")
self.assertEqual(True, False)
if __name__ == '__main__':
unittest.main()
|
# Copyright (c) 2011 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.
"""StatusPush handler from the buildbot master.
See event_sample.txt for event format examples.
"""
import datetime
import json
import logging
import time
from google.appengine.api.labs import taskqueue
from google.appengine.ext import db
from google.appengine.ext.db import polymodel
from google.appengine.runtime import DeadlineExceededError
from google.appengine.runtime.apiproxy_errors import CapabilityDisabledError
from appengine_module.chromium_status.base_page import BasePage
from appengine_module.chromium_status import utils
class Event(polymodel.PolyModel):
"""Base class for every events pushed by buildbot's StatusPush."""
eventid = db.IntegerProperty(required=True, indexed=False)
projectname = db.StringProperty(required=True)
projectstarted = db.DateTimeProperty(required=True)
created = db.DateTimeProperty(auto_now_add=True)
class Change(Event):
"""Buildbot detected a change"""
comments = db.TextProperty()
files = db.StringListProperty()
# Buildbot's master change number in changes.pck
number = db.IntegerProperty(required=True)
revision = db.StringProperty(indexed=False)
when = db.DateTimeProperty(required=True)
who = db.StringProperty(indexed=False)
revlink = db.StringProperty(indexed=False)
class Build(Event):
"""Buildbot completed a build"""
buildername = db.StringProperty(required=True)
buildnumber = db.IntegerProperty(required=True)
finished = db.DateTimeProperty(indexed=False)
reason = db.TextProperty()
results = db.IntegerProperty(indexed=False)
revision = db.StringProperty()
slave = db.StringProperty(indexed=False)
text = db.StringListProperty()
class BuildStep(Event):
"""Buildbot completed a build step"""
buildername = db.StringProperty(required=True)
buildnumber = db.IntegerProperty(required=True)
finished = db.DateTimeProperty(indexed=False)
# TODO(maruel): Require it ASAP
stepnumber = db.IntegerProperty(required=False, indexed=False)
stepname = db.StringProperty(required=True)
text = db.StringListProperty()
results = db.IntegerProperty(indexed=False)
def ModelToStr(obj):
"""Converts a model to a human readable string, for debugging"""
assert isinstance(obj, db.Model)
out = [obj.__class__.__name__]
for k in obj.properties():
if k.startswith('_'):
continue
out.append(' %s: %s' % (k, str(getattr(obj, k))))
return '\n'.join(out)
def onChangeAdded(packet):
change = packet['payload']['change']
obj = Change.gql(
'WHERE projectname = :1 AND projectstarted = :2 AND number = :3',
packet['project'], packet['projectstarted'],
change['number']).get()
if obj:
logging.info('Received duplicate %s/%s event for %s %s' %
(packet['event'], packet['eventid'], obj.__class__.__name__,
obj.number))
return None
return Change(
eventid=packet['id'],
projectname=packet['project'],
projectstarted=packet['projectstarted'],
comments=change['comments'],
files=change['files'],
number=change['number'],
revision=change['revision'],
# TODO(maruel): Timezones
when=datetime.datetime.fromtimestamp(change['when']),
who=change['who'],
revlink=change['revlink'])
def onBuildFinished(packet):
build = packet['payload']['build']
obj = Build.gql(
'WHERE projectname = :1 AND projectstarted = :2 '
'AND buildername = :3 AND buildnumber = :4',
packet['project'], packet['projectstarted'],
build['builderName'], build['number']).get()
if obj:
logging.info('Received duplicate %s/%d event for %s %s' %
(packet['event'], packet['id'], obj.__class__.__name__,
obj.build_number))
return None
# properties is an array of 3 values, keep the first 2 in a dict.
props = dict(((i[0], i[1]) for i in build['properties']))
return Build(
eventid=packet['id'],
projectname=packet['project'],
projectstarted=packet['projectstarted'],
buildername=build['builderName'],
buildnumber=build['number'],
# TODO(maruel): Timezones
finished=datetime.datetime.fromtimestamp(build['times'][1]),
reason=build['reason'],
results=build.get('results', 0),
revision=props.get('got_revision', props.get('revision', None)),
slave=build['slave'],
text=build['text'])
def onStepFinished(packet):
payload = packet['payload']
step = payload['step']
# properties is an array of 3 values, keep the first 2 in a dict.
props = dict(((i[0], i[1]) for i in payload['properties']))
obj = BuildStep.gql(
'WHERE projectname = :1 AND projectstarted = :2 '
'AND buildername = :3 AND buildnumber = :4 AND stepname = :5',
packet['project'], packet['projectstarted'],
props['buildername'], props['buildnumber'],
step['name']).get()
if obj:
logging.info('Received duplicate %s/%d event for %s %s' %
(packet['event'], packet['id'], obj.__class__.__name__,
obj.buildnumber))
return None
return BuildStep(
eventid=packet['id'],
projectname=packet['project'],
projectstarted=packet['projectstarted'],
buildername=props['buildername'],
buildnumber=props['buildnumber'],
# TODO(maruel): Send step number
#number=???
stepname=step['name'],
text=step['text'],
results=step.get('results', (0,))[0])
SUPPORTED_EVENTS = {
'changeAdded': onChangeAdded,
'buildFinished': onBuildFinished,
'stepFinished': onStepFinished,
}
class StatusReceiver(BasePage):
"""Buildbot's HttpStatusPush event receiver"""
@utils.requires_write_access
def post(self):
self.response.headers['Content-Type'] = 'text/plain'
try:
# TODO(maruel): Safety check, pwd?
packets = json.loads(self.request.POST['packets'])
# A list of packets should have been submitted, store each event.
objs = []
for index in xrange(len(packets)):
packet = packets[index]
# To simplify getKwargs.
packet['projectname'] = packet['project']
# TODO(maruel): Timezones
ts = time.strptime(packet['started'].split('.', 1)[0],
'%Y-%m-%d %H:%M:%S')
packet['projectstarted'] = (
datetime.datetime.fromtimestamp(time.mktime(ts)))
packet['eventid'] = packet['id']
if not 'payload' in packet:
packet['payload'] = json.loads(packet['payload_json'])
functor = SUPPORTED_EVENTS.get(packet['event'], None)
if not functor:
continue
obj = functor(packet)
if obj:
objs.append(obj)
# Save all the objects at once to reduce the number of rpc.
db.put(objs)
except CapabilityDisabledError:
logging.info('CapabilityDisabledError: read-only datastore')
self.response.out.write('CapabilityDisabledError: read-only datastore')
self.error(500)
return
except DeadlineExceededError:
logging.info('DeadlineExceededError')
self.response.out.write('DeadlineExceededError')
self.error(500)
return
taskqueue.add(url='/restricted/status-processor')
self.response.out.write('Success')
class RecentEvents(BasePage):
"""Returns the most recent events.
Mostly for testing"""
@utils.requires_read_access
def get(self):
self.response.headers['Content-Type'] = 'text/plain'
limit = int(self.request.GET.get('limit', 25))
nb = 0
for obj in Event.gql('ORDER BY created DESC LIMIT %d' % limit):
self.response.out.write('%s\n\n' % ModelToStr(obj))
nb += 1
logging.debug('RecentEvents(limit=%d) got %d' % (limit, nb))
class StatusProcessor(BasePage):
"""TODO(maruel): Implement http://crbug.com/21801
i.e. implement GateKeeper on appengine, close the tree when the buildbot
master shuts down, etc."""
@utils.requires_work_queue_login
def post(self):
self.response.headers['Content-Type'] = 'text/plain'
self.response.out.write('Success')
|
"""Testing route /cabinet"""
from flask_login import current_user
from module.tests import captured_templates, init_app, login_user, logout_user
def test_cabinet_view_access_and_render(init_app):
"""Make sure route '/cabinet' works and template with cabinet form is rendered"""
app = init_app
with captured_templates(app) as templates:
with app.test_client() as client:
# User is not authenticated
response_cabinet_view = client.get("/cabinet")
assert response_cabinet_view.status_code == 302
assert current_user.is_anonymous
# Authenticate user
response_login_user = login_user(client, "john", "test")
assert response_login_user.status_code == 200
assert current_user.is_authenticated
# Template 'cabinet' was rendered
template, context = templates[-1]
assert len(templates) == 1
assert template.name == "cabinet/cabinet.html"
# Logout user
response_logout_user = logout_user(client)
assert response_logout_user.status_code == 200
assert current_user.is_anonymous
# Authenticate admin and try to access /cabinet
response_login_admin = login_user(client, "admin", "test")
assert response_login_admin.status_code == 200
assert current_user.is_authenticated and current_user.username == "admin"
response_cabinet_view_access_for_admin = client.get("/cabinet")
assert response_cabinet_view_access_for_admin.status_code == 302
def test_payment_card_form(init_app):
"""Check if user can use the payment card"""
app = init_app
with app.test_client() as client:
# login user to access cabinet
response_login_user = login_user(client, "john", "test")
assert response_login_user.status_code == 200
assert current_user.is_authenticated
assert current_user.balance == 0
# Use card with code 000001
response_use_card = client.post("/cabinet", data=dict(code="000001"), follow_redirects=True)
prev_user_balance = current_user.balance
assert response_use_card.status_code == 200
assert current_user.balance != 0
# Use card with code 000001 again (balance shouldn't change)
response_use_card = client.post("/cabinet", data=dict(code="000001"), follow_redirects=True)
assert response_use_card.status_code == 200
assert current_user.balance == prev_user_balance
|
# MIT License
#
# Copyright (c) 2017 Arkadiusz Netczuk <[email protected]>
#
# 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 unittest
import os
# import logging
from revcrc.input import DataParser, InputData
__scriptdir__ = os.path.dirname(os.path.realpath(__file__))
# logging.basicConfig(level=logging.INFO)
class InputDataTest(unittest.TestCase):
def setUp(self):
# Called before testfunction is executed
pass
def tearDown(self):
# Called after testfunction was executed
pass
def test_convert(self):
data = [("E21EAB43EA0B478F52AF6E034D310D819DBC3F", "A2B0A")]
parser = InputData()
parser.convert( data )
self.assertEqual( parser.dataSize, 152 )
self.assertEqual( parser.crcSize, 20 )
self.assertIn( (5042640062004119076411731879610313259117034559L, 666378), parser.numbersList )
class DataParserTest(unittest.TestCase):
def setUp(self):
# Called before testfunction is executed
pass
def tearDown(self):
# Called after testfunction was executed
pass
def test_parse_regular(self):
parser = DataParser()
msg = "E21EAB43EA0B478F52AF6E034D310D819DBC3F A2B0A"
parser.parse(msg)
self.assertEqual( len(parser.data), 1 )
self.assertEqual( parser.data[0], ("E21EAB43EA0B478F52AF6E034D310D819DBC3F", "A2B0A") )
def test_parse_trim(self):
parser = DataParser()
msg = " E21EAB43EA0B478F52AF6E034D310D819DBC3F A2B0A "
parser.parse(msg)
self.assertEqual( len(parser.data), 1 )
self.assertEqual( parser.data[0], ("E21EAB43EA0B478F52AF6E034D310D819DBC3F", "A2B0A") )
def test_parse_full_comment(self):
parser = DataParser()
msg = " # E21EAB43EA0B478F52AF6E034D310D819DBC3F A2B0A "
parser.parse(msg)
self.assertEqual( len(parser.data), 0 )
def test_parse_full_comment2(self):
parser = DataParser()
msg = " // E21EAB43EA0B478F52AF6E034D310D819DBC3F A2B0A "
parser.parse(msg)
self.assertEqual( len(parser.data), 0 )
def test_parse_end_comment(self):
parser = DataParser()
msg = " E21EAB43EA0B478F52AF6E034D310D819DBC3F A2B0A #xxx "
parser.parse(msg)
self.assertEqual( len(parser.data), 1 )
self.assertEqual( parser.data[0], ("E21EAB43EA0B478F52AF6E034D310D819DBC3F", "A2B0A") )
if __name__ == "__main__":
unittest.main()
|
import numpy as np
from abc import ABCMeta, abstractmethod
class Grad(metaclass=ABCMeta):
@abstractmethod
def eta(self, dEdW, dEdB, ap=np):
"""
学習係数η(イータ)を返します
:param dEdW: ∂E/∂W
:param dEdB: ∂E/∂b
:param ap: numpy or cupy
:return: 学習係数
"""
pass
class Static(Grad):
"""
常に、コンストラクタで与えた係数を返します
"""
def __init__(self, rate=0.001):
self.rate = rate
self.hw = None
self.hb = None
def eta(self, dEdW, dEdB, ap=np):
if self.hw is not None:
return self.hw, self.hb
self.hw = [None]
self.hb = [None]
h = self.rate
for idx in range(1, len(dEdW)):
self.hw.append(h * ap.ones_like(dEdW[idx]))
self.hb.append(h * ap.ones_like(dEdB[idx]))
return self.hw, self.hb
class Shrink(Grad):
"""
呼ばれた回数tを数えていて、コンストラクタで与えた係数/t+1 を返します
"""
def __init__(self, rate=0.001):
self.rate = rate
self.cnt = 0.0
def eta(self, dEdW, dEdB, ap=np):
hw = [None]
hb = [None]
self.cnt += 1.0
h = self.rate / self.cnt # これは rate / (cnt+1)
for idx in range(1, len(dEdW)):
hw.append(h * ap.ones_like(dEdW[idx]))
hb.append(h * ap.ones_like(dEdB[idx]))
return hw, hb
|
#Yannick p7e9 Escribe un programa que pida dos palabras las pase como parámetro a un procedimiento y diga si riman o no. Si coinciden las tres últimas letras tiene que decir que riman. Si coinciden sólo las dos últimas tiene que decir que riman un poco y si no, que no riman.
def comprobarRima(palabra1, palabra2):
if palabra1[-3:] == palabra2[-3:]:
resultado = f"Las palabras {palabra1} y {palabra2} riman"
elif palabra1[-2:] == palabra2[-2:]:
resultado = f"Las palabras {palabra1} y {palabra2} riman un poco"
else:
resultado = f"Las palabras {palabra1} y {palabra2} no riman"
return resultado
palabraUno = input("Escribe una palabra")
palabraDos = input("Escribe otra palabra")
print(comprobarRima(palabraUno, palabraDos))
|
import typing as tp
from satella.coding.typing import U, K
import bisect
def linear_interpolate(series: tp.Sequence[tp.Tuple[K, U]], t: K,
clip: bool = False) -> U:
"""
Given a sorted (ascending) series of (t_value, y_value) interpolating linearly a function of
y=f(t) compute a linear approximation of f at t
of two closest values.
t must be larger or equal to t_min and smaller or equal to t_max
:param series: series of (t, y) sorted by t ascending
:param t: t to compute the value for
:param clip: if set to True, then values t: t<t_min f(t_min) will be returned
and for values t: t>t_max f(t_max) will be returned
:return: return value
:raise ValueError: t was smaller than t_min or greater than t_max
"""
if t < series[0][0]:
if clip:
return series[0][1]
else:
raise ValueError('t smaller than t_min')
elif t > series[-1][0]:
if clip:
return series[-1][1]
else:
raise ValueError('t greater than t_max')
if t == series[0][0]:
v = series[0][1]
else:
i = bisect.bisect_left([y[0] for y in series], t) - 1
if i == len(series) - 1:
v = series[-1][1]
else:
t1, v1 = series[i]
t2, v2 = series[i + 1]
assert t1 <= t <= t2, 'Series not sorted!'
v = (v2 - v1) / (t2 - t1) * (t - t1) + v1
return v
|
import torch
from function import graph
from apex import amp
class FwdLossBwdTrainer():
def __init__(self, args, grad_scaler):
super(FwdLossBwdTrainer, self).__init__()
self.args = args
self.grad_scaler = grad_scaler
self.capture_stream = torch.cuda.Stream()
self.send_stats_in_parallel = False
self.stats_stream = torch.cuda.Stream()
self.loss_cpu = torch.tensor(0.0, dtype=torch.float32, device='cpu').pin_memory()
self.mlm_acc_cpu = torch.tensor(0.0, dtype=torch.float32, device='cpu').pin_memory()
def capture_bert_model_segment_graph(self, bert_model, use_cuda_graph):
# eval batch depends on the rank, since eval sample count isn't divisible by world size
rank = torch.distributed.get_rank()
world_size = torch.distributed.get_world_size()
eval_batch_min = self.args.num_eval_examples // world_size
remainder = self.args.num_eval_examples % world_size
if rank<remainder:
eval_batch = eval_batch_min + 1
else:
eval_batch = eval_batch_min
eval_batch = min(eval_batch, self.args.eval_batch_size)
batches_to_graph = [eval_batch, self.args.train_batch_size]
bert_model_segment = bert_model.bert_model_segment
sample_model_train = [
torch.ones(self.args.train_batch_size, self.args.max_seq_length, dtype=torch.int64, device=self.args.device),
torch.ones(self.args.train_batch_size, self.args.max_seq_length, dtype=torch.int64, device=self.args.device),
torch.ones(self.args.train_batch_size, self.args.max_seq_length, dtype=torch.int64, device=self.args.device),
]
sample_model_eval = [
torch.ones(eval_batch, self.args.max_seq_length, dtype=torch.int64, device=self.args.device),
torch.ones(eval_batch, self.args.max_seq_length, dtype=torch.int64, device=self.args.device),
torch.ones(eval_batch, self.args.max_seq_length, dtype=torch.int64, device=self.args.device),
]
bert_model_segment = graph(bert_model_segment,
tuple(t.clone() for t in sample_model_train),
tuple(t.clone() for t in sample_model_eval) if self.args.eval_batch_size * world_size >= self.args.num_eval_examples else None,
self.capture_stream,
warmup_iters=8,
warmup_only=(not use_cuda_graph))
bert_head_segment = bert_model.heads_only_segment
sample_head_train = [
torch.ones(self.args.train_batch_size, self.args.max_seq_length, 1024, dtype=torch.float16, device=self.args.device),
torch.ones(self.args.train_batch_size, 1024, dtype=torch.float16, device=self.args.device),
torch.ones(self.args.train_batch_size, self.args.max_seq_length, dtype=torch.int64, device=self.args.device),
torch.ones(self.args.train_batch_size, dtype=torch.int64, device=self.args.device),
]
sample_head_eval = [
torch.ones(eval_batch, self.args.max_seq_length, 1024, dtype=torch.float16, device=self.args.device),
torch.ones(eval_batch, 1024, dtype=torch.float16, device=self.args.device),
torch.ones(eval_batch, self.args.max_seq_length, dtype=torch.int64, device=self.args.device),
torch.ones(eval_batch, dtype=torch.int64, device=self.args.device),
]
sample_head_tuple_train = tuple([sample_head_train[0].clone().requires_grad_(), sample_head_train[1].clone().requires_grad_(), sample_head_train[2].clone(), sample_head_train[3].clone()])
sample_head_tuple_eval = tuple([sample_head_eval[0].clone(), sample_head_eval[1].clone(), sample_head_eval[2].clone(), sample_head_eval[3].clone()])
bert_head_segment = graph(bert_head_segment,
sample_head_tuple_train,
sample_head_tuple_eval if self.args.eval_batch_size * world_size >= self.args.num_eval_examples else None,
self.capture_stream,
warmup_iters=8,
warmup_only=(not use_cuda_graph))
return bert_model
def eval_step(self, batch, model):
model.eval()
input_ids, segment_ids, input_mask, masked_lm_labels, next_sentence_labels = batch
loss = None
mlm_acc = None
loss, mlm_acc, num_valid = model(input_ids, segment_ids, input_mask,
masked_lm_labels, next_sentence_labels)
return loss, mlm_acc, num_valid
def step(self, step, batch, model, optimizer):
input_ids, segment_ids, input_mask, masked_lm_labels, next_sentence_labels = batch
loss = None
mlm_acc = None
loss, mlm_acc, _ = model(input_ids, segment_ids, input_mask,
masked_lm_labels, next_sentence_labels)
if self.send_stats_in_parallel:
self.stats_stream.wait_stream(torch.cuda.current_stream())
with torch.cuda.stream(self.stats_stream):
self.loss_cpu.copy_(loss.detach(), non_blocking=True)
self.mlm_acc_cpu.copy_(mlm_acc.detach(), non_blocking=True)
if self.args.bypass_amp:
loss.backward()
elif self.args.distributed_lamb:
optimizer._lazy_init_stage1()
self.grad_scaler.scale(loss).backward()
optimizer._lazy_init_stage2()
else:
with amp.scale_loss(loss, optimizer, delay_overflow_check=self.args.allreduce_post_accumulation) as scaled_loss:
scaled_loss.backward()
if self.send_stats_in_parallel:
self.stats_stream.synchronize()
loss = self.loss_cpu
mlm_acc = self.mlm_acc_cpu
return loss, mlm_acc
|
from django.contrib.auth import authenticate, login
from django.contrib.auth.backends import ModelBackend
from django.db.models import Q
from django.shortcuts import render
from django.views.generic.base import View
from .forms import LoginForm
from users.models import UserProfile
class CustomBackend(ModelBackend):
"""
邮箱和用户名都可以登录
继承基础ModelBackend类, 因为有authenticate方法
"""
def authenticate(self, request, username=None, password=None, **kwargs):
try:
# 不希望用户存在两个，get只能有一个。两个是get失败的一种原因 Q为使用并集查询
user = UserProfile.objects.get(Q(username=username) | Q(email=username))
if user.check_password(password):
return user
except Exception as e:
print(e)
return None
class LoginView(View):
def get(self, request):
return render(request, 'login.html')
def post(self, request):
# 实例化表单验证
login_form = LoginForm(request.POST)
if login_form.is_valid():
# 获取用户提交的用户名和密码
user_name = request.POST.get('username', None)
pass_word = request.POST.get('password', None)
# 成功返回user对象, 失败None
user = authenticate(username=user_name, password=pass_word)
if user is not None:
# 验证成功
# 登录
login(request, user)
return render(request, 'index.html')
else:
# 验证失败
return render(request, 'login.html', {'msg': '用户名或密码错误', 'login_form': login_form})
else:
return render(request, 'login.html', {'login_form': login_form})
# def user_login(request):
# """用户名密码登录"""
# if request.method == "POST":
# # 获取用户提交的用户名和密码
# user_name = request.POST.get('username', None)
# password = request.POST.get('password', None)
# # 成功返回user对象, 失败None
# user = authenticate(username=user_name, password=password)
# # 如果不是null说明验证成功
# if user is not None:
# # 登录
# login(request, user)
# return render(request, 'index.html')
# else:
# return render(request, 'login.html', {'msg': '用户名或密码错误'})
#
# elif request.method == 'GET':
# return render(request, 'login.html')
|
import praw
import pandas as pd
import numpy as np
from praw.models import MoreComments
import string
class Scraper:
# ("memes", 10, "top")
def __init__(self, subreddit, depth, feed):
self.subreddit = subreddit
self.reddit = praw.Reddit(client_id='a6uX27rHUe4D5y9cpLZ2WQ', client_secret='_ylxW5EjPRbVE44pXgWLISQflxXU-A', user_agent='CommentSearcher')
if feed == "hot":
self.posts = self.reddit.subreddit(subreddit).hot(limit=depth)
elif feed == "top":
self.posts = self.reddit.subreddit(subreddit).top(limit=depth)
elif feed == "new":
self.posts = self.reddit.subreddit(subreddit).new(limit=depth)
self.frequencies = pd.Series(dtype=int)
# gets words to search for from input string
# - seperated by spaces except when in quotation marks
def getWords(self, wordbank):
words = []
wordbank = wordbank.strip()
word = ""
for i in wordbank:
if i == "\n":
continue
if i == " ":
if word != "":
word = word.lower()
word = word.translate(str.maketrans('','', string.punctuation))
words.append(word)
word = ""
else:
word += i
if(word != ""):
word = word.lower()
word = word.translate(str.maketrans('','', string.punctuation))
words.append(word)
return words
def countInstances(self, baseStr, strToFind):
baseStr = baseStr.lower()
strToFind = strToFind.lower()
index = 0
count = 0
while baseStr.find(strToFind, index) >= 0:
#print(index)
count += 1
index = baseStr.find(strToFind, index+len(strToFind))
return count
def addToSheet(self, word):
word = str(word)
for i in range(len(self.frequencies)):
if self.frequencies.index[i] == word:
self.frequencies[i] += 1
return
newRow = pd.Series(data=[1], index=[word])
#print(newRow)
#self.frequencies = self.frequencies.append(newRow, ignore_index = False)
self.frequencies = pd.concat([self.frequencies, newRow])
#print(self.frequencies)
def commentWordAnalysis(self):
total = 0
it = 0
f = open("WordFrequencies.csv", "w")
f.close()
for post in self.posts:
print("post: " + str(it))
it += 1
# if(it % 10 == 0):
# self.frequencies.to_csv("WordFrequencies.csv")
post.comments.replace_more(limit=10)
print("expanded - comments: " + str(len(post.comments.list())))
for comment in post.comments.list():
print("next comment")
if isinstance(comment, MoreComments):
continue
words = self.getWords(comment.body)
for i in words:
self.addToSheet(i)
self.frequencies.to_csv("WordFrequencies.csv")
print(self.frequencies)
|
from Game import Game
from Player import Player
class Listener:
def __init__(self, game):
if type(game) != Game:
return print("[ERRO]: Esse módulo só pode ser construído pelo módulo Game!")
else:
game.listener = self
self.__game__ = game
game.__listeners__ = {}
def __addListener__(self, listener):
try:
self.__game__.__listeners__[listener["Event"]].append(listener["Callback"])
except KeyError:
self.__game__.__listeners__[listener["Event"]] = []
self.__game__.__listeners__[listener["Event"]].append(listener["Callback"])
def onPlayerJoin(self, callback):
event = {
"Event": "PlayerJoin",
"Callback": callback
}
self.__addListener__(event)
def onPlayerUpdate(self, callback):
event = {
"Event": "PlayerUpdate",
"Callback": callback
}
self.__addListener__(event)
def onPlayerLeave(self, callback):
event = {
"Event": "PlayerLeave",
"Callback": callback
}
self.__addListener__(event)
class Emitter:
def __init__(self, game):
if type(game) != Game:
return print("[ERRO]: Esse módulo só pode ser construído pelo módulo Game!")
else:
game.emitter = self
self.__game__ = game
game.__require__(Listener)
def __emit__(self, event):
try:
if self.__game__.__listeners__[event["Event"]]:
for i in self.__game__.__listeners__[event["Event"]]:
i(event["Data"])
except KeyError:
print("KeyError: Invalid key ... " + str(event["Event"]))
def playerUpdate(self, player):
if type(player) != Player:
return print("[ERRO]: O objeto 'player' precisa ser uma instância de Player!")
else:
event = {
"Event": "PlayerUpdate",
"Data": {
"Player": player
}
}
self.__emit__(event) |
# Copyright (c) 2018 Cole Nixon
# 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.
# pip/Homebrew imports
from flask import Flask, request, render_template, flash, redirect, url_for, session, logging
from flask_mysqldb import MySQL
from wtforms import Form, StringField, IntegerField, TextAreaField, PasswordField, validators
from passlib.hash import sha256_crypt
from functools import wraps
import requests, sys, json, re
# Personal imports
from myForms import PageForm, CommentForm, RegisterForm, BookForm, OrderForm
from keys import pwinty_id, pwinty_key, maps_key
if len(sys.argv) != 2:
print("\tThis program expects a single argument, <databaseName> to be passed in.\n")
print("\tPlease execute with format :\t python app.py <databaseName>")
sys.exit()
pwinty_headers = {'Content-type': 'application/json',
'accept': 'application/json',
'X-Pwinty-MerchantId': pwinty_id,
'X-Pwinty-REST-API-Key': pwinty_key
}
baseurl = "https://sandbox.pwinty.com/v3.0"
order_p = "/orders"
image_p = "/orders/{}/images"
order_status_p = "/orders/{}/SubmissionStatus"
order_submission_p = "/orders/{}/status"
app = Flask(__name__)
# Config MySQL
app.config['MYSQL_HOST'] = 'localhost'
app.config['MYSQL_USER'] = 'root'
app.config['MYSQL_DB'] = sys.argv[1]
app.config['MYSQL_CURSORCLASS'] = 'DictCursor'
# Init MySQL
mysql = MySQL(app)
start_up = 0
# Wraps for Access control
def user_logged_in(f):
@wraps(f)
def wrap(*args, **kwargs):
if 'logged_in' in session:
return f(*args, **kwargs)
else:
flash('Unauthorized, Please Login', 'danger')
return redirect(url_for('login'))
return wrap
@app.route('/')
def index():
global start_up
if start_up == 0:
cursorOnInit = mysql.connection.cursor()
try:
cursorOnInit.execute("SELECT * from USERS")
except:
cursorOnInit.execute(
"CREATE TABLE users(id INT(11) auto_increment primary key, email VARCHAR(100), username VARCHAR(30), password VARCHAR(100), register_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP)")
cursorOnInit.execute(
"CREATE TABLE books(id INT(11) auto_increment primary key, title VARCHAR(100), bio TEXT, author VARCHAR(50), owner VARCHAR(100), userId INT(11), FOREIGN KEY(userId) REFERENCES users(id) ON DELETE CASCADE, date_added TIMESTAMP DEFAULT CURRENT_TIMESTAMP)")
cursorOnInit.execute(
"CREATE TABLE comments(id INT(11) auto_increment primary key, page INT(6) NOT NULL, body TEXT, owner VARCHAR(100), userId INT(11), FOREIGN KEY(userId) REFERENCES users(id) ON DELETE CASCADE, bookId INT(11), FOREIGN KEY(bookId) REFERENCES books(id) ON DELETE CASCADE, date_added TIMESTAMP DEFAULT CURRENT_TIMESTAMP, lat FLOAT(10,7), lng FLOAT(10,7)) ")
start_up = 1
return render_template('home.html')
@app.route('/about')
def about():
return render_template('about.html')
# All books a user has control over
@app.route('/books')
@user_logged_in
def books():
# Get the books
cur = mysql.connection.cursor()
result = cur.execute("SELECT * FROM books WHERE userId = %s", [session['userId']])
if result > 0:
allbooks = cur.fetchall()
return render_template('booksHome.html', allbooks=allbooks)
else:
msg = 'No Books for you!'
return render_template('booksHome.html', msg=msg)
# Close it
cur.close()
# Page for a book
@app.route('/books/<int:id>', methods=['GET', 'POST'])
@user_logged_in
def book(id):
# Set variable for page to filter comments
currentPage = 0
pageForm = PageForm(request.form)
if request.method == 'POST' and pageForm.validate():
currentPage = pageForm.currentPage.data
# grab comments from MySQL
cur = mysql.connection.cursor()
result = cur.execute("SELECT * FROM books WHERE id = %s", [id])
if result > 0:
book = cur.fetchone()
result = cur.execute("SELECT * FROM comments WHERE bookId = %s ORDER BY page", [book['id']])
if result > 0:
comments = cur.fetchall()
return render_template('book.html', book=book, comments=comments, pageForm=pageForm,
currentPage=currentPage, maps_key=maps_key)
else:
msg = "No comments here yet! Be the first :)"
comments = ''
return render_template('book.html', book=book, msg=msg, comments=comments, pageForm=pageForm,
currentPage=currentPage, maps_key=maps_key)
else:
error = "There is no Book with this ID"
return render_template('book.html', error=error, maps_key=maps_key)
# Cant forget!
cur.close()
# Add a comment
@app.route('/book/<int:id>/add_comment', methods=['GET', 'POST'])
@user_logged_in
def add_comment(id):
form = CommentForm(request.form)
if request.method == 'POST' and form.validate():
page = form.page.data
body = form.body.data
coords = re.sub('[()]', '', form.location.data)
latLng = coords.split(', ')
# Create cursor
cur = mysql.connection.cursor()
cur.execute("INSERT INTO comments(page, body, owner, userId, bookId, lat, lng) VALUES(%s, %s, %s, %s, %s, %s, %s)",
(int(page), body, session['username'], int(session['userId']), int(id), float(latLng[0]), float(latLng[1])))
# Commit to DB
mysql.connection.commit()
# Close connection
cur.close()
flash('Comment Added', 'success')
return redirect(url_for('book', id=id))
return render_template('add_comment.html', form=form, maps_key=maps_key)
# Login
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
# Get the form fields
username = request.form['username']
password_attempt = request.form['password']
# Get user by username
cur = mysql.connection.cursor()
result = cur.execute("SELECT * FROM users WHERE username = %s", [username])
if result > 0:
data = cur.fetchone()
password = data['password']
if sha256_crypt.verify(password_attempt, password):
session['logged_in'] = True
session['username'] = username
session['userId'] = data['id']
flash('You are logged in', 'success')
return redirect(url_for('index'))
else:
error = "Invalid Login"
return render_template('login.html', error=error)
cur.close()
else:
app.logger.info('NO USER')
error = "Invalid Login"
return render_template('login.html', error=error)
return render_template('login.html')
# User Registration
@app.route('/register', methods=['GET', 'POST'])
def register():
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
# register user
email = form.email.data
username = form.username.data
password = sha256_crypt.encrypt(str(form.password.data))
# Create cursor
cur = mysql.connection.cursor()
cur.execute("INSERT INTO users(email, username, password) VALUES(%s, %s, %s)", (email, username, password))
# Commit to DB
mysql.connection.commit()
# Close connection
cur.close()
flash('You are now registered and can log in.', 'success')
return redirect(url_for('login'))
return render_template('register.html', form=form)
@app.route('/add_book', methods=['GET', 'POST'])
@user_logged_in
def add_book():
form = BookForm(request.form)
if request.method == 'POST' and form.validate():
title = form.title.data
author = form.author.data
bio = form.bio.data
# Create cursor
cur = mysql.connection.cursor()
cur.execute("INSERT INTO books(title, author, bio, owner, userId) VALUES(%s, %s, %s, %s, %s)",
(title, author, bio, session['username'], int(session['userId'])))
# Commit to DB
mysql.connection.commit()
# Close connection
cur.close()
flash('Book Added', 'success')
return redirect(url_for('books'))
return render_template('add_book.html', form=form)
@app.route('/qr/<int:id>', methods=['GET', 'POST'])
@user_logged_in
def qrdl(id):
form = OrderForm(request.form)
if request.method == 'POST' and form.validate():
order_data = {'countryCode': 'US',
'recipientName': form.name.data,
'address1': form.address.data,
'addressTownOrCity': form.address.data,
'stateOrCounty': form.state.data,
'postalOrZipCode': form.zip.data,
'preferredShippingMethod': 'Budget'}
order_resp = requests.post(baseurl + order_p, headers=pwinty_headers, json=order_data)
if order_resp.status_code == 200:
order_id = json.loads(order_resp.text)['data']['id']
image_path = image_p.format(order_id)
image_data = {'orderId': order_id,
'sku': "M-STI-3X4",
'copies': 1,
'size': 'ShrinkToFit',
'url': 'https://api.qrserver.com/v1/create-qr-code/?data=http://localhost:5000/book/'+str(id)+'size=600x600'
}
image_resp = requests.post(baseurl+image_path, headers=pwinty_headers, json=image_data)
if image_resp.status_code == 200:
order_status_path = order_status_p.format(order_id)
status_resp = requests.get(baseurl+order_status_path, headers=pwinty_headers)
if json.loads(status_resp.text)['data']['isValid'] == True:
# finalize order
order_submission_path = order_submission_p.format(order_id)
wow = requests.post(baseurl+order_submission_path, headers=pwinty_headers, json={'status': 'Submitted'})
if wow.status_code == 200:
flash('Order Successfully Submitted. Order ID: '+str(order_id), 'success')
return redirect(url_for('books'))
return render_template('order_sticker.html', form=form)
# Redirect to the home...
@app.route('/logout')
@user_logged_in
def logout():
session.clear()
flash('Successfully logged out', 'success')
return redirect(url_for('login'))
# Actual Script...
if __name__ == '__main__':
app.secret_key = 'secret123'
app.run(debug=True) # Debug mode turns on automatic server refresh on save
|
# coding=utf-8
# author=XingLong Pan
# date=2016-11-07
import random
import requests
import configparser
import constants
from login import CookiesHelper
from page_parser import MovieParser
from utils import Utils
from storage import DbHelper
# 读取配置文件信息
config = configparser.ConfigParser()
config.read('config.ini')
# 获取模拟登录后的cookies
cookie_helper = CookiesHelper.CookiesHelper(
config['douban']['user'],
config['douban']['password']
)
cookies = cookie_helper.get_cookies()
print(cookies)
# 实例化爬虫类和数据库连接工具类
movie_parser = MovieParser.MovieParser()
db_helper = DbHelper.DbHelper()
# 读取抓取配置
START_ID = int(config['common']['start_id'])
END_ID = int(config['common']['end_id'])
# 通过ID进行遍历
for i in range(START_ID, END_ID):
headers = {'User-Agent': random.choice(constants.USER_AGENT)}
# 获取豆瓣页面(API)数据
r = requests.get(
constants.URL_PREFIX + str(i),
headers=headers,
cookies=cookies
)
r.encoding = 'utf-8'
# 提示当前到达的id(log)
print('id: ' + str(i))
1438011
# 提取豆瓣数据
movie_parser.set_html_doc(r.text)
movie = movie_parser.extract_movie_info()
# 如果获取的数据为空，延时以减轻对目标服务器的压力,并跳过。
if not movie:
Utils.Utils.delay(constants.DELAY_MIN_SECOND, constants.DELAY_MAX_SECOND)
continue
# 豆瓣数据有效，写入数据库
movie['douban_id'] = str(i)
if movie:
db_helper.insert_movie(movie)
Utils.Utils.delay(constants.DELAY_MIN_SECOND, constants.DELAY_MAX_SECOND)
# 释放资源
movie_parser = None
db_helper.close_db()
|
from django.shortcuts import render
from django.http.response import HttpResponse
from django.views.generic import TemplateView, View, ListView
from website.models import Menu, SocialLinks, Slider, About_us, Programs_Header, Programs, Events, \
News, Multimedia, Collective, Contact_us, VacancyMenu, Vacancy
# Create your views here.
class PandaSchoolBaseView(View):
def get_nav_menu_items(self):
obj = Menu.objects.filter(status=True)
return obj
def get_footer_links(self):
obj = SocialLinks.objects.filter(status=True)
return obj
def get_vacancy_menu(self):
obj = VacancyMenu.objects.all()
return obj
def get_context_data(self, **kwargs):
context = {}
context['base_menu'] = self.get_nav_menu_items()
context['footer_links'] = self.get_footer_links()
context['vacancy_list'] = self.get_vacancy_menu()
return context
class BaseIndexView(PandaSchoolBaseView):
template_name = 'html/index.html'
additional = 'home/index.html'
def get_all_sliders(self):
obj = Slider.objects.filter(status=True)
return obj
def get_last_about_us(self):
obj = About_us.objects.filter(status=True).last()
return obj
def get_programs_head(self):
obj = Programs_Header.objects.filter(status=True).last()
return obj
def get_events(self):
obj = Events.objects.filter(status=True)[:3]
return obj
def get_all_news(self):
obj = News.objects.filter(status=True)[:3]
return obj
def get_multimedia(self):
obj = Multimedia.objects.filter(status=True)[:3]
return obj
def get_collective(self):
obj = Collective.objects.filter(status=True)[:3]
return obj
def get_contact_us(self):
obj = Contact_us.objects.all().last()
return obj
def get_context_data(self, **kwargs):
context = super(BaseIndexView, self).get_context_data(**kwargs)
context['sliders'] = self.get_all_sliders()
context['about_us'] = self.get_last_about_us()
context['program_head'] = self.get_programs_head()
context['program_list'] = Programs.objects.filter(status=True)
context['event_list'] = self.get_events()
context['news_list'] = self.get_all_news()
context['multimedia_list'] = self.get_multimedia()
context['collective_list'] = self.get_collective()
context['contact_us'] = self.get_contact_us()
return context
def get(self, request):
if '/panda.' in request.build_absolute_uri():
return render(request, self.additional, self.get_context_data())
else:
return render(request, self.additional,
self.get_context_data()) # return render(request,self.template_name)
class AboutUsView(PandaSchoolBaseView):
template_name = 'html/about.html'
def get_context_data(self, **kwargs):
context = super(AboutUsView, self).get_context_data(**kwargs)
context['title'] = Menu.objects.filter(link__icontains='about').last()
context['about'] = About_us.objects.filter(status=True)
return context
def get(self, request):
return render(request, self.template_name, self.get_context_data())
class MyTemplate(TemplateView):
template_name = '404.html'
class VacancyListView(PandaSchoolBaseView,ListView):
model = Vacancy
|
from __future__ import print_function
opcodes = '''Equal
NotEqual
GreaterThan
GreaterThanOrEqual
LessThan
LessThanOrEqual
StartsWith
EndsWith
Contains
And
Or
Not
MessageSend
MakeList
MakeRecord
Return
Continue
ObjectAliasQuote
Tell
Consider
ErrorHandler
Error
Exit
LinkRepeat
RepeatNTimes
RepeatWhile
RepeatUntil
RepeatInCollection
RepeatInRange
TestIf
Add
Subtract
Multiply
Divide
Quotient
Remainder
Power
Concatenate
Coerce
Negate
GetData
PushMe
PushIt
PositionalMessageSend
MakeObjectAlias
MakeObjectAlias
MakeObjectAlias
MakeObjectAlias
MakeObjectAlias
MakeObjectAlias
MakeObjectAlias
MakeObjectAlias
MakeObjectAlias
MakeObjectAlias
MakeObjectAlias
MakeObjectAlias
MakeComp
MakeComp
MakeComp
MakeComp
MakeComp
MakeComp
MakeComp
MakeComp
MakeComp
MakeComp
MakeComp
MakeComp
MakeComp
GetData
SetData
CopyData
Undefined
Undefined
PositionalContinue
DefineActor
DefineProcedure
DefineClosure
DefineProperty
StoreResult
GetResult
Clone
Of
EndDefineActor
EndOf
EndTell
EndConsider
EndErrorHandler
HandleError
Jump
Pop
Dup
GCSwap
PushVariableExtended
PopVariableExtended
PushGlobalExtended
PopGlobalExtended
PushLiteralExtended
PushParentVariable
PopParentVariable
PushNext
PushTrue
PushFalse
PushEmpty
PushUndefined
PushMinus1
Push0
Push1
Push2
Push3
BeginTimeout
EndTimeout
BeginTransaction
EndTransaction
Undefined
Undefined
Undefined
MatchLiteral
MakeVector
None
None
None
None
None
None
None
None
None
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
Undefined
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PushVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PopVariable
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PushGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PopGlobal
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral
PushLiteral'''.split('\n')
opcodes_map = {x: i for i, x in enumerate(opcodes)}
def getSizeByIndex(x):
if x in [4,
14,
18,
21,
22,
23,
26,
28,
29,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
45,
58,
59,
83,
102,
103,
122]:
return 3
if x in [15,
53,
55,
73,
80,
81,
82,
88,
108,
120,
124]:
return 6
if x in [16,
17,
89]:
return 8
if x in [19]:
return 1
if x in [20,
30,
31,
44,
177]:
return 2
if x in [24,
49,
50,
51,
56,
57,
60,
72,
74,
75,
76,
77,
78,
84,
100,
101,
107,
109,
111,
112,
113,
118,
123]:
return 4
if x in [25,
27,
52,
54,
61,
62,
63,
64,
65,
66,
67,
68,
69,
70,
71,
79,
85,
86,
87,
91,
92,
93,
94,
95,
96,
97,
98,
99,
104,
105,
106,
110,
114,
115,
116,
117,
119]:
return 5
if x in [90]:
return 7
ConstMap = {
0x7A2: 'true',
0x792: 'false',
0x002: 'null',
# i dont know these yet, but used in AppleScript binary
0x3A2: None,
0x702: None
}
comments = {
21: 'GetProperty',
21 + 1: 'GetEvery',
21 + 2: 'GetSome',
21 + 3: 'GetIndexed (item A of B)',
21 + 4: 'GetKeyFrom',
21 + 6: 'GetRange',
21 + 9: 'GetPositionBeginning',
21 + 10: 'GetPositionEnd',
21 + 11: 'GetMiddle'
}
if __name__ == '__main__':
for i in range(256):
if opcodes[i] == 'None':
opcodes[i] = ''
print('%02x' % i, opcodes[i])
|
"""
mbed CMSIS-DAP debugger
Copyright (c) 2006-2013 ARM Limited
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from flash import Flash
import logging
flash_algo = { 'load_address' : 0x20000000,
'instructions' : [
0xE00ABE00, 0x062D780D, 0x24084068, 0xD3000040, 0x1E644058, 0x1C49D1FA, 0x2A001E52, 0x4770D1F2,
0xb510492f, 0x60084449, 0x2100482e, 0x482f6001, 0x44484a2d, 0x22016002, 0x04926041, 0x02926082,
0x220560c2, 0x61420692, 0x03122201, 0x46026182, 0x70113220, 0x62411e49, 0xf929f000, 0xd0002800,
0xbd102001, 0x47702000, 0xb5084a21, 0x0349447a, 0x0c0a9200, 0x481d4601, 0x44482300, 0xf9b7f000,
0xd0002800, 0xbd082001, 0x4919b510, 0x48174479, 0x44483920, 0xf891f000, 0xd0002800, 0xbd102001,
0x4b13b510, 0x4601447b, 0x22014810, 0x02923b38, 0xf0004448, 0x2800f8b4, 0x2001d000, 0xb538bd10,
0x490b460c, 0x39584479, 0x46019100, 0x46134807, 0x44484622, 0xf948f000, 0xd0002800, 0xbd382001,
0x00000004, 0x40048100, 0x40020000, 0x00000008, 0x00000085, 0x4604b570, 0x25006800, 0x061b7803,
0x2370d5fc, 0x20007003, 0x0003e03a, 0xfa60f000, 0x0f0b070c, 0x1f1b1713, 0x2f2b2723, 0x68263633,
0x71f37813, 0x6826e02a, 0x71b37853, 0x6826e026, 0x71737893, 0x6826e022, 0x713378d3, 0x6826e01e,
0x72f37913, 0x6826e01a, 0x72b37953, 0x6826e016, 0x72737993, 0x6826e012, 0x723379d3, 0x6826e00e,
0x73f37a13, 0x6826e00a, 0x73b37a53, 0x6826e006, 0x73737a93, 0x6826e002, 0x73337ad3, 0xb2c01c40,
0xd9c24288, 0x20806821, 0xe0037008, 0x1c416a60, 0x4780d000, 0x78006820, 0xd5f70600, 0x78006820,
0xd5010681, 0xe0062504, 0xd50106c1, 0xe0022508, 0xd00007c0, 0x46282510, 0xb508bd70, 0x2244460b,
0x700a4669, 0x2100466a, 0xbd084798, 0x4614b538, 0xd002078a, 0x300120ff, 0x6843bd38, 0xd803428b,
0x189a6882, 0xd80d428a, 0x428a68c2, 0x6903d803, 0x428b18d3, 0x2002d801, 0x1a89bd38, 0x05d22201,
0xe0001889, 0x22081ac9, 0x701a466b, 0x705a0c0a, 0x709a0a0a, 0x466a70d9, 0x47a02103, 0xb5ffbd38,
0x4615b081, 0x27019a01, 0x26006852, 0x02bf1948, 0xd804428a, 0x689b9b01, 0x428318d3, 0x9a01d20f,
0x428a68d2, 0x9b01d804, 0x18d3691b, 0xd2014283, 0xe0292602, 0x21011a88, 0x184405c9, 0x1a8ce000,
0x46204639, 0xf907f000, 0xd0022900, 0x360126ff, 0x4639e01a, 0xf0004628, 0x2900f8fe, 0x2601d012,
0x2009e012, 0x70084669, 0x70480c20, 0x70880a20, 0x9b0470cc, 0x2103466a, 0x47989801, 0xd1030006,
0x19e41bed, 0xd1ec2d00, 0xb0054630, 0xb5f0bdf0, 0x24006801, 0x0612780a, 0x2270d5fc, 0x6802700a,
0x71d12103, 0x22806801, 0x6803718a, 0x71592100, 0x23fc6805, 0x6803712b, 0x680373d9, 0x6802701a,
0x061b7813, 0x7a55d5fc, 0x07177a12, 0x0f3f2201, 0x105603d2, 0xf000003b, 0x0910f96b, 0x09100e0b,
0x10090909, 0x09090e1f, 0x11090909, 0xe0056102, 0x03522203, 0x6106e7fa, 0x6101e000, 0x0f12072a,
0xf0000013, 0x0c10f955, 0x120f0c0c, 0x1d1b1815, 0x0c0c0c1f, 0x0d0c0c0c, 0x03522201, 0x61c1e7e6,
0xbdf04620, 0x02c92101, 0x2101e7f9, 0xe7f60289, 0x02492101, 0x21ffe7f3, 0xe7f03101, 0xe7ee2180,
0xe7ec2140, 0xe7ea2120, 0x4607b5fe, 0x461d4616, 0x198a2000, 0xd002078b, 0x300120ff, 0x07b3bdfe,
0x2001d001, 0x687bbdfe, 0xd803428b, 0x191c68bc, 0xd20d4294, 0x428b68fb, 0x693cd803, 0x4294191c,
0x2002d201, 0x2201bdfe, 0x05d21ac9, 0xe01b188c, 0xe0191acc, 0x46692006, 0x0c207008, 0x0a207048,
0x70cc7088, 0x710878e8, 0x714878a8, 0x71887868, 0x71c87828, 0x466a9b08, 0x46382107, 0x28004798,
0x1d24d1e0, 0x1d2d1f36, 0xd1e32e00, 0xb5febdfe, 0x46044615, 0x00a86842, 0x461e1840, 0xd803428a,
0x18d368a3, 0xd808428b, 0x428b68e3, 0x6927d803, 0x428b19db, 0x2002d801, 0x4282bdfe, 0x68a3d805,
0x428318d3, 0x1a8fd301, 0x68e2e00a, 0xd9034282, 0x18d36923, 0xd3ee4283, 0x21011a88, 0x184705c9,
0x46382104, 0xf817f000, 0xd0022900, 0x300120ff, 0x2001bdfe, 0x70084669, 0x70480c38, 0x70880a38,
0x0a2870cf, 0x714d7108, 0x9b08718e, 0x2106466a, 0x47984620, 0x2200bdfe, 0x428b0903, 0x0a03d32c,
0xd311428b, 0x469c2300, 0x4603e04e, 0xd43c430b, 0x08432200, 0xd331428b, 0x428b0903, 0x0a03d31c,
0xd301428b, 0xe03f4694, 0x428b09c3, 0x01cbd301, 0x41521ac0, 0x428b0983, 0x018bd301, 0x41521ac0,
0x428b0943, 0x014bd301, 0x41521ac0, 0x428b0903, 0x010bd301, 0x41521ac0, 0x428b08c3, 0x00cbd301,
0x41521ac0, 0x428b0883, 0x008bd301, 0x41521ac0, 0x428b0843, 0x004bd301, 0x41521ac0, 0xd2001a41,
0x41524601, 0x47704610, 0x0fcae05d, 0x4249d000, 0xd3001003, 0x40534240, 0x469c2200, 0x428b0903,
0x0a03d32d, 0xd312428b, 0x018922fc, 0x0a03ba12, 0xd30c428b, 0x11920189, 0xd308428b, 0x11920189,
0xd304428b, 0xd03a0189, 0xe0001192, 0x09c30989, 0xd301428b, 0x1ac001cb, 0x09834152, 0xd301428b,
0x1ac0018b, 0x09434152, 0xd301428b, 0x1ac0014b, 0x09034152, 0xd301428b, 0x1ac0010b, 0x08c34152,
0xd301428b, 0x1ac000cb, 0x08834152, 0xd301428b, 0x1ac0008b, 0xd2d94152, 0x428b0843, 0x004bd301,
0x41521ac0, 0xd2001a41, 0x46634601, 0x105b4152, 0xd3014610, 0x2b004240, 0x4249d500, 0x46634770,
0xd300105b, 0xb5014240, 0x46c02000, 0xbd0246c0, 0x4674b430, 0x78251e64, 0x42ab1c64, 0x461dd200,
0x005b5d63, 0xbc3018e3, 0x00004718, 0xfffffffe
],
'pc_init' : 0x20000020,
'pc_eraseAll' : 0x20000088,
'pc_erase_sector' : 0x200000a0,
'pc_program_page' : 0x200000be,
'begin_stack' : 0x20001000,
'begin_data' : 0x20002000,
'static_base' : 0x200005ec,
'page_size' : 1024
};
class Flash_kl25z(Flash):
def __init__(self, target):
super(Flash_kl25z, self).__init__(target, flash_algo)
def checkSecurityBits(self, address, data):
#error if security bits have unexpected values
if (address == 0x400):
for i in range(12):
logging.debug("data[%d] at add 0x%X: 0x%X", i, i, data[i])
if (data[i] != 0xff):
return 0
logging.debug("data[%d] at add 0x%X: 0x%X", i+3, i+3, data[i+3])
logging.debug("data[%d] at add 0x%X: 0x%X", i+4, i+4, data[i+4])
if ((data[i+3] != 0xff) or (data[i+4] != 0xff)):
return 0
return 1
|
lista = []
lista.pop(0)
# IndexError: pop from empty list |
"""
Example:
>>> from wms import gui
>>> main_page = gui.MainPage()
>>> gui.intro() # Display the intro section
>>> gui.info() # Display the info on the sidebar
"""
import streamlit as st
class MainPage:
"""Main Page of the Web App
The main page displays the title, a short description, and instructions for admin
Attributes:
title: A Streamlit title of the web.
header: A Streamlit header of the web.
info_field: A Streamlit reserved field, which contains short description of the web.
"""
def __init__(self):
"""Initializes MainPage instance."""
self.title = st.empty()
self.header = st.empty()
self.info_field = st.empty()
def call(self):
"""Calls the welcome screen."""
self._welcome()
def _welcome(self):
"""Sets up the welcome screen."""
self.title.title("Wholesale Management System")
self.header.header("Welcome to the WMS of company That Boring Company.")
def intro():
"""Shows intro section."""
st.markdown("""
---\n
This is a wholesale management system project for Software Engineering course in
[International University - VNU-HCM](https://hcmiu.edu.vn/en/).\n
The web application is built with [Streamlit](https://www.streamlit.io/).\n
Source code is available at [GitHub](https://github.com/minhlong94/SWE_IT076IU).\n
""")
def info():
"""Shows info, a short summary of intro section."""
st.sidebar.markdown("""
---\n
[International University - VNU-HCM](https://hcmiu.edu.vn/en/)\n
[Streamlit](https://www.streamlit.io/)\n
[GitHub](https://github.com/minhlong94/SWE_IT076IU)\n
""")
|
#!/usr/bin/env python
#
# Copyright (c) 2017 All rights reserved
# This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Tests performed:
# - Peering OpenDaylight with Quagga:
# - Set up a Quagga instance in the functest container
# - Start a BGP router with OpenDaylight
# - Add the functest Quagga as a neighbor
# - Verify that the OpenDaylight and gateway Quagga peer
import logging
import sys
import os
from sdnvpn.lib import config as sdnvpn_config
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib.results import Results
COMMON_CONFIG = sdnvpn_config.CommonConfig()
TESTCASE_CONFIG = sdnvpn_config.TestcaseConfig(
"sdnvpn.test.functest.testcase_9")
logger = logging.getLogger('__name__')
def main():
results = Results(COMMON_CONFIG.line_length)
results.add_to_summary(0, "=")
results.add_to_summary(2, "STATUS", "SUBTEST")
results.add_to_summary(0, "=")
openstack_nodes = test_utils.get_nodes()
installer_type = str(os.environ['INSTALLER_TYPE'].lower())
# node.is_odl() doesn't work in Apex
# https://jira.opnfv.org/browse/RELENG-192
fuel_cmd = "sudo systemctl status opendaylight"
apex_cmd = "sudo docker exec opendaylight_api " \
"/opt/opendaylight/bin/status"
health_cmd = "sudo docker ps -f name=opendaylight_api -f " \
"health=healthy -q"
if installer_type in ["fuel"]:
controllers = [node for node in openstack_nodes
if "running" in node.run_cmd(fuel_cmd)]
elif installer_type in ["apex"]:
controllers = [node for node in openstack_nodes
if node.run_cmd(health_cmd)
if "Running" in node.run_cmd(apex_cmd)]
msg = ("Verify that all OpenStack nodes OVS br-int have "
"fail_mode set to secure")
results.record_action(msg)
results.add_to_summary(0, "-")
if not controllers:
msg = ("Controller (ODL) list is empty. Skipping rest of tests.")
logger.info(msg)
results.add_failure(msg)
return results.compile_summary()
else:
msg = ("Controller (ODL) list is ready")
logger.info(msg)
results.add_success(msg)
# Get fail_mode status on all nodes
fail_mode_statuses = test_utils.is_fail_mode_secure()
for node_name, status in fail_mode_statuses.iteritems():
msg = 'Node {} br-int is fail_mode secure'.format(node_name)
if status:
results.add_success(msg)
else:
results.add_failure(msg)
return results.compile_summary()
if __name__ == '__main__':
sys.exit(main())
|
#ClickKaleidoscope.py
import random
import turtle
t = turtle.Pen()
t.speed(0)
t.hideturtle()
turtle.bgcolor("black")
colors = ["red", "yellow", "blue", "green", "orange", "purple",
"white", "gray"]
def draw_kaleido(x,y):
t.pencolor(random.choice(colors))
size = random.randint(10,40)
draw_spiral(x,y, size)
draw_spiral(-x,y, size)
draw_spiral(-x,-y, size)
draw_spiral(x,-y, size)
def draw_spiral(x,y, size):
t.penup()
t.setpos(x,y)
t.pendown()
for m in range(size):
t.forward(m*2)
t.left(92)
turtle.onscreenclick(draw_kaleido)
|
#!/usr/bin/env python3
#----------------------------------------------------------------------------
# Copyright (c) 2018 FIRST. All Rights Reserved.
# Open Source Software - may be modified and shared by FRC teams. The code
# must be accompanied by the FIRST BSD license file in the root directory of
# the project.
#----------------------------------------------------------------------------
import json
import time
import sys
from cscore import CameraServer, VideoSource, UsbCamera, MjpegServer
from networktables import NetworkTablesInstance
# JSON format:
# {
# "team": <team number>,
# "ntmode": <"client" or "server", "client" if unspecified>
# "cameras": [
# {
# "name": <camera name>
# "path": <path, e.g. "/dev/video0">
# "pixel format": <"MJPEG", "YUYV", etc> // optional
# "width": <video mode width> // optional
# "height": <video mode height> // optional
# "fps": <video mode fps> // optional
# "brightness": <percentage brightness> // optional
# "white balance": <"auto", "hold", value> // optional
# "exposure": <"auto", "hold", value> // optional
# "properties": [ // optional
# {
# "name": <property name>
# "value": <property value>
# }
# ],
# "stream": { // optional
# "properties": [
# {
# "name": <stream property name>
# "value": <stream property value>
# }
# ]
# }
# }
# ]
# }
configFile = "/boot/frc.json"
class CameraConfig: pass
team = None
server = False
cameraConfigs = []
"""Report parse error."""
def parseError(str):
print("config error in '" + configFile + "': " + str, file=sys.stderr)
"""Read single camera configuration."""
def readCameraConfig(config):
cam = CameraConfig()
# name
try:
cam.name = config["name"]
except KeyError:
parseError("could not read camera name")
return False
# path
try:
cam.path = config["path"]
except KeyError:
parseError("camera '{}': could not read path".format(cam.name))
return False
# stream properties
cam.streamConfig = config.get("stream")
cam.config = config
cameraConfigs.append(cam)
return True
"""Read configuration file."""
def readConfig():
global team
global server
# parse file
try:
with open(configFile, "rt") as f:
j = json.load(f)
except OSError as err:
print("could not open '{}': {}".format(configFile, err), file=sys.stderr)
return False
# top level must be an object
if not isinstance(j, dict):
parseError("must be JSON object")
return False
# team number
try:
team = j["team"]
except KeyError:
parseError("could not read team number")
return False
# ntmode (optional)
if "ntmode" in j:
str = j["ntmode"]
if str.lower() == "client":
server = False
elif str.lower() == "server":
server = True
else:
parseError("could not understand ntmode value '{}'".format(str))
# cameras
try:
cameras = j["cameras"]
except KeyError:
parseError("could not read cameras")
return False
for camera in cameras:
if not readCameraConfig(camera):
return False
return True
"""Start running the camera."""
def startCamera(config):
print("Starting camera '{}' on {}".format(config.name, config.path))
inst = CameraServer.getInstance()
camera = UsbCamera(config.name, config.path)
server = inst.startAutomaticCapture(camera=camera, return_server=True)
camera.setConfigJson(json.dumps(config.config))
camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen)
if config.streamConfig is not None:
server.setConfigJson(json.dumps(config.streamConfig))
return camera
if __name__ == "__main__":
if len(sys.argv) >= 2:
configFile = sys.argv[1]
# read configuration
if not readConfig():
sys.exit(1)
# start NetworkTables
ntinst = NetworkTablesInstance.getDefault()
if server:
print("Setting up NetworkTables server")
ntinst.startServer()
else:
print("Setting up NetworkTables client for team {}".format(team))
ntinst.startClientTeam(team)
# start cameras
cameras = []
for cameraConfig in cameraConfigs:
cameras.append(startCamera(cameraConfig))
# loop forever
while True:
time.sleep(10)
|
"""
Provide an interface class for handling pubsub notification messages,
and an example class (though very useful in practice) showing how to
use it.
Notification messages are generated by pubsub
- if a handler has been configured via pub.addNotificationHandler()
- when pubsub does certain tasks, such as when a listener subscribes to
or unsubscribes from a topic
Derive from this class to handle notification events from
various parts of pubsub. E.g. when a listener subscribes,
unsubscribes, or dies, a notification handler, if you
specified one via pub.addNotificationHandler(), is given the
relevant information.
:copyright: Copyright since 2006 by Oliver Schoenborn, all rights reserved.
:license: BSD, see LICENSE_BSD_Simple.txt for details.
"""
from typing import List, Mapping, Any, TextIO
from ..core import TopicManager, INotificationHandler, Listener, Topic, Publisher
class IgnoreNotificationsMixin(INotificationHandler):
"""
Derive your Notifications handler from this class if your handler
just wants to be notified of one or two types of pubsub events.
Then just override the desired methods. The rest of the notifications
will automatically be ignored.
"""
def notifySubscribe(self, pubListener: Listener, topicObj: Topic, newSub: bool):
pass
def notifyUnsubscribe(self, pubListener: Listener, topicObj: Topic):
pass
def notifyDeadListener(self, pubListener: Listener, topicObj: Topic):
pass
def notifySend(self, stage: str, topicObj: Topic, pubListener: Listener = None):
pass
def notifyNewTopic(self, topicObj: Topic, description: str, required: List[str], argsDocs: Mapping[str, str]):
pass
def notifyDelTopic(self, topicName: str):
pass
class NotifyByWriteFile(INotificationHandler):
"""
Print a message to stdout when a notification is received.
"""
defaultPrefix = 'PUBSUB:'
def __init__(self, fileObj: TextIO = None, prefix: str = None):
"""
Will write to stdout unless fileObj given. Will use
defaultPrefix as prefix for each line output, unless prefix
specified.
"""
self.__pre = prefix or self.defaultPrefix
if fileObj is None:
import sys
self.__fileObj = sys.stdout
else:
self.__fileObj = fileObj
def changeFile(self, fileObj):
self.__fileObj = fileObj
def notifySubscribe(self, pubListener: Listener, topicObj: Topic, newSub: bool):
if newSub:
msg = '%s Subscribed listener "%s" to topic "%s"\n'
else:
msg = '%s Subscription of "%s" to topic "%s" redundant\n'
msg = msg % (self.__pre, pubListener, topicObj.getName())
self.__fileObj.write(msg)
def notifyUnsubscribe(self, pubListener: Listener, topicObj: Topic):
msg = '%s Unsubscribed listener "%s" from topic "%s"\n'
msg = msg % (self.__pre, pubListener, topicObj.getName())
self.__fileObj.write(msg)
def notifyDeadListener(self, pubListener: Listener, topicObj: Topic):
msg = '%s Listener "%s" of Topic "%s" has died\n' \
% (self.__pre, pubListener, topicObj.getName())
# a bug apparently: sometimes on exit, the stream gets closed before
# and leads to a TypeError involving NoneType
self.__fileObj.write(msg)
def notifySend(self, stage: str, topicObj: Topic, pubListener: Listener = None):
if stage == 'in':
msg = '%s Sending message of topic "%s" to listener %s\n' % (self.__pre, topicObj.getName(), pubListener)
elif stage == 'pre':
msg = '%s Start sending message of topic "%s"\n' % (self.__pre, topicObj.getName())
else:
msg = '%s Done sending message of topic "%s"\n' % (self.__pre, topicObj.getName())
self.__fileObj.write(msg)
def notifyNewTopic(self, topicObj: Topic, description: str, required: List[str], argsDocs: Mapping[str, str]):
msg = '%s New topic "%s" created\n' % (self.__pre, topicObj.getName())
self.__fileObj.write(msg)
def notifyDelTopic(self, topicName: str):
msg = '%s Topic "%s" destroyed\n' % (self.__pre, topicName)
self.__fileObj.write(msg)
class NotifyByPubsubMessage(INotificationHandler):
"""
Handle pubsub notification messages by generating
messages of a 'pubsub.' subtopic. Also provides
an example of how to create a notification handler.
Use it by calling::
import pubsub.utils
pubsub.utils.useNotifyByPubsubMessage()
...
pub.setNotificationFlags(...) # optional
E.g. whenever a listener is unsubscribed, a 'pubsub.unsubscribe'
message is generated. If you have subscribed a listener of
this topic, your listener will be notified of what listener
unsubscribed from what topic.
"""
topicRoot = 'pubsub'
topics = dict(
send='%s.sendMessage' % topicRoot,
subscribe='%s.subscribe' % topicRoot,
unsubscribe='%s.unsubscribe' % topicRoot,
newTopic='%s.newTopic' % topicRoot,
delTopic='%s.delTopic' % topicRoot,
deadListener='%s.deadListener' % topicRoot)
def __init__(self, topicMgr: TopicManager = None):
self._pubTopic = None
self.__sending = False # used to guard against infinite loop
if topicMgr is not None:
self.createNotificationTopics(topicMgr)
def createNotificationTopics(self, topicMgr: TopicManager):
"""
Create the notification topics. The root of the topics created
is self.topicRoot. The topicMgr is (usually) pub.topicMgr.
"""
# see if the special topics have already been defined
try:
topicMgr.getTopic(self.topicRoot)
except ValueError:
# no, so create them
self._pubTopic = topicMgr.getOrCreateTopic(self.topicRoot)
self._pubTopic.setDescription('root of all pubsub-specific topics')
_createTopics(self.topics, topicMgr)
def notifySubscribe(self, pubListener: Listener, topicObj: Topic, newSub: bool):
if (self._pubTopic is None) or self.__sending:
return
pubTopic = self._pubTopic.getSubtopic('subscribe')
if topicObj is not pubTopic:
kwargs = dict(listener=pubListener, topic=topicObj, newSub=newSub)
self.__doNotification(pubTopic, kwargs)
def notifyUnsubscribe(self, pubListener: Listener, topicObj: Topic):
if (self._pubTopic is None) or self.__sending:
return
pubTopic = self._pubTopic.getSubtopic('unsubscribe')
if topicObj is not pubTopic:
kwargs = dict(
topic=topicObj,
listenerRaw=pubListener.getCallable(),
listener=pubListener)
self.__doNotification(pubTopic, kwargs)
def notifyDeadListener(self, pubListener: Listener, topicObj: Topic):
if (self._pubTopic is None) or self.__sending:
return
pubTopic = self._pubTopic.getSubtopic('deadListener')
kwargs = dict(topic=topicObj, listener=pubListener)
self.__doNotification(pubTopic, kwargs)
def notifySend(self, stage: str, topicObj: Topic, pubListener: Listener = None):
"""
Stage must be 'pre' or 'post'. Note that any pubsub sendMessage
operation resulting from this notification (which sends a message;
listener could handle by sending another message!) will NOT themselves
lead to a send notification.
"""
if (self._pubTopic is None) or self.__sending:
return
sendMsgTopic = self._pubTopic.getSubtopic('sendMessage')
if stage == 'pre' and (topicObj is sendMsgTopic):
msg = 'Not allowed to send messages of topic %s' % topicObj.getName()
raise ValueError(msg)
self.__doNotification(sendMsgTopic, dict(topic=topicObj, stage=stage))
def notifyNewTopic(self, topicObj: Topic, description: str, required: List[str], argsDocs: Mapping[str, str]):
if (self._pubTopic is None) or self.__sending:
return
pubTopic = self._pubTopic.getSubtopic('newTopic')
kwargs = dict(topic=topicObj, description=description, required=required, args=argsDocs)
self.__doNotification(pubTopic, kwargs)
def notifyDelTopic(self, topicName: str):
if (self._pubTopic is None) or self.__sending:
return
pubTopic = self._pubTopic.getSubtopic('delTopic')
self.__doNotification(pubTopic, dict(name=topicName))
def __doNotification(self, pubTopic: Topic, kwargs: Mapping[str, Any]):
self.__sending = True
try:
pubTopic.publish(**kwargs)
finally:
self.__sending = False
def _createTopics(topicMap: Mapping[str, str], topicMgr: TopicManager):
"""
Create notification topics. These are used when some of the notification flags have been set to True (see
pub.setNotificationFlags(). The topicMap is a dict where key is the notification type, and value is the topic
name to create. Notification type is a string in ('send', 'subscribe', 'unsubscribe', 'newTopic', 'delTopic',
'deadListener').
"""
def newTopic(_name, _desc, _required=None, **argsDocs):
topic = topicMgr.getOrCreateTopic(_name)
topic.setDescription(_desc)
topic.setMsgArgSpec(argsDocs, _required)
newTopic(
_name=topicMap['subscribe'],
_desc='whenever a listener is subscribed to a topic',
topic='topic that listener has subscribed to',
listener='instance of pub.Listener containing listener',
newSub='false if listener was already subscribed, true otherwise')
newTopic(
_name=topicMap['unsubscribe'],
_desc='whenever a listener is unsubscribed from a topic',
topic='instance of Topic that listener has been unsubscribed from',
listener='instance of pub.Listener unsubscribed; None if listener not found',
listenerRaw='listener unsubscribed')
newTopic(
_name=topicMap['send'],
_desc='sent at beginning and end of sendMessage()',
topic='instance of topic for message being sent',
stage='stage of send operation: "pre" or "post" or "in"',
listener='which listener being sent to')
newTopic(
_name=topicMap['newTopic'],
_desc='whenever a new topic is defined',
topic='instance of Topic created',
description='description of topic (use)',
args='the argument names/descriptions for arguments that listeners must accept',
required='which args are required (all others are optional)')
newTopic(
_name=topicMap['delTopic'],
_desc='whenever a topic is deleted',
name='full name of the Topic instance that was destroyed')
newTopic(
_name=topicMap['deadListener'],
_desc='whenever a listener dies without having unsubscribed',
topic='instance of Topic that listener was subscribed to',
listener='instance of pub.Listener containing dead listener')
def useNotifyByPubsubMessage(publisher: Publisher = None, all: bool = True, **kwargs):
"""
Will cause all of pubsub's notifications of pubsub "actions" (such as
new topic created, message sent, listener subscribed, etc) to be sent
out as messages. Topic will be 'pubsub' subtopics, such as
'pubsub.newTopic', 'pubsub.delTopic', 'pubsub.sendMessage', etc.
The 'all' and kwargs args are the same as pubsub's setNotificationFlags(),
except that 'all' defaults to True.
The publisher is rarely needed:
* The publisher must be specfied if pubsub is not installed
on the system search path (ie from pubsub import ... would fail or
import wrong pubsub -- such as if pubsub is within wxPython's
wx.lib package). Then pbuModule is the pub module to use::
from wx.lib.pubsub import pub
from wx.lib.pubsub.utils import notification
notification.useNotifyByPubsubMessage()
"""
if publisher is None:
from .. import pub
publisher = pub.getDefaultPublisher()
topicMgr = publisher.getTopicMgr()
notifHandler = NotifyByPubsubMessage(topicMgr)
publisher.addNotificationHandler(notifHandler)
publisher.setNotificationFlags(all=all, **kwargs)
def useNotifyByWriteFile(fileObj: TextIO = None, prefix: str = None, publisher: Publisher = None, all: bool = True,
**kwargs):
"""
Will cause all pubsub notifications of pubsub "actions" (such as new topic created, message sent, listener died
etc) to be written to specified file (or stdout if none given). The fileObj need only provide a 'write(string)'
method.
The first two arguments are the same as those of NotifyByWriteFile constructor. The 'all' and kwargs arguments
are those of pubsub's setNotificationFlags(), except that 'all' defaults to True. See useNotifyByPubsubMessage()
for an explanation of pubModule (typically only if pubsub inside wxPython's wx.lib)
"""
if publisher is None:
from .. import pub
publisher = pub.getDefaultPublisher()
notifHandler = NotifyByWriteFile(fileObj, prefix)
publisher.addNotificationHandler(notifHandler)
publisher.setNotificationFlags(all=all, **kwargs)
|
from src.video_processing import VideoProcessing
from src.drone_control import Drone
from dronekit import VehicleMode
import time, numpy as np, pathlib
CAM_ASPECT_RATIO = 16.0 / 9.0
INPUT_IMG_SIZE = 224
gstream_pipeline = (
"nvarguscamerasrc ! "
"video/x-raw(memory:NVMM), "
"width=(int){capture_width:d}, height=(int){capture_height:d}, "
"format=(string)NV12, framerate=(fraction){framerate:d}/1 ! "
"nvvidconv top={crop_top:d} bottom={crop_bottom:d} left={crop_left:d} right={crop_right:d} flip-method={flip_method:d} ! "
"video/x-raw, width=(int){display_width:d}, height=(int){display_height:d}, format=(string)BGRx ! "
"videoconvert ! "
"video/x-raw, format=(string)BGR ! appsink".format(
capture_width=int(INPUT_IMG_SIZE * CAM_ASPECT_RATIO),
capture_height=INPUT_IMG_SIZE,
framerate=60,
crop_top=0,
crop_bottom=INPUT_IMG_SIZE,
crop_left=int(INPUT_IMG_SIZE * (CAM_ASPECT_RATIO - 1) / 2),
crop_right=int(INPUT_IMG_SIZE * (CAM_ASPECT_RATIO + 1) / 2),
flip_method=0,
display_width=INPUT_IMG_SIZE,
display_height=INPUT_IMG_SIZE,
)
)
print(gstream_pipeline)
MODELS_PATH = pathlib.Path(".") / "drone-gesture-control" / "models"
video_processing = VideoProcessing(
gstream_def=gstream_pipeline,
estimation_mode_path=str(MODELS_PATH / "resnet18_baseline_att_224x224_trt.pth"),
classification_mode_path=str(MODELS_PATH / "Robust_BODY18_TRT"),
topology_path=str(MODELS_PATH / "human_pose.json"),
labels_path=str(MODELS_PATH / "Robust_BODY18_info.json"),
)
drone = Drone(serial_address="/dev/ttyTHS1", baud=57600)
THRESHOLD_ALT = 0.3
last_label = video_processing.get_pose()
print("\n### RUNNING ###\n")
try:
while True:
latest_label = video_processing.get_pose()
if latest_label == last_label:
label = None
else:
label = latest_label
last_label = latest_label
if label and (drone.vehicle.mode.name == "GUIDED"):
if label == "T":
if not drone.vehicle.armed: # Arm
drone.vehicle.armed = True
else:
if (
drone.vehicle.location.global_relative_frame.alt < THRESHOLD_ALT
): # Disarm if landed
drone.vehicle.armed = False
elif (label == "Traffic_AllStop") and drone.vehicle.armed:
if (
drone.vehicle.location.global_relative_frame.alt < THRESHOLD_ALT
): # Take off if landed
takeoff_alt = 1.8
drone.vehicle.simple_takeoff(takeoff_alt) # Take off at two meters
while drone.vehicle.location.global_relative_frame.alt < (
takeoff_alt - THRESHOLD_ALT
): # Wait to reach altitude
time.sleep(0.3)
# print("Altitude: ", vehicle.location.global_relative_frame.alt)
else:
if drone.vehicle.location.global_relative_frame.alt > THRESHOLD_ALT:
drone.vehicle.mode = VehicleMode("LAND")
# Go right
elif (label == "Traffic_RightTurn") and drone.vehicle.armed:
x, y = 0.0, 2.0 # meters
yaw = drone.vehicle.attitude.yaw
drone.send_global_velocity(
x * np.cos(yaw) - y * np.sin(yaw),
x * np.sin(yaw) + y * np.cos(yaw),
0,
2,
)
drone.send_global_velocity(0, 0, 0, 1)
# Go left
elif (label == "Traffic_LeftTurn") and drone.vehicle.armed:
x, y = 0.0, -2.0 # meters
yaw = drone.vehicle.attitude.yaw
drone.send_global_velocity(
x * np.cos(yaw) - y * np.sin(yaw),
x * np.sin(yaw) + y * np.cos(yaw),
0,
2,
)
drone.send_global_velocity(0, 0, 0, 1)
# Go back
elif (label == "Traffic_BackFrontStop") and drone.vehicle.armed:
x, y = -2.0, 0.0 # meters
yaw = drone.vehicle.attitude.yaw
drone.send_global_velocity(
x * np.cos(yaw) - y * np.sin(yaw),
x * np.sin(yaw) + y * np.cos(yaw),
0,
2,
)
drone.send_global_velocity(0, 0, 0, 1)
# Go front
elif (
label == "Traffic_FrontStop" or label == "Stand_RightArmRaised"
) and drone.vehicle.armed:
x, y = 2.0, 0.0 # meters
yaw = drone.vehicle.attitude.yaw
drone.send_global_velocity(
x * np.cos(yaw) - y * np.sin(yaw),
x * np.sin(yaw) + y * np.cos(yaw),
0,
2,
)
drone.send_global_velocity(0, 0, 0, 1)
elif (label == "Yoga_UpwardSalute") and drone.vehicle.armed:
drone.vehicle.mode = VehicleMode("RTL")
# elif label == "rotate right":
# drone.condition_yaw(45,relative=True)
# elif label == "rotate left":
# drone.condition_yaw(315,relative=True)
time.sleep(0.25)
print(
"FPS: {fps:.2f}\tCurrent label: {lab1}\tSend order: {lab2}".format(
fps=video_processing.get_fps(), lab1=latest_label, lab2=label
).ljust(80)[:80],
end="\r",
)
except:
video_processing.cap.release()
video_processing.video_recording.release()
print("Video processing stopped")
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
def main():
_ = int(input())
A = set(map(int, input().split()))
for _ in range(int(input())):
command, _ = input().split()
B = set(map(int, input().split()))
getattr(A, command)(B)
print(sum(A))
if __name__ == '__main__':
main()
|
import kydb
def test_basic():
db = kydb.connect('memory://union_db1;memory://union_db2')
db1, db2 = db.dbs
db1['/foo'] = 1
db2['/foo'] = 2
assert db['/foo'] == 1
assert db.ls('/') == ['foo']
db['/foo'] = 3
assert db['/foo'] == 3
assert db1['/foo'] == 3
assert db2['/foo'] == 2
db.delete('/foo')
assert db['/foo'] == 2
assert list(db.list_dir('/')) == ['foo']
assert db.ls('/') == ['foo']
db2.delete('/foo')
assert list(db.list_dir('/')) == []
assert db.ls('/') == []
def test_list_dir():
db = kydb.connect('memory://union_db3;memory://union_db4')
db1, db2 = db.dbs
db1['/a/b/obj1'] = 1
db1['/a/b/obj2'] = 2
db1['/a/obj3'] = 3
db2['/a/b/obj4'] = 4
db2['/a/obj5'] = 5
db2['obj6'] = 6
assert set(db.ls('/')) == set(['a/', 'obj6'])
assert set(db.ls('/a/')) == set(['b/', 'obj3', 'obj5'])
assert set(db.ls('/a/b/')) == set(['obj1', 'obj2', 'obj4'])
assert set(db.ls('/', False)) == set(['obj6'])
assert set(db.ls('/a/', False)) == set(['obj3', 'obj5'])
assert set(db.ls('/a/b/', False)) == set(['obj1', 'obj2', 'obj4'])
|
#!/usr/bin/python
import requests
import yaml
import os
URL = "https://maps.googleapis.com/maps/api/directions/json"
CONFIG_FILE = os.path.dirname(os.path.abspath(__file__)) + "/config.yml"
def makeRequest():
parameters = {
"departure_time": "now",
"alternatives": "true",
"avoid": "tolls"
}
with open(CONFIG_FILE, "r") as s:
try:
y = yaml.safe_load(s)
parameters["origin"] = y['Origin'].replace(" ", "+"),
parameters["destination"] = y['Dest'].replace(" ", "+"),
parameters["key"] = y['Google_Maps_API_Key']
except yaml.YAMLError as exc:
print exc
req = requests.get(URL, params=parameters)
return req.json()
def printResponse(r):
if r["status"] != "OK":
raise r["error_message"]
print("There are " + str(len(r['routes'])) + " routes home")
for route in r['routes']:
print (route["summary"] + " will take "
+ route['legs'][0]['duration_in_traffic']['text'])
if __name__ == "__main__":
r = makeRequest()
printResponse(r)
|
import sys, os
import re, csv
import tensorflow as tf
from tensorflow.contrib.tensorboard.plugins import projector
import numpy as np
import pickle
from sklearn.cluster import DBSCAN
from sklearn import metrics
from konlpy.tag import Mecab
def visualize(sess, varname, X, meta_file):
model_path = os.path.dirname(meta_file)
tf.logging.info('visualize count {}'.format(X.shape))
Ws = tf.Variable(X, trainable=True, name=varname)
sess.run(Ws.initializer)
# save weights
saver = tf.train.Saver()
saver.save(sess, os.path.join(model_path, '%s.ckpt' % varname))
# associate meta & embeddings
conf = projector.ProjectorConfig()
embedding = conf.embeddings.add()
embedding.tensor_name = varname
embedding.metadata_path = meta_file
writer = tf.summary.FileWriter(model_path)
projector.visualize_embeddings(writer, conf)
tf.logging.info('Run `tensorboard --logdir={}` to run visualize result on tensorboard'.format(model_path))
class DBScan:
def __init__(self,
model_path=None,
unit=100,
eps=0.5):
if model_path:
self.model_file = os.path.join(model_path, 'dbscan.model')
self.meta_file = os.path.join(model_path, 'dbscan.meta')
self.X_file = os.path.join(model_path, 'dbscan_x.npy')
if self.model_file and os.path.exists(self.model_file):
try:
with open(self.model_file, 'rb') as f:
self.model = pickle.load(f)
except:
tf.logging.info('fail to load dbscan: {}'.format(sys.exc_info()))
tf.logging.info('dbscan loaded')
else:
self.model = DBSCAN(
eps=eps, # neighborhood로 인정되는 최대 거리
min_samples=2, # core point size
metric='euclidean',
n_jobs=-1)
self.X = np.zeros([0, unit], dtype=np.float32)
try:
if self.X_file and os.path.exists(self.X_file):
self.X = np.load(self.X_file, mmap_mode='r+')
except:
tf.logging.info('fail to load X from file {} {}'.format(self.X_file, sys.exc_info()))
def save(self, tags=[]):
if self.model_file:
try:
with open(self.model_file, 'wb') as f:
pickle.dump(
self.model, f, protocol=pickle.HIGHEST_PROTOCOL)
except:
tf.logging.info(
'fail to save dbscan: {}'.format(sys.exc_info()))
if self.meta_file and tags:
with open(self.meta_file, 'ab') as f:
for tag, label in zip(tags, self.model.labels_):
f.write(('[%03x] %s' % (label, tag)).encode('utf-8') + b'\n')
if self.X_file:
np.save(self.X_file, self.X)
def fit(self, X):
self.X = np.concatenate((self.X, np.array(X)), axis=0)
# return [nsamples]
return self.model.fit_predict(X)
def labels(self):
# return: 각 sample(doc)의 label
return self.model.labels_
def n_clusters(self):
L = self.labels()
return len(set(L)) - (1 if -1 in L else 0)
def core_samples(self):
return self.model.core_sample_indices_
def core_tags(self, tags):
labels = self.model.labels_
cores = self.model.core_sample_indices_
clu_tags = []
for _ in range(self.n_clusters()):
clu_tags.append([])
for i in cores:
clu = labels[i]
if clu < 0: continue
tag = tags[i] if len(tags) > i else ''
clu_tags[clu].append(tag)
return clu_tags
def eval(labels, cls_labels, X):
nclusters = len(set(labels)) - (1 if -1 in labels else 0)
return dict(
n_clusters=nclusters,
homogeneity="%0.3f" % metrics.homogeneity_score(cls_labels, labels),
completeness="%0.3f" % metrics.completeness_score(cls_labels, labels),
v_measure="%0.3f" % metrics.v_measure_score(cls_labels, labels),
adjusted_rand_index="%0.3f" % metrics.adjusted_rand_score(cls_labels, labels),
adjusted_mutual_info="%0.3f" % metrics.adjusted_mutual_info_score(cls_labels, labels),
silhouette="%0.3f" % metrics.silhouette_score(X, labels))
SEP = re.compile(r"[\.!\?]\s+|$", re.M)
def to_sentences(doc):
sts = []
start_sentence=0
for sep in SEP.finditer(doc):
st= doc[start_sentence:sep.start(0)]
start_sentence = sep.end(0)
if len(st) < 10: continue
sts.append(st)
return sts
def clear_str(str):
str = re.sub(r'\[[^\]]+\]', '', str)
str = re.sub(r'\([^\)]+\)', '', str)
str = re.sub(r'\<[^\>]+\>', '', str)
str = re.sub(r'[^\.\?!\uAC00-\uD7AF]', ' ', str)
str = re.sub(r'\s{2,}', ' ', str)
return str
def parse(sentence, mecab, allowed_morps=None):
"""문장을 형태소로 변환"""
return [pos[0]for pos in mecab.pos(sentence) \
if not allowed_morps or pos[1] in allowed_morps]
|
#
# PySNMP MIB module DVB-MGTR101290-MIB (http://snmplabs.com/pysmi)
# ASN.1 source file:///Users/davwang4/Dev/mibs.snmplabs.com/asn1/DVB-MGTR101290-MIB
# Produced by pysmi-0.3.4 at Mon Apr 29 18:40:09 2019
# On host DAVWANG4-M-1475 platform Darwin version 18.5.0 by user davwang4
# Using Python version 3.7.3 (default, Mar 27 2019, 09:23:15)
#
Integer, OctetString, ObjectIdentifier = mibBuilder.importSymbols("ASN1", "Integer", "OctetString", "ObjectIdentifier")
NamedValues, = mibBuilder.importSymbols("ASN1-ENUMERATION", "NamedValues")
SingleValueConstraint, ValueSizeConstraint, ConstraintsUnion, ConstraintsIntersection, ValueRangeConstraint = mibBuilder.importSymbols("ASN1-REFINEMENT", "SingleValueConstraint", "ValueSizeConstraint", "ConstraintsUnion", "ConstraintsIntersection", "ValueRangeConstraint")
ModuleCompliance, NotificationGroup, ObjectGroup = mibBuilder.importSymbols("SNMPv2-CONF", "ModuleCompliance", "NotificationGroup", "ObjectGroup")
Gauge32, Counter64, TimeTicks, MibScalar, MibTable, MibTableRow, MibTableColumn, Integer32, Bits, ObjectIdentity, MibIdentifier, ModuleIdentity, enterprises, NotificationType, iso, Counter32, IpAddress, Unsigned32 = mibBuilder.importSymbols("SNMPv2-SMI", "Gauge32", "Counter64", "TimeTicks", "MibScalar", "MibTable", "MibTableRow", "MibTableColumn", "Integer32", "Bits", "ObjectIdentity", "MibIdentifier", "ModuleIdentity", "enterprises", "NotificationType", "iso", "Counter32", "IpAddress", "Unsigned32")
RowStatus, TextualConvention, DateAndTime, DisplayString, TruthValue = mibBuilder.importSymbols("SNMPv2-TC", "RowStatus", "TextualConvention", "DateAndTime", "DisplayString", "TruthValue")
tr101290 = ModuleIdentity((1, 3, 6, 1, 4, 1, 2696, 3, 2))
if mibBuilder.loadTexts: tr101290.setLastUpdated('200111071400Z')
if mibBuilder.loadTexts: tr101290.setOrganization('DVB')
class ActiveTime(TextualConvention, Unsigned32):
status = 'current'
displayHint = 'd'
class Availability(TextualConvention, Integer32):
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4))
namedValues = NamedValues(("notAvailable", 1), ("testAvailable", 2), ("measurementAvailable", 3), ("measurementAndTestAvailable", 4))
class BERMeasurementMethod(TextualConvention, Integer32):
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2))
namedValues = NamedValues(("iqSeparate", 1), ("iqCombined", 2))
class BitRateElement(TextualConvention, Integer32):
reference = 'TR 101 290 5.3.3.1'
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4))
namedValues = NamedValues(("bit", 1), ("byte", 2), ("packet", 3), ("other", 4))
class DeliverySystemType(TextualConvention, Integer32):
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4))
namedValues = NamedValues(("unknown", 1), ("cable", 2), ("satellite", 3), ("terrestrial", 4))
class Enable(TextualConvention, Bits):
status = 'current'
namedValues = NamedValues(("testEnable", 0), ("failTrapEnable", 1), ("unknownTrapEnable", 2))
class FloatingPoint(TextualConvention, OctetString):
status = 'current'
displayHint = '63a'
subtypeSpec = OctetString.subtypeSpec + ValueSizeConstraint(1, 63)
class GroupAvailability(TextualConvention, Integer32):
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3))
namedValues = NamedValues(("noSupport", 1), ("selectiveSupport", 2), ("completeSupport", 3))
class GuardInterval(TextualConvention, Integer32):
reference = 'EN 300 744 section 4.1'
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4))
namedValues = NamedValues(("interval1d4", 1), ("interval1d8", 2), ("interval1d16", 3), ("interval1d32", 4))
class Hierarchy(TextualConvention, Integer32):
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4))
namedValues = NamedValues(("nonHierarchical", 1), ("hierarchicalAlphaOne", 2), ("hierarchicalAphaTwo", 3), ("hierarchicalAlphaFour", 4))
class IndexConsistencyTest(TextualConvention, Integer32):
reference = 'TR 101 290 section 5.3.4'
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1))
namedValues = NamedValues(("tsIdCheck", 1))
class IndexMIPSyntaxTest(TextualConvention, Integer32):
reference = 'TR 101 290 section 9.20'
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4, 5, 6))
namedValues = NamedValues(("mipTimingError", 1), ("mipStructureError", 2), ("mipPresenceError", 3), ("mipPointerError", 4), ("mipPeriodicityError", 5), ("mipTsRateError", 6))
class IndexPCRMeasurement(TextualConvention, Integer32):
reference = 'TR 101 290 section 5.3.2'
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4))
namedValues = NamedValues(("pcrFO", 1), ("pcrDR", 2), ("pcrOJ", 3), ("pcrAC", 4))
class IndexServicePerformance(TextualConvention, Integer32):
reference = 'TR 101 290 section 5.5'
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3))
namedValues = NamedValues(("serviceAvailability", 1), ("serviceDegradation", 2), ("serviceImpairments", 3))
class IndexTransportStreamTest(TextualConvention, Integer32):
reference = 'TR 101 290 section 5.2'
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1010, 1020, 1031, 1040, 1051, 1060, 2010, 2020, 2031, 2032, 2040, 2050, 2060, 3011, 3012, 3020, 3030, 3041, 3051, 3052, 3061, 3062, 3063, 3070, 3080, 3090, 3100))
namedValues = NamedValues(("tsSyncLoss", 1010), ("syncByteError", 1020), ("patError2", 1031), ("continuityCountError", 1040), ("pmtError2", 1051), ("pidError", 1060), ("transportError", 2010), ("crcError", 2020), ("pcrRepetitionError", 2031), ("pcrDiscontinuityError", 2032), ("pcrAccuracyError", 2040), ("ptsError", 2050), ("catError", 2060), ("nitActualError", 3011), ("nitOtherError", 3012), ("siRepetitionError", 3020), ("bufferError", 3030), ("unreferencedPID", 3041), ("sdtActualError", 3051), ("sdtOtherError", 3052), ("eitActualError", 3061), ("eitOtherError", 3062), ("eitPfError", 3063), ("rstError", 3070), ("tdtError", 3080), ("emptyBufferError", 3090), ("dataDelayError", 3100))
class InputNumber(TextualConvention, Integer32):
status = 'current'
displayHint = 'd'
subtypeSpec = Integer32.subtypeSpec + ValueRangeConstraint(1, 2147483647)
class MeasurementState(TextualConvention, Integer32):
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4))
namedValues = NamedValues(("disabled", 1), ("unknown", 2), ("normal", 3), ("abnormal", 4))
class Modulation(TextualConvention, Integer32):
reference = 'TR 101 198 (BPSK) EN 300 421 (QPSK) EN 301 210 (8PSK, 16QAM) EN 300 429 (16QAM, 32QAM, 64QAM, 128QAM, 256QAM) EN 300 744 (QPSK, 16QAM, 64QAM, 16QAM/alpha=2, 64QAM/alpha=2, 16QAM/alpha=4, 64QAM/alpha=4) '
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
namedValues = NamedValues(("bpsk", 1), ("qpsk", 2), ("psk8", 3), ("qam16", 4), ("qam32", 5), ("qam64", 6), ("qam128", 7), ("qam256", 8), ("qam16Alpha2", 9), ("qam64Alpha2", 10), ("qam16Alpha4", 11), ("qam64Alpha4", 12))
class PIDPlusOne(TextualConvention, Integer32):
reference = 'ISO 13818-1 2.1.32'
status = 'current'
displayHint = 'x'
subtypeSpec = Integer32.subtypeSpec + ValueRangeConstraint(1, 8192)
class PollingInterval(TextualConvention, Integer32):
status = 'current'
class RateStatus(TextualConvention, Integer32):
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3))
namedValues = NamedValues(("disabled", 1), ("enabled", 2), ("enabledThrottled", 3))
class ServiceId(TextualConvention, Integer32):
status = 'current'
displayHint = 'x'
subtypeSpec = Integer32.subtypeSpec + ValueRangeConstraint(1, 65535)
class TerrestrialTransmissionMode(TextualConvention, Integer32):
reference = 'EN 300 744 section 4.1'
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2))
namedValues = NamedValues(("mode2k", 1), ("mode8k", 2))
class TestState(TextualConvention, Integer32):
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4))
namedValues = NamedValues(("disabled", 1), ("unknown", 2), ("pass", 3), ("fail", 4))
class TestSummary(TextualConvention, Bits):
status = 'current'
namedValues = NamedValues(("tsTsSyncLoss", 0), ("tsSyncByteError", 1), ("tsPatError2", 2), ("tsContinuityCountError", 3), ("tsPmtError2", 4), ("tsPidError", 5), ("tsTransportError", 6), ("tsCrcError", 7), ("tsPcrRepetitionError", 8), ("tsPcrDiscontinuityError", 9), ("tsPcrAccuracyError", 10), ("tsPtsError", 11), ("tsCatError", 12), ("tsNitActualError", 13), ("tsNitOtherError", 14), ("tsSiRepetitionError", 15), ("tsBufferError", 16), ("tsUnreferencedPID", 17), ("tsSdtActualError", 18), ("tsSdtOtherError", 19), ("tsEitActualError", 20), ("tsEitOtherError", 21), ("tsEitPfError", 22), ("tsRstError", 23), ("tsTdtError", 24), ("tsEmptyBufferError", 25), ("tsDataDelayError", 26), ("pcrPcrFO", 27), ("pcrPcrDR", 28), ("pcrPcrOJ", 29), ("pcrPcrAC", 30), ("bitrateTransportStream", 31), ("bitrateService", 32), ("bitratePID", 33), ("tsTsConsistency", 34), ("performanceServiceAvailability", 35), ("performanceServiceDegradation", 36), ("performanceServiceImpairments", 37), ("csSysAvailability", 38), ("csLinkAvailability", 39), ("csBerRS", 40), ("csRFIFSignalPower", 41), ("csNoisePower", 42), ("csMer", 43), ("csSteMean", 44), ("csSteDeviation", 45), ("csCS", 46), ("csAI", 47), ("csQE", 48), ("csRTE", 49), ("csCI", 50), ("csPJ", 51), ("csSNR", 52), ("cNoiseMargin", 53), ("cEstNoiseMargin", 54), ("cSignQualMarT", 55), ("cEND", 56), ("cOutBandEmiss", 57), ("sBerViterbi", 58), ("sIfSpectrum", 59), ("tRFAccuracy", 60), ("tRFChannelWidth", 61), ("tSymbolLength", 62), ("tRFIFPower", 63), ("tRFIFSpectrum", 64), ("tEND", 65), ("tENF", 66), ("tENDLP", 67), ("tENFLP", 68), ("tLinearity", 69), ("tBerViterbi", 70), ("tBerViterbiLP", 71), ("tBerRS", 72), ("tBerRSLP", 73), ("tMER", 74), ("tSteMean", 75), ("tSteDeviation", 76), ("tCS", 77), ("tAI", 78), ("tQE", 79), ("tPJ", 80), ("tMipTimingError", 81), ("tMipStructureError", 82), ("tMipPresenceError", 83), ("tMipPointerError", 84), ("tMipPeriodicityError", 85), ("tMipTsRateError", 86), ("tSepEti", 87), ("tSepSeti", 88))
class TransportStreamID(TextualConvention, Integer32):
status = 'current'
displayHint = 'x'
subtypeSpec = Integer32.subtypeSpec + ValueRangeConstraint(0, 65535)
class UATMode(TextualConvention, Integer32):
reference = 'TR 101 290 section 5.4.5'
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2))
namedValues = NamedValues(("nConsecutive", 1), ("rollingWindow", 2))
dvb = MibIdentifier((1, 3, 6, 1, 4, 1, 2696))
mg = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3))
tr101290Objects = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1))
tr101290Control = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1))
controlNow = MibScalar((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1, 1), DateAndTime()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: controlNow.setStatus('current')
controlEventPersistence = MibScalar((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1, 2), FloatingPoint().clone('2')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: controlEventPersistence.setStatus('current')
controlRFSystemTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1, 3), )
if mibBuilder.loadTexts: controlRFSystemTable.setStatus('current')
controlRFSystemEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1, 3, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "rfSystemInputNumber"))
if mibBuilder.loadTexts: controlRFSystemEntry.setStatus('current')
rfSystemInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1, 3, 1, 1), InputNumber())
if mibBuilder.loadTexts: rfSystemInputNumber.setStatus('current')
rfSystemDelivery = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1, 3, 1, 2), DeliverySystemType()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfSystemDelivery.setStatus('current')
controlSynchronizationTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1, 4), )
if mibBuilder.loadTexts: controlSynchronizationTable.setStatus('current')
controlSynchronizationEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1, 4, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "controlSynchronizationInputNumber"))
if mibBuilder.loadTexts: controlSynchronizationEntry.setStatus('current')
controlSynchronizationInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1, 4, 1, 1), InputNumber())
if mibBuilder.loadTexts: controlSynchronizationInputNumber.setStatus('current')
controlSynchronizedTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 1, 4, 1, 2), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: controlSynchronizedTime.setStatus('current')
tr101290Trap = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2))
trapPrefix = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 0))
testFailTrap = NotificationType((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 0, 1)).setObjects(("DVB-MGTR101290-MIB", "trapControlOID"), ("DVB-MGTR101290-MIB", "trapControlGenerationTime"), ("DVB-MGTR101290-MIB", "trapControlFailureSummary"), ("DVB-MGTR101290-MIB", "trapInput"))
if mibBuilder.loadTexts: testFailTrap.setStatus('current')
measurementFailTrap = NotificationType((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 0, 2)).setObjects(("DVB-MGTR101290-MIB", "trapControlOID"), ("DVB-MGTR101290-MIB", "trapControlGenerationTime"), ("DVB-MGTR101290-MIB", "trapControlMeasurementValue"), ("DVB-MGTR101290-MIB", "trapControlFailureSummary"), ("DVB-MGTR101290-MIB", "trapInput"))
if mibBuilder.loadTexts: measurementFailTrap.setStatus('current')
measurementUnknownTrap = NotificationType((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 0, 3)).setObjects(("DVB-MGTR101290-MIB", "trapControlOID"), ("DVB-MGTR101290-MIB", "trapControlGenerationTime"), ("DVB-MGTR101290-MIB", "trapControlFailureSummary"), ("DVB-MGTR101290-MIB", "trapInput"))
if mibBuilder.loadTexts: measurementUnknownTrap.setStatus('current')
trapControlTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 1), )
if mibBuilder.loadTexts: trapControlTable.setStatus('current')
trapControlEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "trapControlInputNumber"))
if mibBuilder.loadTexts: trapControlEntry.setStatus('current')
trapControlInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: trapControlInputNumber.setStatus('current')
trapControlOID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 1, 1, 2), ObjectIdentifier()).setMaxAccess("accessiblefornotify")
if mibBuilder.loadTexts: trapControlOID.setStatus('current')
trapControlGenerationTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 1, 1, 3), DateAndTime()).setMaxAccess("accessiblefornotify")
if mibBuilder.loadTexts: trapControlGenerationTime.setStatus('current')
trapControlMeasurementValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 1, 1, 4), FloatingPoint()).setMaxAccess("accessiblefornotify")
if mibBuilder.loadTexts: trapControlMeasurementValue.setStatus('current')
trapControlRateStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 1, 1, 5), RateStatus()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: trapControlRateStatus.setStatus('current')
trapControlPeriod = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 1, 1, 6), Unsigned32().subtype(subtypeSpec=ValueRangeConstraint(0, 3600000))).setUnits('millisecond').setMaxAccess("readwrite")
if mibBuilder.loadTexts: trapControlPeriod.setStatus('current')
trapControlFailureSummary = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 1, 1, 7), TestSummary()).setMaxAccess("readonly")
if mibBuilder.loadTexts: trapControlFailureSummary.setStatus('current')
trapInput = MibScalar((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 2, 2), InputNumber()).setMaxAccess("accessiblefornotify")
if mibBuilder.loadTexts: trapInput.setStatus('current')
tr101290Capability = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3))
capabilityMIBRevision = MibScalar((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 1), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityMIBRevision.setStatus('current')
capabilityTS = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 5))
capabilityTSGroup = MibScalar((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 5, 1), GroupAvailability()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityTSGroup.setStatus('current')
capabilityTSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 5, 2), )
if mibBuilder.loadTexts: capabilityTSTable.setStatus('current')
capabilityTSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 5, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "capabilityTSOID"))
if mibBuilder.loadTexts: capabilityTSEntry.setStatus('current')
capabilityTSOID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 5, 2, 1, 1), ObjectIdentifier())
if mibBuilder.loadTexts: capabilityTSOID.setStatus('current')
capabilityTSAvailability = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 5, 2, 1, 2), Availability()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityTSAvailability.setStatus('current')
capabilityTSPollInterval = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 5, 2, 1, 3), PollingInterval()).setUnits('millisecond').setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityTSPollInterval.setStatus('current')
capabilityCableSat = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 6))
capabilityCableSatGroup = MibScalar((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 6, 1), GroupAvailability()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityCableSatGroup.setStatus('current')
capabilityCableSatTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 6, 2), )
if mibBuilder.loadTexts: capabilityCableSatTable.setStatus('current')
capabilityCableSatEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 6, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "capabilityCableSatOID"))
if mibBuilder.loadTexts: capabilityCableSatEntry.setStatus('current')
capabilityCableSatOID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 6, 2, 1, 1), ObjectIdentifier())
if mibBuilder.loadTexts: capabilityCableSatOID.setStatus('current')
capabilityCableSatAvailability = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 6, 2, 1, 2), Availability()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityCableSatAvailability.setStatus('current')
capabilityCableSatPollInterval = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 6, 2, 1, 3), PollingInterval()).setUnits('millisecond').setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityCableSatPollInterval.setStatus('current')
capabilityCable = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 7))
capabilityCableGroup = MibScalar((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 7, 1), GroupAvailability()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityCableGroup.setStatus('current')
capabilityCableTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 7, 2), )
if mibBuilder.loadTexts: capabilityCableTable.setStatus('current')
capabilityCableEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 7, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "capabilityCableOID"))
if mibBuilder.loadTexts: capabilityCableEntry.setStatus('current')
capabilityCableOID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 7, 2, 1, 1), ObjectIdentifier())
if mibBuilder.loadTexts: capabilityCableOID.setStatus('current')
capabilityCableAvailability = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 7, 2, 1, 2), Availability()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityCableAvailability.setStatus('current')
capabilityCablePollInterval = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 7, 2, 1, 3), PollingInterval()).setUnits('millisecond').setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityCablePollInterval.setStatus('current')
capabilitySatellite = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 8))
capabilitySatelliteGroup = MibScalar((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 8, 1), GroupAvailability()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilitySatelliteGroup.setStatus('current')
capabilitySatelliteTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 8, 2), )
if mibBuilder.loadTexts: capabilitySatelliteTable.setStatus('current')
capabilitySatelliteEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 8, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "capabilitySatelliteOID"))
if mibBuilder.loadTexts: capabilitySatelliteEntry.setStatus('current')
capabilitySatelliteOID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 8, 2, 1, 1), ObjectIdentifier())
if mibBuilder.loadTexts: capabilitySatelliteOID.setStatus('current')
capabilitySatelliteAvailability = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 8, 2, 1, 2), Availability()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilitySatelliteAvailability.setStatus('current')
capabilitySatellitePollInterval = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 8, 2, 1, 3), PollingInterval()).setUnits('millisecond').setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilitySatellitePollInterval.setStatus('current')
capabilityTerrestrial = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 9))
capabilityTerrestrialGroup = MibScalar((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 9, 1), GroupAvailability()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityTerrestrialGroup.setStatus('current')
capabilityTerrestrialTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 9, 2), )
if mibBuilder.loadTexts: capabilityTerrestrialTable.setStatus('current')
capabilityTerrestrialEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 9, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "capabilityTerrestrialOID"))
if mibBuilder.loadTexts: capabilityTerrestrialEntry.setStatus('current')
capabilityTerrestrialOID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 9, 2, 1, 1), ObjectIdentifier())
if mibBuilder.loadTexts: capabilityTerrestrialOID.setStatus('current')
capabilityTerrestrialAvailability = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 9, 2, 1, 2), Availability()).setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityTerrestrialAvailability.setStatus('current')
capabilityTerrestrialPollInterval = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 3, 9, 2, 1, 3), PollingInterval()).setUnits('millisecond').setMaxAccess("readonly")
if mibBuilder.loadTexts: capabilityTerrestrialPollInterval.setStatus('current')
tr101290TS = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5))
tsTests = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2))
tsTestsSummaryTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2), )
if mibBuilder.loadTexts: tsTestsSummaryTable.setStatus('current')
tsTestsSummaryEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsTestsSummaryTestNumber"), (0, "DVB-MGTR101290-MIB", "tsTestsSummaryInputNumber"))
if mibBuilder.loadTexts: tsTestsSummaryEntry.setStatus('current')
tsTestsSummaryInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsTestsSummaryInputNumber.setStatus('current')
tsTestsSummaryTestNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2, 1, 2), IndexTransportStreamTest())
if mibBuilder.loadTexts: tsTestsSummaryTestNumber.setStatus('current')
tsTestsSummaryState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2, 1, 3), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTestsSummaryState.setStatus('current')
tsTestsSummaryEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2, 1, 4), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsSummaryEnable.setStatus('current')
tsTestsSummaryCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2, 1, 5), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTestsSummaryCounter.setStatus('current')
tsTestsSummaryCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2, 1, 6), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTestsSummaryCounterDiscontinuity.setStatus('current')
tsTestsSummaryCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2, 1, 7), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsSummaryCounterReset.setStatus('current')
tsTestsSummaryLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2, 1, 8), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTestsSummaryLatestError.setStatus('current')
tsTestsSummaryActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 2, 1, 9), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTestsSummaryActiveTime.setStatus('current')
tsTestsPIDTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3), )
if mibBuilder.loadTexts: tsTestsPIDTable.setStatus('current')
tsTestsPIDEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsTestsPIDPID"), (0, "DVB-MGTR101290-MIB", "tsTestsPIDTestNumber"), (0, "DVB-MGTR101290-MIB", "tsTestsPIDInputNumber"))
if mibBuilder.loadTexts: tsTestsPIDEntry.setStatus('current')
tsTestsPIDInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsTestsPIDInputNumber.setStatus('current')
tsTestsPIDPID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 2), PIDPlusOne())
if mibBuilder.loadTexts: tsTestsPIDPID.setStatus('current')
tsTestsPIDTestNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 3), IndexTransportStreamTest())
if mibBuilder.loadTexts: tsTestsPIDTestNumber.setStatus('current')
tsTestsPIDRowStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 4), RowStatus().clone('active')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsTestsPIDRowStatus.setStatus('current')
tsTestsPIDState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 5), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTestsPIDState.setStatus('current')
tsTestsPIDEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 6), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsTestsPIDEnable.setStatus('current')
tsTestsPIDCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 7), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTestsPIDCounter.setStatus('current')
tsTestsPIDCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 8), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTestsPIDCounterDiscontinuity.setStatus('current')
tsTestsPIDCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 9), TruthValue().clone('false')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsTestsPIDCounterReset.setStatus('current')
tsTestsPIDLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 10), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTestsPIDLatestError.setStatus('current')
tsTestsPIDActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 3, 1, 11), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTestsPIDActiveTime.setStatus('current')
tsTestsPreferences = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100))
tsTestsPreferencesTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1), )
if mibBuilder.loadTexts: tsTestsPreferencesTable.setStatus('current')
tsTestsPreferencesEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsTestsPrefInputNumber"))
if mibBuilder.loadTexts: tsTestsPreferencesEntry.setStatus('current')
tsTestsPrefInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsTestsPrefInputNumber.setStatus('current')
tsTestsPrefTransitionDuration = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 2), FloatingPoint().clone('0.5')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefTransitionDuration.setStatus('current')
tsTestsPrefPATSectionIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 3), FloatingPoint().clone('0.5')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefPATSectionIntervalMax.setStatus('current')
tsTestsPrefPMTSectionIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 4), FloatingPoint().clone('0.5')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefPMTSectionIntervalMax.setStatus('current')
tsTestsPrefReferredIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 5), FloatingPoint().clone('5')).setUnits('s').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefReferredIntervalMax.setStatus('current')
tsTestsPrefPCRIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 6), FloatingPoint().clone('0.04')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefPCRIntervalMax.setStatus('current')
tsTestsPrefPCRDiscontinuityMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 7), FloatingPoint().clone('0.1')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefPCRDiscontinuityMax.setStatus('current')
tsTestsPrefPCRInaccuracyMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 8), FloatingPoint().clone('500E-9')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefPCRInaccuracyMax.setStatus('current')
tsTestsPrefPTSIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 9), FloatingPoint().clone('0.7')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefPTSIntervalMax.setStatus('current')
tsTestsPrefNITActualIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 10), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefNITActualIntervalMax.setStatus('current')
tsTestsPrefNITActualIntervalMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 11), FloatingPoint().clone('0.025')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefNITActualIntervalMin.setStatus('current')
tsTestsPrefNITOtherIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 12), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefNITOtherIntervalMax.setStatus('current')
tsTestsPrefSIGapMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 13), FloatingPoint().clone('0.025')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefSIGapMin.setStatus('current')
tsTestsPrefNITTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 14), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefNITTableIntervalMax.setStatus('current')
tsTestsPrefBATTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 15), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefBATTableIntervalMax.setStatus('current')
tsTestsPrefSDTActualTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 16), FloatingPoint().clone('2')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefSDTActualTableIntervalMax.setStatus('current')
tsTestsPrefSDTOtherTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 17), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefSDTOtherTableIntervalMax.setStatus('current')
tsTestsPrefEITPFActualTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 18), FloatingPoint().clone('2')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefEITPFActualTableIntervalMax.setStatus('current')
tsTestsPrefEITPFOtherTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 19), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefEITPFOtherTableIntervalMax.setStatus('current')
tsTestsPrefEITSActualNearTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 20), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefEITSActualNearTableIntervalMax.setStatus('current')
tsTestsPrefEITSActualFarTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 21), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefEITSActualFarTableIntervalMax.setStatus('current')
tsTestsPrefEITSOtherNearTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 22), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefEITSOtherNearTableIntervalMax.setStatus('current')
tsTestsPrefEITSOtherFarTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 23), FloatingPoint().clone('30')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefEITSOtherFarTableIntervalMax.setStatus('current')
tsTestsPrefTxTTableIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 24), FloatingPoint().clone('30')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefTxTTableIntervalMax.setStatus('current')
tsTestsPrefSDTActualIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 25), FloatingPoint().clone('2')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefSDTActualIntervalMax.setStatus('current')
tsTestsPrefSDTActualIntervalMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 26), FloatingPoint().clone('0.025')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefSDTActualIntervalMin.setStatus('current')
tsTestsPrefSDTOtherIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 27), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefSDTOtherIntervalMax.setStatus('current')
tsTestsPrefEITActualIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 28), FloatingPoint().clone('2')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefEITActualIntervalMax.setStatus('current')
tsTestsPrefEITActualIntervalMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 29), FloatingPoint().clone('0.025')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefEITActualIntervalMin.setStatus('current')
tsTestsPrefEITOtherIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 30), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefEITOtherIntervalMax.setStatus('current')
tsTestsPrefRSTIntervalMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 31), FloatingPoint().clone('0.025')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefRSTIntervalMin.setStatus('current')
tsTestsPrefTDTIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 32), FloatingPoint().clone('10')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefTDTIntervalMax.setStatus('current')
tsTestsPrefTDTIntervalMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 1, 1, 33), FloatingPoint().clone('0.025')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefTDTIntervalMin.setStatus('current')
tsTestsPreferencesPIDTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 2), )
if mibBuilder.loadTexts: tsTestsPreferencesPIDTable.setStatus('current')
tsTestsPreferencesPIDEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsTestsPrefPIDInputNumber"), (0, "DVB-MGTR101290-MIB", "tsTestsPrefPIDPID"))
if mibBuilder.loadTexts: tsTestsPreferencesPIDEntry.setStatus('current')
tsTestsPrefPIDInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsTestsPrefPIDInputNumber.setStatus('current')
tsTestsPrefPIDPID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 2, 1, 2), PIDPlusOne())
if mibBuilder.loadTexts: tsTestsPrefPIDPID.setStatus('current')
tsTestsPrefPIDRowStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 2, 1, 3), RowStatus()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsTestsPrefPIDRowStatus.setStatus('current')
tsTestsPrefPIDReferredIntervalMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 2, 100, 2, 1, 4), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTestsPrefPIDReferredIntervalMax.setStatus('current')
tsMeasurements = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4))
tsPcrMeasurementTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1), )
if mibBuilder.loadTexts: tsPcrMeasurementTable.setStatus('current')
tsPcrMeasurementEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsPcrMeasurementPID"), (0, "DVB-MGTR101290-MIB", "tsPcrMeasurementNumber"), (0, "DVB-MGTR101290-MIB", "tsPcrMeasurementInputNumber"))
if mibBuilder.loadTexts: tsPcrMeasurementEntry.setStatus('current')
tsPcrMeasurementInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsPcrMeasurementInputNumber.setStatus('current')
tsPcrMeasurementPID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 2), PIDPlusOne())
if mibBuilder.loadTexts: tsPcrMeasurementPID.setStatus('current')
tsPcrMeasurementNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 3), IndexPCRMeasurement())
if mibBuilder.loadTexts: tsPcrMeasurementNumber.setStatus('current')
tsPcrMeasurementRowStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 4), RowStatus().clone('active')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsPcrMeasurementRowStatus.setStatus('current')
tsPcrMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 5), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPcrMeasurementState.setStatus('current')
tsPcrMeasurementEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 6), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsPcrMeasurementEnable.setStatus('current')
tsPcrMeasurementCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 7), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPcrMeasurementCounter.setStatus('current')
tsPcrMeasurementCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 8), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPcrMeasurementCounterDiscontinuity.setStatus('current')
tsPcrMeasurementCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 9), TruthValue().clone('false')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsPcrMeasurementCounterReset.setStatus('current')
tsPcrMeasurementLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 10), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPcrMeasurementLatestError.setStatus('current')
tsPcrMeasurementActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 11), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPcrMeasurementActiveTime.setStatus('current')
tsPcrMeasurementMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 12), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPcrMeasurementMeasurementState.setStatus('current')
tsPcrMeasurementValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 1, 1, 13), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPcrMeasurementValue.setStatus('current')
bitRate = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2))
tsTransportStreamBitRateTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1), )
if mibBuilder.loadTexts: tsTransportStreamBitRateTable.setStatus('current')
tsTransportStreamBitRateEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsTransportStreamBitRateInputNumber"))
if mibBuilder.loadTexts: tsTransportStreamBitRateEntry.setStatus('current')
tsTransportStreamBitRateInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsTransportStreamBitRateInputNumber.setStatus('current')
tsTransportStreamBitRateState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTransportStreamBitRateState.setStatus('current')
tsTransportStreamBitRateEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 3), Enable()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTransportStreamBitRateEnable.setStatus('current')
tsTransportStreamBitRateCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTransportStreamBitRateCounter.setStatus('current')
tsTransportStreamBitRateCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTransportStreamBitRateCounterDiscontinuity.setStatus('current')
tsTransportStreamBitRateCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsTransportStreamBitRateCounterReset.setStatus('current')
tsTransportStreamBitRateLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTransportStreamBitRateLatestError.setStatus('current')
tsTransportStreamBitRateActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTransportStreamBitRateActiveTime.setStatus('current')
tsTransportStreamBitRateMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTransportStreamBitRateMeasurementState.setStatus('current')
tsTransportStreamBitRateValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 10), FloatingPoint()).setUnits('bit/s').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTransportStreamBitRateValue.setStatus('current')
tsTransportStreamBitRateNomenclature = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 1, 1, 11), DisplayString()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsTransportStreamBitRateNomenclature.setStatus('current')
tsServiceBitRateTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2), )
if mibBuilder.loadTexts: tsServiceBitRateTable.setStatus('current')
tsServiceBitRateEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsServiceBitRateService"), (0, "DVB-MGTR101290-MIB", "tsServiceBitRateInputNumber"))
if mibBuilder.loadTexts: tsServiceBitRateEntry.setStatus('current')
tsServiceBitRateInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsServiceBitRateInputNumber.setStatus('current')
tsServiceBitRateService = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 2), ServiceId())
if mibBuilder.loadTexts: tsServiceBitRateService.setStatus('current')
tsServiceBitRateRowStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 3), RowStatus().clone('active')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsServiceBitRateRowStatus.setStatus('current')
tsServiceBitRateState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 4), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServiceBitRateState.setStatus('current')
tsServiceBitRateEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 5), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsServiceBitRateEnable.setStatus('current')
tsServiceBitRateCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 6), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServiceBitRateCounter.setStatus('current')
tsServiceBitRateCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServiceBitRateCounterDiscontinuity.setStatus('current')
tsServiceBitRateCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 8), TruthValue().clone('false')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsServiceBitRateCounterReset.setStatus('current')
tsServiceBitRateLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 9), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServiceBitRateLatestError.setStatus('current')
tsServiceBitRateActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 10), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServiceBitRateActiveTime.setStatus('current')
tsServiceBitRateMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 11), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServiceBitRateMeasurementState.setStatus('current')
tsServiceBitRateValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 12), FloatingPoint()).setUnits('bit/s').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServiceBitRateValue.setStatus('current')
tsServiceBitRateNomenclature = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 2, 1, 13), DisplayString()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServiceBitRateNomenclature.setStatus('current')
tsPIDBitRateTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3), )
if mibBuilder.loadTexts: tsPIDBitRateTable.setStatus('current')
tsPIDBitRateEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsPIDBitRateInputNumber"), (0, "DVB-MGTR101290-MIB", "tsPIDBitRatePID"))
if mibBuilder.loadTexts: tsPIDBitRateEntry.setStatus('current')
tsPIDBitRateInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsPIDBitRateInputNumber.setStatus('current')
tsPIDBitRatePID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 2), PIDPlusOne())
if mibBuilder.loadTexts: tsPIDBitRatePID.setStatus('current')
tsPIDBitRateRowStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 3), RowStatus().clone('active')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsPIDBitRateRowStatus.setStatus('current')
tsPIDBitRateState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 4), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPIDBitRateState.setStatus('current')
tsPIDBitRateEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 5), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsPIDBitRateEnable.setStatus('current')
tsPIDBitRateCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 6), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPIDBitRateCounter.setStatus('current')
tsPIDBitRateCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPIDBitRateCounterDiscontinuity.setStatus('current')
tsPIDBitRateCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 8), TruthValue().clone('false')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsPIDBitRateCounterReset.setStatus('current')
tsPIDBitRateLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 9), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPIDBitRateLatestError.setStatus('current')
tsPIDBitRateActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 10), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPIDBitRateActiveTime.setStatus('current')
tsPIDBitRateMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 11), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPIDBitRateMeasurementState.setStatus('current')
tsPIDBitRateValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 12), FloatingPoint()).setUnits('bit/s').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPIDBitRateValue.setStatus('current')
tsPIDBitRateNomenclature = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 2, 3, 1, 13), DisplayString()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsPIDBitRateNomenclature.setStatus('current')
tsConsistencyTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3), )
if mibBuilder.loadTexts: tsConsistencyTable.setStatus('current')
tsConsistencyEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsConsistencyInputNumber"), (0, "DVB-MGTR101290-MIB", "tsConsistencyTestNumber"))
if mibBuilder.loadTexts: tsConsistencyEntry.setStatus('current')
tsConsistencyInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsConsistencyInputNumber.setStatus('current')
tsConsistencyTestNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3, 1, 2), IndexConsistencyTest())
if mibBuilder.loadTexts: tsConsistencyTestNumber.setStatus('current')
tsConsistencyState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3, 1, 3), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsConsistencyState.setStatus('current')
tsConsistencyEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3, 1, 4), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsConsistencyEnable.setStatus('current')
tsConsistencyCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3, 1, 5), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsConsistencyCounter.setStatus('current')
tsConsistencyCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3, 1, 6), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsConsistencyCounterDiscontinuity.setStatus('current')
tsConsistencyCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3, 1, 7), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsConsistencyCounterReset.setStatus('current')
tsConsistencyLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3, 1, 8), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsConsistencyLatestError.setStatus('current')
tsConsistencyActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 3, 1, 9), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsConsistencyActiveTime.setStatus('current')
tsMeasurePreferences = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100))
tsMeasurePreferencesTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1), )
if mibBuilder.loadTexts: tsMeasurePreferencesTable.setStatus('current')
tsMeasurePreferencesEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsMeasurePrefInputNumber"))
if mibBuilder.loadTexts: tsMeasurePreferencesEntry.setStatus('current')
tsMeasurePrefInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsMeasurePrefInputNumber.setStatus('current')
tsMeasurePrefPCRDemarcationFrequency = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 2), FloatingPoint().clone('0.01')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefPCRDemarcationFrequency.setStatus('current')
tsMeasurePrefPCRFOMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 3), FloatingPoint().clone('810')).setUnits('Hz').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefPCRFOMax.setStatus('current')
tsMeasurePrefPCRDRMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 4), FloatingPoint().clone('0.075')).setUnits('Hz/s').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefPCRDRMax.setStatus('current')
tsMeasurePrefPCROJMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 5), FloatingPoint().clone('25E-06')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefPCROJMax.setStatus('current')
tsMeasurePrefTSBitRateTau = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 6), FloatingPoint().clone('0.1')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefTSBitRateTau.setStatus('current')
tsMeasurePrefTSBitRateN = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 7), Unsigned32().clone(10)).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefTSBitRateN.setStatus('current')
tsMeasurePrefTSBitRateElement = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 8), BitRateElement().clone('packet')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefTSBitRateElement.setStatus('current')
tsMeasurePrefTSBitRateMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 9), FloatingPoint()).setUnits('bit/s').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefTSBitRateMin.setStatus('current')
tsMeasurePrefTSBitRateMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 10), FloatingPoint()).setUnits('bit/s').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefTSBitRateMax.setStatus('current')
tsMeasurePrefAllServiceBitRateTau = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 11), FloatingPoint().clone('0.1')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefAllServiceBitRateTau.setStatus('current')
tsMeasurePrefAllServiceBitRateN = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 12), Unsigned32().clone(10)).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefAllServiceBitRateN.setStatus('current')
tsMeasurePrefAllServiceBitRateElement = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 13), BitRateElement().clone('packet')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefAllServiceBitRateElement.setStatus('current')
tsMeasurePrefAllPIDBitRateTau = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 14), FloatingPoint().clone('0.1')).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefAllPIDBitRateTau.setStatus('current')
tsMeasurePrefAllPIDBitRateN = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 15), Unsigned32().clone(10)).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefAllPIDBitRateN.setStatus('current')
tsMeasurePrefAllPIDBitRateElement = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 16), BitRateElement().clone('packet')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefAllPIDBitRateElement.setStatus('current')
tsMeasurePrefExpectedTSID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 1, 1, 17), TransportStreamID()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsMeasurePrefExpectedTSID.setStatus('current')
tsMeasurePreferencesServiceTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 2), )
if mibBuilder.loadTexts: tsMeasurePreferencesServiceTable.setStatus('current')
tsMeasurePreferencesServiceEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsMeasurePrefServiceInputNumber"), (0, "DVB-MGTR101290-MIB", "tsMeasurePrefServiceService"))
if mibBuilder.loadTexts: tsMeasurePreferencesServiceEntry.setStatus('current')
tsMeasurePrefServiceInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsMeasurePrefServiceInputNumber.setStatus('current')
tsMeasurePrefServiceService = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 2, 1, 2), ServiceId())
if mibBuilder.loadTexts: tsMeasurePrefServiceService.setStatus('current')
tsMeasurePrefServiceRowStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 2, 1, 3), RowStatus().clone('active')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefServiceRowStatus.setStatus('current')
tsMeasurePrefServiceBitRateTau = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 2, 1, 4), FloatingPoint().clone('0.1')).setUnits('second').setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefServiceBitRateTau.setStatus('current')
tsMeasurePrefServiceBitRateN = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 2, 1, 5), Unsigned32().clone(10)).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefServiceBitRateN.setStatus('current')
tsMeasurePrefServiceBitRateElement = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 2, 1, 6), BitRateElement().clone('packet')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefServiceBitRateElement.setStatus('current')
tsMeasurePrefServiceBitRateMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 2, 1, 7), FloatingPoint()).setUnits('bit/s').setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefServiceBitRateMin.setStatus('current')
tsMeasurePrefServiceBitRateMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 2, 1, 8), FloatingPoint()).setUnits('bit/s').setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefServiceBitRateMax.setStatus('current')
tsMeasurePreferencesPIDTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 3), )
if mibBuilder.loadTexts: tsMeasurePreferencesPIDTable.setStatus('current')
tsMeasurePreferencesPIDEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 3, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsMeasurePrefPIDInputNumber"), (0, "DVB-MGTR101290-MIB", "tsMeasurePrefPIDPID"))
if mibBuilder.loadTexts: tsMeasurePreferencesPIDEntry.setStatus('current')
tsMeasurePrefPIDInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 3, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsMeasurePrefPIDInputNumber.setStatus('current')
tsMeasurePrefPIDPID = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 3, 1, 2), PIDPlusOne())
if mibBuilder.loadTexts: tsMeasurePrefPIDPID.setStatus('current')
tsMeasurePrefPIDRowStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 3, 1, 3), RowStatus().clone('active')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefPIDRowStatus.setStatus('current')
tsMeasurePrefPIDBitRateTau = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 3, 1, 4), FloatingPoint().clone('0.1')).setUnits('second').setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefPIDBitRateTau.setStatus('current')
tsMeasurePrefPIDBitRateN = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 3, 1, 5), Unsigned32().clone(10)).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefPIDBitRateN.setStatus('current')
tsMeasurePrefPIDBitRateElement = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 3, 1, 6), BitRateElement().clone('packet')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefPIDBitRateElement.setStatus('current')
tsMeasurePrefPIDBitRateMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 3, 1, 7), FloatingPoint()).setUnits('bit/s').setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefPIDBitRateMin.setStatus('current')
tsMeasurePrefPIDBitRateMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 4, 100, 3, 1, 8), FloatingPoint()).setUnits('bit/s').setMaxAccess("readcreate")
if mibBuilder.loadTexts: tsMeasurePrefPIDBitRateMax.setStatus('current')
tsServicePerformance = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5))
tsServicePerformanceTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2), )
if mibBuilder.loadTexts: tsServicePerformanceTable.setStatus('current')
tsServicePerformanceEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsServicePerformanceNumber"), (0, "DVB-MGTR101290-MIB", "tsServicePerformanceInputNumber"))
if mibBuilder.loadTexts: tsServicePerformanceEntry.setStatus('current')
tsServicePerformanceInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsServicePerformanceInputNumber.setStatus('current')
tsServicePerformanceNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 2), IndexServicePerformance())
if mibBuilder.loadTexts: tsServicePerformanceNumber.setStatus('current')
tsServicePerformanceState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 3), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServicePerformanceState.setStatus('current')
tsServicePerformanceEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 4), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsServicePerformanceEnable.setStatus('current')
tsServicePerformanceCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 5), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServicePerformanceCounter.setStatus('current')
tsServicePerformanceCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 6), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServicePerformanceCounterDiscontinuity.setStatus('current')
tsServicePerformanceCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 7), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsServicePerformanceCounterReset.setStatus('current')
tsServicePerformanceLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 8), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServicePerformanceLatestError.setStatus('current')
tsServicePerformanceActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 9), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServicePerformanceActiveTime.setStatus('current')
tsServicePerformanceMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 10), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServicePerformanceMeasurementState.setStatus('current')
tsServicePerformanceError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 11), Unsigned32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServicePerformanceError.setStatus('current')
tsServicePerformanceErrorRatio = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 2, 1, 12), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: tsServicePerformanceErrorRatio.setStatus('current')
tsServicePerformancePreferencesTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 100), )
if mibBuilder.loadTexts: tsServicePerformancePreferencesTable.setStatus('current')
tsServicePerformancePreferencesEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 100, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "tsSPPrefInputNumber"), (0, "DVB-MGTR101290-MIB", "tsSPPrefNumber"))
if mibBuilder.loadTexts: tsServicePerformancePreferencesEntry.setStatus('current')
tsSPPrefInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 100, 1, 1), InputNumber())
if mibBuilder.loadTexts: tsSPPrefInputNumber.setStatus('current')
tsSPPrefNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 100, 1, 2), IndexServicePerformance())
if mibBuilder.loadTexts: tsSPPrefNumber.setStatus('current')
tsSPPrefDeltaT = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 100, 1, 3), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsSPPrefDeltaT.setStatus('current')
tsSPPrefEvaluationTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 100, 1, 4), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsSPPrefEvaluationTime.setStatus('current')
tsSPPrefThreshold = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 5, 5, 100, 1, 5), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: tsSPPrefThreshold.setStatus('current')
tr101290CableSat = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6))
sysAvailabilityTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1), )
if mibBuilder.loadTexts: sysAvailabilityTable.setStatus('current')
sysAvailabilityEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "sysAvailabilityInputNumber"))
if mibBuilder.loadTexts: sysAvailabilityEntry.setStatus('current')
sysAvailabilityInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: sysAvailabilityInputNumber.setStatus('current')
sysAvailabilityTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sysAvailabilityTestState.setStatus('current')
sysAvailabilityEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: sysAvailabilityEnable.setStatus('current')
sysAvailabilityCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sysAvailabilityCounter.setStatus('current')
sysAvailabilityCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sysAvailabilityCounterDiscontinuity.setStatus('current')
sysAvailabilityCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: sysAvailabilityCounterReset.setStatus('current')
sysAvailabilityLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sysAvailabilityLatestError.setStatus('current')
sysAvailabilityActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: sysAvailabilityActiveTime.setStatus('current')
sysAvailabilityMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sysAvailabilityMeasurementState.setStatus('current')
sysAvailabilityUnavailableTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 10), Unsigned32()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: sysAvailabilityUnavailableTime.setStatus('current')
sysAvailabilityRatio = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 11), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sysAvailabilityRatio.setStatus('current')
sysAvailabilityInSETI = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 1, 1, 12), TruthValue()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sysAvailabilityInSETI.setStatus('current')
linkAvailabilityTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2), )
if mibBuilder.loadTexts: linkAvailabilityTable.setStatus('current')
linkAvailabilityEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "linkAvailabilityInputNumber"))
if mibBuilder.loadTexts: linkAvailabilityEntry.setStatus('current')
linkAvailabilityInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: linkAvailabilityInputNumber.setStatus('current')
linkAvailabilityTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linkAvailabilityTestState.setStatus('current')
linkAvailabilityEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: linkAvailabilityEnable.setStatus('current')
linkAvailabilityCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linkAvailabilityCounter.setStatus('current')
linkAvailabilityCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linkAvailabilityCounterDiscontinuity.setStatus('current')
linkAvailabilityCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: linkAvailabilityCounterReset.setStatus('current')
linkAvailabilityLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linkAvailabilityLatestError.setStatus('current')
linkAvailabilityActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: linkAvailabilityActiveTime.setStatus('current')
linkAvailabilityMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linkAvailabilityMeasurementState.setStatus('current')
linkAvailabilityUnavailableTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 10), Unsigned32()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: linkAvailabilityUnavailableTime.setStatus('current')
linkAvailabilityRatio = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 11), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linkAvailabilityRatio.setStatus('current')
linkAvailabilityInSUTI = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 2, 1, 12), TruthValue()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linkAvailabilityInSUTI.setStatus('current')
berRSinServiceTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3), )
if mibBuilder.loadTexts: berRSinServiceTable.setStatus('current')
berRSinServiceEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "berRSinServiceInputNumber"))
if mibBuilder.loadTexts: berRSinServiceEntry.setStatus('current')
berRSinServiceInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1, 1), InputNumber())
if mibBuilder.loadTexts: berRSinServiceInputNumber.setStatus('current')
berRSinServiceTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSinServiceTestState.setStatus('current')
berRSinServiceEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berRSinServiceEnable.setStatus('current')
berRSinServiceCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSinServiceCounter.setStatus('current')
berRSinServiceCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSinServiceCounterDiscontinuity.setStatus('current')
berRSinServiceCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berRSinServiceCounterReset.setStatus('current')
berRSinServiceLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSinServiceLatestError.setStatus('current')
berRSinServiceActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSinServiceActiveTime.setStatus('current')
berRSinServiceMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSinServiceMeasurementState.setStatus('current')
berRSinServiceValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 3, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSinServiceValue.setStatus('current')
rfIFsignalPowerTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6), )
if mibBuilder.loadTexts: rfIFsignalPowerTable.setStatus('current')
rfIFsignalPowerEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "rfIFsignalPowerInputNumber"))
if mibBuilder.loadTexts: rfIFsignalPowerEntry.setStatus('current')
rfIFsignalPowerInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1, 1), InputNumber())
if mibBuilder.loadTexts: rfIFsignalPowerInputNumber.setStatus('current')
rfIFsignalPowerTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIFsignalPowerTestState.setStatus('current')
rfIFsignalPowerEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfIFsignalPowerEnable.setStatus('current')
rfIFsignalPowerCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIFsignalPowerCounter.setStatus('current')
rfIFsignalPowerCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIFsignalPowerCounterDiscontinuity.setStatus('current')
rfIFsignalPowerCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfIFsignalPowerCounterReset.setStatus('current')
rfIFsignalPowerLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIFsignalPowerLatestError.setStatus('current')
rfIFsignalPowerActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIFsignalPowerActiveTime.setStatus('current')
rfIFsignalPowerMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIFsignalPowerMeasurementState.setStatus('current')
rfIFsignalPowerValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 6, 1, 10), FloatingPoint()).setUnits('dBm').setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIFsignalPowerValue.setStatus('current')
noisePowerTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7), )
if mibBuilder.loadTexts: noisePowerTable.setStatus('current')
noisePowerEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "noisePowerInputNumber"))
if mibBuilder.loadTexts: noisePowerEntry.setStatus('current')
noisePowerInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1, 1), InputNumber())
if mibBuilder.loadTexts: noisePowerInputNumber.setStatus('current')
noisePowerTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: noisePowerTestState.setStatus('current')
noisePowerEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: noisePowerEnable.setStatus('current')
noisePowerCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: noisePowerCounter.setStatus('current')
noisePowerCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: noisePowerCounterDiscontinuity.setStatus('current')
noisePowerCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: noisePowerCounterReset.setStatus('current')
noisePowerLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: noisePowerLatestError.setStatus('current')
noisePowerActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: noisePowerActiveTime.setStatus('current')
noisePowerMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: noisePowerMeasurementState.setStatus('current')
noisePowerValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 7, 1, 10), FloatingPoint()).setUnits('dBm').setMaxAccess("readonly")
if mibBuilder.loadTexts: noisePowerValue.setStatus('current')
iqAnalysisCS = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9))
merCSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2), )
if mibBuilder.loadTexts: merCSTable.setStatus('current')
merCSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "merCSInputNumber"))
if mibBuilder.loadTexts: merCSEntry.setStatus('current')
merCSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: merCSInputNumber.setStatus('current')
merCSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: merCSTestState.setStatus('current')
merCSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: merCSEnable.setStatus('current')
merCSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: merCSCounter.setStatus('current')
merCSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: merCSCounterDiscontinuity.setStatus('current')
merCSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: merCSCounterReset.setStatus('current')
merCSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: merCSLatestError.setStatus('current')
merCSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: merCSActiveTime.setStatus('current')
merCSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: merCSMeasurementState.setStatus('current')
merCSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 2, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: merCSValue.setStatus('current')
steCS = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3))
steMeanCSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1), )
if mibBuilder.loadTexts: steMeanCSTable.setStatus('current')
steMeanCSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "steMeanCSInputNumber"))
if mibBuilder.loadTexts: steMeanCSEntry.setStatus('current')
steMeanCSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: steMeanCSInputNumber.setStatus('current')
steMeanCSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanCSTestState.setStatus('current')
steMeanCSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: steMeanCSEnable.setStatus('current')
steMeanCSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanCSCounter.setStatus('current')
steMeanCSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanCSCounterDiscontinuity.setStatus('current')
steMeanCSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: steMeanCSCounterReset.setStatus('current')
steMeanCSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanCSLatestError.setStatus('current')
steMeanCSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanCSActiveTime.setStatus('current')
steMeanCSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanCSMeasurementState.setStatus('current')
steMeanCSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 1, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanCSValue.setStatus('current')
steDeviationCSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2), )
if mibBuilder.loadTexts: steDeviationCSTable.setStatus('current')
steDeviationCSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "steDeviationCSInputNumber"))
if mibBuilder.loadTexts: steDeviationCSEntry.setStatus('current')
steDeviationCSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: steDeviationCSInputNumber.setStatus('current')
steDeviationCSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationCSTestState.setStatus('current')
steDeviationCSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: steDeviationCSEnable.setStatus('current')
steDeviationCSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationCSCounter.setStatus('current')
steDeviationCSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationCSCounterDiscontinuity.setStatus('current')
steDeviationCSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: steDeviationCSCounterReset.setStatus('current')
steDeviationCSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationCSLatestError.setStatus('current')
steDeviationCSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationCSActiveTime.setStatus('current')
steDeviationCSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationCSMeasurementState.setStatus('current')
steDeviationCSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 3, 2, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationCSValue.setStatus('current')
csCSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4), )
if mibBuilder.loadTexts: csCSTable.setStatus('current')
csCSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "csCSInputNumber"))
if mibBuilder.loadTexts: csCSEntry.setStatus('current')
csCSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1, 1), InputNumber())
if mibBuilder.loadTexts: csCSInputNumber.setStatus('current')
csCSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: csCSTestState.setStatus('current')
csCSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: csCSEnable.setStatus('current')
csCSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: csCSCounter.setStatus('current')
csCSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: csCSCounterDiscontinuity.setStatus('current')
csCSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: csCSCounterReset.setStatus('current')
csCSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: csCSLatestError.setStatus('current')
csCSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: csCSActiveTime.setStatus('current')
csCSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: csCSMeasurementState.setStatus('current')
csCSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 4, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: csCSValue.setStatus('current')
aiCSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5), )
if mibBuilder.loadTexts: aiCSTable.setStatus('current')
aiCSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "aiCSInputNumber"))
if mibBuilder.loadTexts: aiCSEntry.setStatus('current')
aiCSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1, 1), InputNumber())
if mibBuilder.loadTexts: aiCSInputNumber.setStatus('current')
aiCSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiCSTestState.setStatus('current')
aiCSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: aiCSEnable.setStatus('current')
aiCSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiCSCounter.setStatus('current')
aiCSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiCSCounterDiscontinuity.setStatus('current')
aiCSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: aiCSCounterReset.setStatus('current')
aiCSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiCSLatestError.setStatus('current')
aiCSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: aiCSActiveTime.setStatus('current')
aiCSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiCSMeasurementState.setStatus('current')
aiCSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 5, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiCSValue.setStatus('current')
qeCSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6), )
if mibBuilder.loadTexts: qeCSTable.setStatus('current')
qeCSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "qeCSInputNumber"))
if mibBuilder.loadTexts: qeCSEntry.setStatus('current')
qeCSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1, 1), InputNumber())
if mibBuilder.loadTexts: qeCSInputNumber.setStatus('current')
qeCSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: qeCSTestState.setStatus('current')
qeCSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: qeCSEnable.setStatus('current')
qeCSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: qeCSCounter.setStatus('current')
qeCSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: qeCSCounterDiscontinuity.setStatus('current')
qeCSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: qeCSCounterReset.setStatus('current')
qeCSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: qeCSLatestError.setStatus('current')
qeCSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: qeCSActiveTime.setStatus('current')
qeCSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: qeCSMeasurementState.setStatus('current')
qeCSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 6, 1, 10), FloatingPoint()).setUnits('degree').setMaxAccess("readonly")
if mibBuilder.loadTexts: qeCSValue.setStatus('current')
rteCSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7), )
if mibBuilder.loadTexts: rteCSTable.setStatus('current')
rteCSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "rteCSInputNumber"))
if mibBuilder.loadTexts: rteCSEntry.setStatus('current')
rteCSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1, 1), InputNumber())
if mibBuilder.loadTexts: rteCSInputNumber.setStatus('current')
rteCSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rteCSTestState.setStatus('current')
rteCSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rteCSEnable.setStatus('current')
rteCSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rteCSCounter.setStatus('current')
rteCSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rteCSCounterDiscontinuity.setStatus('current')
rteCSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rteCSCounterReset.setStatus('current')
rteCSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rteCSLatestError.setStatus('current')
rteCSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: rteCSActiveTime.setStatus('current')
rteCSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rteCSMeasurementState.setStatus('current')
rteCSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 7, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rteCSValue.setStatus('current')
ciCSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8), )
if mibBuilder.loadTexts: ciCSTable.setStatus('current')
ciCSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "ciCSInputNumber"))
if mibBuilder.loadTexts: ciCSEntry.setStatus('current')
ciCSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1, 1), InputNumber())
if mibBuilder.loadTexts: ciCSInputNumber.setStatus('current')
ciCSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: ciCSTestState.setStatus('current')
ciCSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: ciCSEnable.setStatus('current')
ciCSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: ciCSCounter.setStatus('current')
ciCSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: ciCSCounterDiscontinuity.setStatus('current')
ciCSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: ciCSCounterReset.setStatus('current')
ciCSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: ciCSLatestError.setStatus('current')
ciCSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: ciCSActiveTime.setStatus('current')
ciCSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: ciCSMeasurementState.setStatus('current')
ciCSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 8, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: ciCSValue.setStatus('current')
pjCSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9), )
if mibBuilder.loadTexts: pjCSTable.setStatus('current')
pjCSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "pjCSInputNumber"))
if mibBuilder.loadTexts: pjCSEntry.setStatus('current')
pjCSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1, 1), InputNumber())
if mibBuilder.loadTexts: pjCSInputNumber.setStatus('current')
pjCSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: pjCSTestState.setStatus('current')
pjCSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: pjCSEnable.setStatus('current')
pjCSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: pjCSCounter.setStatus('current')
pjCSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: pjCSCounterDiscontinuity.setStatus('current')
pjCSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: pjCSCounterReset.setStatus('current')
pjCSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: pjCSLatestError.setStatus('current')
pjCSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: pjCSActiveTime.setStatus('current')
pjCSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: pjCSMeasurementState.setStatus('current')
pjCSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 9, 1, 10), FloatingPoint()).setUnits('degree').setMaxAccess("readonly")
if mibBuilder.loadTexts: pjCSValue.setStatus('current')
snrCSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10), )
if mibBuilder.loadTexts: snrCSTable.setStatus('current')
snrCSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "snrCSInputNumber"))
if mibBuilder.loadTexts: snrCSEntry.setStatus('current')
snrCSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1, 1), InputNumber())
if mibBuilder.loadTexts: snrCSInputNumber.setStatus('current')
snrCSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: snrCSTestState.setStatus('current')
snrCSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: snrCSEnable.setStatus('current')
snrCSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: snrCSCounter.setStatus('current')
snrCSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: snrCSCounterDiscontinuity.setStatus('current')
snrCSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: snrCSCounterReset.setStatus('current')
snrCSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: snrCSLatestError.setStatus('current')
snrCSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: snrCSActiveTime.setStatus('current')
snrCSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: snrCSMeasurementState.setStatus('current')
snrCSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 9, 10, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: snrCSValue.setStatus('current')
cableSatPreferencesTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100), )
if mibBuilder.loadTexts: cableSatPreferencesTable.setStatus('current')
cableSatPreferencesEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "cableSatPrefInputNumber"))
if mibBuilder.loadTexts: cableSatPreferencesEntry.setStatus('current')
cableSatPrefInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 1), InputNumber())
if mibBuilder.loadTexts: cableSatPrefInputNumber.setStatus('current')
cableSatPrefCentreFrequency = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 2), FloatingPoint()).setUnits('MHz').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefCentreFrequency.setStatus('current')
cableSatPrefModulation = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 3), Modulation()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefModulation.setStatus('current')
cableSatPrefSysAvailUATMode = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 4), UATMode()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSysAvailUATMode.setStatus('current')
cableSatPrefSysAvailN = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 5), Unsigned32()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSysAvailN.setStatus('current')
cableSatPrefSysAvailT = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 6), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSysAvailT.setStatus('current')
cableSatPrefSysAvailM = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 7), Unsigned32()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSysAvailM.setStatus('current')
cableSatPrefSysAvailTI = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 8), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSysAvailTI.setStatus('current')
cableSatPrefSysAvailEBPerCent = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 9), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSysAvailEBPerCent.setStatus('current')
cableSatPrefSysAvailTotalTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 10), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSysAvailTotalTime.setStatus('current')
cableSatPrefLinkAvailUATMode = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 11), UATMode()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefLinkAvailUATMode.setStatus('current')
cableSatPrefLinkAvailN = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 12), Unsigned32()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefLinkAvailN.setStatus('current')
cableSatPrefLinkAvailT = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 13), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefLinkAvailT.setStatus('current')
cableSatPrefLinkAvailM = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 14), Unsigned32()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefLinkAvailM.setStatus('current')
cableSatPrefLinkAvailTI = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 15), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefLinkAvailTI.setStatus('current')
cableSatPrefLinkAvailUPPerCent = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 16), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefLinkAvailUPPerCent.setStatus('current')
cableSatPrefLinkAvailTotalTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 17), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefLinkAvailTotalTime.setStatus('current')
cableSatPrefBERMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 18), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefBERMax.setStatus('current')
cableSatPrefSignalPowerMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 19), FloatingPoint()).setUnits('dBm').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSignalPowerMin.setStatus('current')
cableSatPrefSignalPowerMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 20), FloatingPoint()).setUnits('dBm').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSignalPowerMax.setStatus('current')
cableSatPrefNoisePowerMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 21), FloatingPoint()).setUnits('dBm').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefNoisePowerMax.setStatus('current')
cableSatPrefMerCSMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 22), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefMerCSMin.setStatus('current')
cableSatPrefSteMeanCSMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 23), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSteMeanCSMax.setStatus('current')
cableSatPrefSteDeviationCSMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 24), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSteDeviationCSMax.setStatus('current')
cableSatPrefCsCSMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 25), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefCsCSMin.setStatus('current')
cableSatPrefAiCSMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 26), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefAiCSMax.setStatus('current')
cableSatPrefQeCSMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 27), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefQeCSMax.setStatus('current')
cableSatPrefRteCSMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 28), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefRteCSMax.setStatus('current')
cableSatPrefCiCSMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 29), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefCiCSMin.setStatus('current')
cableSatPrefPjCSMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 30), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefPjCSMax.setStatus('current')
cableSatPrefSnrCSMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 6, 100, 1, 31), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cableSatPrefSnrCSMin.setStatus('current')
tr101290Cable = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7))
noiseMarginTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1), )
if mibBuilder.loadTexts: noiseMarginTable.setStatus('current')
noiseMarginEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "noiseMarginInputNumber"))
if mibBuilder.loadTexts: noiseMarginEntry.setStatus('current')
noiseMarginInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: noiseMarginInputNumber.setStatus('current')
noiseMarginTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: noiseMarginTestState.setStatus('current')
noiseMarginEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: noiseMarginEnable.setStatus('current')
noiseMarginCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: noiseMarginCounter.setStatus('current')
noiseMarginCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: noiseMarginCounterDiscontinuity.setStatus('current')
noiseMarginCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: noiseMarginCounterReset.setStatus('current')
noiseMarginLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: noiseMarginLatestError.setStatus('current')
noiseMarginActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: noiseMarginActiveTime.setStatus('current')
noiseMarginMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: noiseMarginMeasurementState.setStatus('current')
noiseMarginValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 1, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: noiseMarginValue.setStatus('current')
estNoiseMarginTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2), )
if mibBuilder.loadTexts: estNoiseMarginTable.setStatus('current')
estNoiseMarginEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "estNoiseMarginInputNumber"))
if mibBuilder.loadTexts: estNoiseMarginEntry.setStatus('current')
estNoiseMarginInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: estNoiseMarginInputNumber.setStatus('current')
estNoiseMarginTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: estNoiseMarginTestState.setStatus('current')
estNoiseMarginEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: estNoiseMarginEnable.setStatus('current')
estNoiseMarginCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: estNoiseMarginCounter.setStatus('current')
estNoiseMarginCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: estNoiseMarginCounterDiscontinuity.setStatus('current')
estNoiseMarginCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: estNoiseMarginCounterReset.setStatus('current')
estNoiseMarginLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: estNoiseMarginLatestError.setStatus('current')
estNoiseMarginActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: estNoiseMarginActiveTime.setStatus('current')
estNoiseMarginMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: estNoiseMarginMeasurementState.setStatus('current')
estNoiseMarginValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 2, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: estNoiseMarginValue.setStatus('current')
signQualMarTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 3), )
if mibBuilder.loadTexts: signQualMarTTable.setStatus('current')
signQualMarTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 3, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "signQualMarTInputNumber"))
if mibBuilder.loadTexts: signQualMarTEntry.setStatus('current')
signQualMarTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 3, 1, 1), InputNumber())
if mibBuilder.loadTexts: signQualMarTInputNumber.setStatus('current')
signQualMarTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 3, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: signQualMarTTestState.setStatus('current')
signQualMarTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 3, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: signQualMarTEnable.setStatus('current')
signQualMarTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 3, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: signQualMarTCounter.setStatus('current')
signQualMarTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 3, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: signQualMarTCounterDiscontinuity.setStatus('current')
signQualMarTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 3, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: signQualMarTCounterReset.setStatus('current')
signQualMarTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 3, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: signQualMarTLatestError.setStatus('current')
signQualMarTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 3, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: signQualMarTActiveTime.setStatus('current')
eNDCTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4), )
if mibBuilder.loadTexts: eNDCTable.setStatus('current')
eNDCEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "eNDCInputNumber"))
if mibBuilder.loadTexts: eNDCEntry.setStatus('current')
eNDCInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1, 1), InputNumber())
if mibBuilder.loadTexts: eNDCInputNumber.setStatus('current')
eNDCTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDCTestState.setStatus('current')
eNDCEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: eNDCEnable.setStatus('current')
eNDCCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDCCounter.setStatus('current')
eNDCCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDCCounterDiscontinuity.setStatus('current')
eNDCCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: eNDCCounterReset.setStatus('current')
eNDCLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDCLatestError.setStatus('current')
eNDCActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDCActiveTime.setStatus('current')
eNDCMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDCMeasurementState.setStatus('current')
eNDCValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 4, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDCValue.setStatus('current')
outBandEmissTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 5), )
if mibBuilder.loadTexts: outBandEmissTable.setStatus('current')
outBandEmissEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 5, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "outBandEmissInputNumber"))
if mibBuilder.loadTexts: outBandEmissEntry.setStatus('current')
outBandEmissInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 5, 1, 1), InputNumber())
if mibBuilder.loadTexts: outBandEmissInputNumber.setStatus('current')
outBandEmissTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 5, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: outBandEmissTestState.setStatus('current')
outBandEmissEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 5, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: outBandEmissEnable.setStatus('current')
outBandEmissCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 5, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: outBandEmissCounter.setStatus('current')
outBandEmissCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 5, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: outBandEmissCounterDiscontinuity.setStatus('current')
outBandEmissCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 5, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: outBandEmissCounterReset.setStatus('current')
outBandEmissLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 5, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: outBandEmissLatestError.setStatus('current')
outBandEmissActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 5, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: outBandEmissActiveTime.setStatus('current')
cablePreferencesTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100), )
if mibBuilder.loadTexts: cablePreferencesTable.setStatus('current')
cablePreferencesEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "cablePrefInputNumber"))
if mibBuilder.loadTexts: cablePreferencesEntry.setStatus('current')
cablePrefInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100, 1, 1), InputNumber())
if mibBuilder.loadTexts: cablePrefInputNumber.setStatus('current')
cablePrefNoiseMarginMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100, 1, 2), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cablePrefNoiseMarginMin.setStatus('current')
cablePrefEstNoiseMarginMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100, 1, 3), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cablePrefEstNoiseMarginMin.setStatus('current')
cablePrefSignQualBoxSize = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100, 1, 4), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cablePrefSignQualBoxSize.setStatus('current')
cablePrefSignQualPercentMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100, 1, 5), Integer32()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cablePrefSignQualPercentMax.setStatus('current')
cablePrefENDBER = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100, 1, 6), FloatingPoint().clone('1E-04')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cablePrefENDBER.setStatus('current')
cablePrefENDCtoNSpecified = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100, 1, 7), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: cablePrefENDCtoNSpecified.setStatus('current')
cablePrefENDIdeal = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100, 1, 8), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cablePrefENDIdeal.setStatus('current')
cablePrefENDMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 7, 100, 1, 9), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: cablePrefENDMax.setStatus('current')
tr101290Satellite = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8))
berViterbiSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1), )
if mibBuilder.loadTexts: berViterbiSTable.setStatus('current')
berViterbiSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "berViterbiSInputNumber"))
if mibBuilder.loadTexts: berViterbiSEntry.setStatus('current')
berViterbiSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: berViterbiSInputNumber.setStatus('current')
berViterbiSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiSTestState.setStatus('current')
berViterbiSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berViterbiSEnable.setStatus('current')
berViterbiSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiSCounter.setStatus('current')
berViterbiSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiSCounterDiscontinuity.setStatus('current')
berViterbiSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berViterbiSCounterReset.setStatus('current')
berViterbiSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiSLatestError.setStatus('current')
berViterbiSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiSActiveTime.setStatus('current')
berViterbiSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiSMeasurementState.setStatus('current')
berViterbiSIValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiSIValue.setStatus('current')
berViterbiSQValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 11), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiSQValue.setStatus('current')
berViterbiSMeasurementMethod = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 1, 1, 12), BERMeasurementMethod()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiSMeasurementMethod.setStatus('current')
ifSpectrumTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 2), )
if mibBuilder.loadTexts: ifSpectrumTable.setStatus('current')
ifSpectrumEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "ifSpectrumInputNumber"))
if mibBuilder.loadTexts: ifSpectrumEntry.setStatus('current')
ifSpectrumInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: ifSpectrumInputNumber.setStatus('current')
ifSpectrumTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: ifSpectrumTestState.setStatus('current')
ifSpectrumEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: ifSpectrumEnable.setStatus('current')
ifSpectrumCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: ifSpectrumCounter.setStatus('current')
ifSpectrumCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: ifSpectrumCounterDiscontinuity.setStatus('current')
ifSpectrumCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 2, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: ifSpectrumCounterReset.setStatus('current')
ifSpectrumLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: ifSpectrumLatestError.setStatus('current')
ifSpectrumActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 2, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: ifSpectrumActiveTime.setStatus('current')
satellitePreferencesTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 100), )
if mibBuilder.loadTexts: satellitePreferencesTable.setStatus('current')
satellitePreferencesEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 100, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "satellitePrefInputNumber"))
if mibBuilder.loadTexts: satellitePreferencesEntry.setStatus('current')
satellitePrefInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 100, 1, 1), InputNumber())
if mibBuilder.loadTexts: satellitePrefInputNumber.setStatus('current')
satellitePrefBERMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 8, 100, 1, 2), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: satellitePrefBERMax.setStatus('current')
tr101290Terrestrial = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9))
rfTerr = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1))
rfAccuracyTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1), )
if mibBuilder.loadTexts: rfAccuracyTable.setStatus('current')
rfAccuracyEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "rfAccuracyInputNumber"))
if mibBuilder.loadTexts: rfAccuracyEntry.setStatus('current')
rfAccuracyInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: rfAccuracyInputNumber.setStatus('current')
rfAccuracyTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfAccuracyTestState.setStatus('current')
rfAccuracyEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfAccuracyEnable.setStatus('current')
rfAccuracyCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfAccuracyCounter.setStatus('current')
rfAccuracyCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfAccuracyCounterDiscontinuity.setStatus('current')
rfAccuracyCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfAccuracyCounterReset.setStatus('current')
rfAccuracyLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfAccuracyLatestError.setStatus('current')
rfAccuracyActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: rfAccuracyActiveTime.setStatus('current')
rfAccuracyMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfAccuracyMeasurementState.setStatus('current')
rfAccuracyValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 1, 1, 10), FloatingPoint()).setUnits('Hz').setMaxAccess("readonly")
if mibBuilder.loadTexts: rfAccuracyValue.setStatus('current')
rfChannelWidthTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2), )
if mibBuilder.loadTexts: rfChannelWidthTable.setStatus('current')
rfChannelWidthEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "rfChannelWidthInputNumber"))
if mibBuilder.loadTexts: rfChannelWidthEntry.setStatus('current')
rfChannelWidthInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: rfChannelWidthInputNumber.setStatus('current')
rfChannelWidthTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfChannelWidthTestState.setStatus('current')
rfChannelWidthEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfChannelWidthEnable.setStatus('current')
rfChannelWidthCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfChannelWidthCounter.setStatus('current')
rfChannelWidthCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfChannelWidthCounterDiscontinuity.setStatus('current')
rfChannelWidthCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfChannelWidthCounterReset.setStatus('current')
rfChannelWidthLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfChannelWidthLatestError.setStatus('current')
rfChannelWidthActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: rfChannelWidthActiveTime.setStatus('current')
rfChannelWidthMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfChannelWidthMeasurementState.setStatus('current')
rfChannelWidthValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 2, 1, 10), FloatingPoint()).setUnits('Hz').setMaxAccess("readonly")
if mibBuilder.loadTexts: rfChannelWidthValue.setStatus('current')
symbolLengthTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3), )
if mibBuilder.loadTexts: symbolLengthTable.setStatus('current')
symbolLengthEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "symbolLengthInputNumber"))
if mibBuilder.loadTexts: symbolLengthEntry.setStatus('current')
symbolLengthInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1, 1), InputNumber())
if mibBuilder.loadTexts: symbolLengthInputNumber.setStatus('current')
symbolLengthTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: symbolLengthTestState.setStatus('current')
symbolLengthEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: symbolLengthEnable.setStatus('current')
symbolLengthCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: symbolLengthCounter.setStatus('current')
symbolLengthCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: symbolLengthCounterDiscontinuity.setStatus('current')
symbolLengthCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: symbolLengthCounterReset.setStatus('current')
symbolLengthLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: symbolLengthLatestError.setStatus('current')
symbolLengthActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: symbolLengthActiveTime.setStatus('current')
symbolLengthMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: symbolLengthMeasurementState.setStatus('current')
symbolLengthValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 1, 3, 1, 10), FloatingPoint()).setUnits('microsecond').setMaxAccess("readonly")
if mibBuilder.loadTexts: symbolLengthValue.setStatus('current')
rfIfPowerTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5), )
if mibBuilder.loadTexts: rfIfPowerTable.setStatus('current')
rfIfPowerEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "rfIfPowerInputNumber"))
if mibBuilder.loadTexts: rfIfPowerEntry.setStatus('current')
rfIfPowerInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1, 1), InputNumber())
if mibBuilder.loadTexts: rfIfPowerInputNumber.setStatus('current')
rfIfPowerTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfPowerTestState.setStatus('current')
rfIfPowerEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfIfPowerEnable.setStatus('current')
rfIfPowerCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfPowerCounter.setStatus('current')
rfIfPowerCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfPowerCounterDiscontinuity.setStatus('current')
rfIfPowerCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfIfPowerCounterReset.setStatus('current')
rfIfPowerLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfPowerLatestError.setStatus('current')
rfIfPowerActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfPowerActiveTime.setStatus('current')
rfIfPowerMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfPowerMeasurementState.setStatus('current')
rfIfPowerValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 5, 1, 10), FloatingPoint()).setUnits('dBm').setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfPowerValue.setStatus('current')
rfIfSpectrumTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 7), )
if mibBuilder.loadTexts: rfIfSpectrumTable.setStatus('current')
rfIfSpectrumEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 7, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "rfIfSpectrumInputNumber"))
if mibBuilder.loadTexts: rfIfSpectrumEntry.setStatus('current')
rfIfSpectrumInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 7, 1, 1), InputNumber())
if mibBuilder.loadTexts: rfIfSpectrumInputNumber.setStatus('current')
rfIfSpectrumTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 7, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfSpectrumTestState.setStatus('current')
rfIfSpectrumEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 7, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfIfSpectrumEnable.setStatus('current')
rfIfSpectrumCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 7, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfSpectrumCounter.setStatus('current')
rfIfSpectrumCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 7, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfSpectrumCounterDiscontinuity.setStatus('current')
rfIfSpectrumCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 7, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rfIfSpectrumCounterReset.setStatus('current')
rfIfSpectrumLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 7, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfSpectrumLatestError.setStatus('current')
rfIfSpectrumActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 7, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: rfIfSpectrumActiveTime.setStatus('current')
eNDT = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9))
eNDTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1), )
if mibBuilder.loadTexts: eNDTTable.setStatus('current')
eNDTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "eNDTInputNumber"))
if mibBuilder.loadTexts: eNDTEntry.setStatus('current')
eNDTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: eNDTInputNumber.setStatus('current')
eNDTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTTestState.setStatus('current')
eNDTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: eNDTEnable.setStatus('current')
eNDTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTCounter.setStatus('current')
eNDTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTCounterDiscontinuity.setStatus('current')
eNDTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: eNDTCounterReset.setStatus('current')
eNDTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTLatestError.setStatus('current')
eNDTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTActiveTime.setStatus('current')
eNDTMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTMeasurementState.setStatus('current')
eNDTValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 1, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTValue.setStatus('current')
eNFTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2), )
if mibBuilder.loadTexts: eNFTTable.setStatus('current')
eNFTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "eNFTInputNumber"))
if mibBuilder.loadTexts: eNFTEntry.setStatus('current')
eNFTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: eNFTInputNumber.setStatus('current')
eNFTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTTestState.setStatus('current')
eNFTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: eNFTEnable.setStatus('current')
eNFTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTCounter.setStatus('current')
eNFTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTCounterDiscontinuity.setStatus('current')
eNFTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: eNFTCounterReset.setStatus('current')
eNFTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTLatestError.setStatus('current')
eNFTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTActiveTime.setStatus('current')
eNFTMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTMeasurementState.setStatus('current')
eNFTValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 2, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTValue.setStatus('current')
eNDTLPTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3), )
if mibBuilder.loadTexts: eNDTLPTable.setStatus('current')
eNDTLPEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "eNDTLPInputNumber"))
if mibBuilder.loadTexts: eNDTLPEntry.setStatus('current')
eNDTLPInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1, 1), InputNumber())
if mibBuilder.loadTexts: eNDTLPInputNumber.setStatus('current')
eNDTLPTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTLPTestState.setStatus('current')
eNDTLPEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: eNDTLPEnable.setStatus('current')
eNDTLPCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTLPCounter.setStatus('current')
eNDTLPCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTLPCounterDiscontinuity.setStatus('current')
eNDTLPCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: eNDTLPCounterReset.setStatus('current')
eNDTLPLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTLPLatestError.setStatus('current')
eNDTLPActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1, 8), ActiveTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTLPActiveTime.setStatus('current')
eNDTLPMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTLPMeasurementState.setStatus('current')
eNDTLPValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 3, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: eNDTLPValue.setStatus('current')
eNFTLPTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4), )
if mibBuilder.loadTexts: eNFTLPTable.setStatus('current')
eNFTLPEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "eNDTLPInputNumber"))
if mibBuilder.loadTexts: eNFTLPEntry.setStatus('current')
eNFTLPInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1, 1), InputNumber())
if mibBuilder.loadTexts: eNFTLPInputNumber.setStatus('current')
eNFTLPTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTLPTestState.setStatus('current')
eNFTLPEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: eNFTLPEnable.setStatus('current')
eNFTLPCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTLPCounter.setStatus('current')
eNFTLPCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTLPCounterDiscontinuity.setStatus('current')
eNFTLPCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: eNFTLPCounterReset.setStatus('current')
eNFTLPLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTLPLatestError.setStatus('current')
eNFTLPActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1, 8), ActiveTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTLPActiveTime.setStatus('current')
eNFTLPMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTLPMeasurementState.setStatus('current')
eNFTLPValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 9, 4, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: eNFTLPValue.setStatus('current')
linearityTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10), )
if mibBuilder.loadTexts: linearityTable.setStatus('current')
linearityEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "linearityInputNumber"))
if mibBuilder.loadTexts: linearityEntry.setStatus('current')
linearityInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1, 1), InputNumber())
if mibBuilder.loadTexts: linearityInputNumber.setStatus('current')
linearityTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linearityTestState.setStatus('current')
linearityEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: linearityEnable.setStatus('current')
linearityCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linearityCounter.setStatus('current')
linearityCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linearityCounterDiscontinuity.setStatus('current')
linearityCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: linearityCounterReset.setStatus('current')
linearityLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linearityLatestError.setStatus('current')
linearityActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: linearityActiveTime.setStatus('current')
linearityMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: linearityMeasurementState.setStatus('current')
linearityValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 10, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: linearityValue.setStatus('current')
berViterbiT = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15))
berViterbiTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1), )
if mibBuilder.loadTexts: berViterbiTTable.setStatus('current')
berViterbiTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "berViterbiTInputNumber"))
if mibBuilder.loadTexts: berViterbiTEntry.setStatus('current')
berViterbiTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: berViterbiTInputNumber.setStatus('current')
berViterbiTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTTestState.setStatus('current')
berViterbiTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berViterbiTEnable.setStatus('current')
berViterbiTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTCounter.setStatus('current')
berViterbiTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTCounterDiscontinuity.setStatus('current')
berViterbiTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berViterbiTCounterReset.setStatus('current')
berViterbiTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTLatestError.setStatus('current')
berViterbiTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1, 8), ActiveTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTActiveTime.setStatus('current')
berViterbiTMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTMeasurementState.setStatus('current')
berViterbiTValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 1, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTValue.setStatus('current')
berViterbiTLPTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2), )
if mibBuilder.loadTexts: berViterbiTLPTable.setStatus('current')
berViterbiTLPEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "berViterbiTLPInputNumber"))
if mibBuilder.loadTexts: berViterbiTLPEntry.setStatus('current')
berViterbiTLPInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: berViterbiTLPInputNumber.setStatus('current')
berViterbiTLPTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTLPTestState.setStatus('current')
berViterbiTLPEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berViterbiTLPEnable.setStatus('current')
berViterbiTLPCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTLPCounter.setStatus('current')
berViterbiTLPCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTLPCounterDiscontinuity.setStatus('current')
berViterbiTLPCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berViterbiTLPCounterReset.setStatus('current')
berViterbiTLPLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTLPLatestError.setStatus('current')
berViterbiTLPActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1, 8), ActiveTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTLPActiveTime.setStatus('current')
berViterbiTLPMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTLPMeasurementState.setStatus('current')
berViterbiTLPValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 15, 2, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: berViterbiTLPValue.setStatus('current')
berRS = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16))
berRSTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1), )
if mibBuilder.loadTexts: berRSTable.setStatus('current')
berRSEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "berRSInputNumber"))
if mibBuilder.loadTexts: berRSEntry.setStatus('current')
berRSInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: berRSInputNumber.setStatus('current')
berRSTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSTestState.setStatus('current')
berRSEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berRSEnable.setStatus('current')
berRSCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSCounter.setStatus('current')
berRSCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSCounterDiscontinuity.setStatus('current')
berRSCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berRSCounterReset.setStatus('current')
berRSLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSLatestError.setStatus('current')
berRSActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1, 8), ActiveTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSActiveTime.setStatus('current')
berRSMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSMeasurementState.setStatus('current')
berRSValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 1, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSValue.setStatus('current')
berRSLPTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2), )
if mibBuilder.loadTexts: berRSLPTable.setStatus('current')
berRSLPEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "berRSLPInputNumber"))
if mibBuilder.loadTexts: berRSLPEntry.setStatus('current')
berRSLPInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: berRSLPInputNumber.setStatus('current')
berRSLPTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSLPTestState.setStatus('current')
berRSLPEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berRSLPEnable.setStatus('current')
berRSLPCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSLPCounter.setStatus('current')
berRSLPCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSLPCounterDiscontinuity.setStatus('current')
berRSLPCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: berRSLPCounterReset.setStatus('current')
berRSLPLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSLPLatestError.setStatus('current')
berRSLPActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1, 8), ActiveTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSLPActiveTime.setStatus('current')
berRSLPMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSLPMeasurementState.setStatus('current')
berRSLPValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 16, 2, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: berRSLPValue.setStatus('current')
iqAnalysisT = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18))
merTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2), )
if mibBuilder.loadTexts: merTTable.setStatus('current')
merTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "merTInputNumber"))
if mibBuilder.loadTexts: merTEntry.setStatus('current')
merTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: merTInputNumber.setStatus('current')
merTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: merTTestState.setStatus('current')
merTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: merTEnable.setStatus('current')
merTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: merTCounter.setStatus('current')
merTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: merTCounterDiscontinuity.setStatus('current')
merTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: merTCounterReset.setStatus('current')
merTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: merTLatestError.setStatus('current')
merTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: merTActiveTime.setStatus('current')
merTMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: merTMeasurementState.setStatus('current')
merTValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 2, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: merTValue.setStatus('current')
steT = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3))
steMeanTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1), )
if mibBuilder.loadTexts: steMeanTTable.setStatus('current')
steMeanTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "steMeanTInputNumber"))
if mibBuilder.loadTexts: steMeanTEntry.setStatus('current')
steMeanTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: steMeanTInputNumber.setStatus('current')
steMeanTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanTTestState.setStatus('current')
steMeanTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: steMeanTEnable.setStatus('current')
steMeanTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanTCounter.setStatus('current')
steMeanTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanTCounterDiscontinuity.setStatus('current')
steMeanTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: steMeanTCounterReset.setStatus('current')
steMeanTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanTLatestError.setStatus('current')
steMeanTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanTActiveTime.setStatus('current')
steMeanTMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanTMeasurementState.setStatus('current')
steMeanTValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 1, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steMeanTValue.setStatus('current')
steDeviationTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2), )
if mibBuilder.loadTexts: steDeviationTTable.setStatus('current')
steDeviationTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "steDeviationTInputNumber"))
if mibBuilder.loadTexts: steDeviationTEntry.setStatus('current')
steDeviationTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: steDeviationTInputNumber.setStatus('current')
steDeviationTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationTTestState.setStatus('current')
steDeviationTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: steDeviationTEnable.setStatus('current')
steDeviationTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationTCounter.setStatus('current')
steDeviationTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationTCounterDiscontinuity.setStatus('current')
steDeviationTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: steDeviationTCounterReset.setStatus('current')
steDeviationTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationTLatestError.setStatus('current')
steDeviationTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationTActiveTime.setStatus('current')
steDeviationTMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationTMeasurementState.setStatus('current')
steDeviationTValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 3, 2, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: steDeviationTValue.setStatus('current')
csTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4), )
if mibBuilder.loadTexts: csTTable.setStatus('current')
csTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "csTInputNumber"))
if mibBuilder.loadTexts: csTEntry.setStatus('current')
csTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1, 1), InputNumber())
if mibBuilder.loadTexts: csTInputNumber.setStatus('current')
csTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: csTTestState.setStatus('current')
csTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: csTEnable.setStatus('current')
csTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: csTCounter.setStatus('current')
csTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: csTCounterDiscontinuity.setStatus('current')
csTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: csTCounterReset.setStatus('current')
csTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: csTLatestError.setStatus('current')
csTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: csTActiveTime.setStatus('current')
csTMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: csTMeasurementState.setStatus('current')
csTValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 4, 1, 10), FloatingPoint()).setUnits('dB').setMaxAccess("readonly")
if mibBuilder.loadTexts: csTValue.setStatus('current')
aiTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5), )
if mibBuilder.loadTexts: aiTTable.setStatus('current')
aiTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "aiTInputNumber"))
if mibBuilder.loadTexts: aiTEntry.setStatus('current')
aiTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1, 1), InputNumber())
if mibBuilder.loadTexts: aiTInputNumber.setStatus('current')
aiTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiTTestState.setStatus('current')
aiTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: aiTEnable.setStatus('current')
aiTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiTCounter.setStatus('current')
aiTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiTCounterDiscontinuity.setStatus('current')
aiTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: aiTCounterReset.setStatus('current')
aiTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiTLatestError.setStatus('current')
aiTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: aiTActiveTime.setStatus('current')
aiTMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiTMeasurementState.setStatus('current')
aiTValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 5, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: aiTValue.setStatus('current')
qeTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6), )
if mibBuilder.loadTexts: qeTTable.setStatus('current')
qeTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "qeTInputNumber"))
if mibBuilder.loadTexts: qeTEntry.setStatus('current')
qeTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1, 1), InputNumber())
if mibBuilder.loadTexts: qeTInputNumber.setStatus('current')
qeTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: qeTTestState.setStatus('current')
qeTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: qeTEnable.setStatus('current')
qeTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: qeTCounter.setStatus('current')
qeTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: qeTCounterDiscontinuity.setStatus('current')
qeTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: qeTCounterReset.setStatus('current')
qeTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: qeTLatestError.setStatus('current')
qeTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: qeTActiveTime.setStatus('current')
qeTMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: qeTMeasurementState.setStatus('current')
qeTValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 6, 1, 10), FloatingPoint()).setUnits('degree').setMaxAccess("readonly")
if mibBuilder.loadTexts: qeTValue.setStatus('current')
pjTTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7), )
if mibBuilder.loadTexts: pjTTable.setStatus('current')
pjTEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "pjTInputNumber"))
if mibBuilder.loadTexts: pjTEntry.setStatus('current')
pjTInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1, 1), InputNumber())
if mibBuilder.loadTexts: pjTInputNumber.setStatus('current')
pjTTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: pjTTestState.setStatus('current')
pjTEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: pjTEnable.setStatus('current')
pjTCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: pjTCounter.setStatus('current')
pjTCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: pjTCounterDiscontinuity.setStatus('current')
pjTCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1, 6), TruthValue().clone('false')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: pjTCounterReset.setStatus('current')
pjTLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: pjTLatestError.setStatus('current')
pjTActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: pjTActiveTime.setStatus('current')
pjTMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: pjTMeasurementState.setStatus('current')
pjTValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 18, 7, 1, 10), FloatingPoint()).setUnits('degree').setMaxAccess("readonly")
if mibBuilder.loadTexts: pjTValue.setStatus('current')
mipSyntaxTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20), )
if mibBuilder.loadTexts: mipSyntaxTable.setStatus('current')
mipSyntaxEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "mipSyntaxTestNumber"), (0, "DVB-MGTR101290-MIB", "mipSyntaxInputNumber"))
if mibBuilder.loadTexts: mipSyntaxEntry.setStatus('current')
mipSyntaxInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20, 1, 1), InputNumber())
if mibBuilder.loadTexts: mipSyntaxInputNumber.setStatus('current')
mipSyntaxTestNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20, 1, 2), IndexMIPSyntaxTest())
if mibBuilder.loadTexts: mipSyntaxTestNumber.setStatus('current')
mipSyntaxState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20, 1, 3), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: mipSyntaxState.setStatus('current')
mipSyntaxEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20, 1, 4), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: mipSyntaxEnable.setStatus('current')
mipSyntaxCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20, 1, 5), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: mipSyntaxCounter.setStatus('current')
mipSyntaxCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20, 1, 6), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: mipSyntaxCounterDiscontinuity.setStatus('current')
mipSyntaxCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20, 1, 7), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: mipSyntaxCounterReset.setStatus('current')
mipSyntaxLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20, 1, 8), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: mipSyntaxLatestError.setStatus('current')
mipSyntaxActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 20, 1, 9), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: mipSyntaxActiveTime.setStatus('current')
systemErrorPerformance = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21))
sepEtiTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1), )
if mibBuilder.loadTexts: sepEtiTable.setStatus('current')
sepEtiEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "sepEtiInputNumber"))
if mibBuilder.loadTexts: sepEtiEntry.setStatus('current')
sepEtiInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1, 1), InputNumber())
if mibBuilder.loadTexts: sepEtiInputNumber.setStatus('current')
sepEtiTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepEtiTestState.setStatus('current')
sepEtiEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: sepEtiEnable.setStatus('current')
sepEtiCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepEtiCounter.setStatus('current')
sepEtiCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepEtiCounterDiscontinuity.setStatus('current')
sepEtiCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: sepEtiCounterReset.setStatus('current')
sepEtiLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepEtiLatestError.setStatus('current')
sepEtiActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: sepEtiActiveTime.setStatus('current')
sepEtiMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepEtiMeasurementState.setStatus('current')
sepEtiValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 1, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepEtiValue.setStatus('current')
sepSetiTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2), )
if mibBuilder.loadTexts: sepSetiTable.setStatus('current')
sepSetiEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "sepSetiInputNumber"))
if mibBuilder.loadTexts: sepSetiEntry.setStatus('current')
sepSetiInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1, 1), InputNumber())
if mibBuilder.loadTexts: sepSetiInputNumber.setStatus('current')
sepSetiTestState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1, 2), TestState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepSetiTestState.setStatus('current')
sepSetiEnable = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1, 3), Enable().clone(namedValues=NamedValues(("testEnable", 0)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: sepSetiEnable.setStatus('current')
sepSetiCounter = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1, 4), Counter32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepSetiCounter.setStatus('current')
sepSetiCounterDiscontinuity = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1, 5), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepSetiCounterDiscontinuity.setStatus('current')
sepSetiCounterReset = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: sepSetiCounterReset.setStatus('current')
sepSetiLatestError = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1, 7), DateAndTime()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepSetiLatestError.setStatus('current')
sepSetiActiveTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1, 8), ActiveTime()).setUnits('second').setMaxAccess("readonly")
if mibBuilder.loadTexts: sepSetiActiveTime.setStatus('current')
sepSetiMeasurementState = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1, 9), MeasurementState()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepSetiMeasurementState.setStatus('current')
sepSetiValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 21, 2, 1, 10), FloatingPoint()).setMaxAccess("readonly")
if mibBuilder.loadTexts: sepSetiValue.setStatus('current')
terrestrialPreferencesTable = MibTable((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100), )
if mibBuilder.loadTexts: terrestrialPreferencesTable.setStatus('current')
terrestrialPreferencesEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1), ).setIndexNames((0, "DVB-MGTR101290-MIB", "terrestrialPrefInputNumber"))
if mibBuilder.loadTexts: terrestrialPreferencesEntry.setStatus('current')
terrestrialPrefInputNumber = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 1), InputNumber())
if mibBuilder.loadTexts: terrestrialPrefInputNumber.setStatus('current')
terrestrialPrefCentreFrequency = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 2), FloatingPoint()).setUnits('MHz').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefCentreFrequency.setStatus('current')
terrestrialPrefBandwidth = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 3), FloatingPoint()).setUnits('MHz').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefBandwidth.setStatus('current')
terrestrialPrefModulation = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 4), Modulation()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefModulation.setStatus('current')
terrestrialPrefTransmissionMode = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 5), TerrestrialTransmissionMode()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefTransmissionMode.setStatus('current')
terrestrialPrefGuardInterval = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 6), GuardInterval()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefGuardInterval.setStatus('current')
terrestrialPrefHierarchical = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 7), Hierarchy()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefHierarchical.setStatus('current')
terrestrialPrefCentreFreqExpected = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 8), FloatingPoint()).setUnits('Hz').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefCentreFreqExpected.setStatus('current')
terrestrialPrefCentreFreqLimit = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 9), FloatingPoint()).setUnits('Hz').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefCentreFreqLimit.setStatus('current')
terrestrialPrefChannelWidthLimit = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 10), FloatingPoint()).setUnits('Hz').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefChannelWidthLimit.setStatus('current')
terrestrialPrefSymbolLengthLimit = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 11), FloatingPoint()).setUnits('s').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefSymbolLengthLimit.setStatus('current')
terrestrialPrefPowerMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 12), FloatingPoint()).setUnits('dBm').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefPowerMin.setStatus('current')
terrestrialPrefPowerMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 13), FloatingPoint()).setUnits('dBm').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefPowerMax.setStatus('current')
terrestrialPrefENDBER = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 14), FloatingPoint().clone('2E-04')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefENDBER.setStatus('current')
terrestrialPrefENDIdeal = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 15), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefENDIdeal.setStatus('current')
terrestrialPrefENDMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 16), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefENDMax.setStatus('current')
terrestrialPrefENFIdeal = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 17), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefENFIdeal.setStatus('current')
terrestrialPrefENFMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 18), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefENFMax.setStatus('current')
terrestrialPrefENDLPIdeal = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 19), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefENDLPIdeal.setStatus('current')
terrestrialPrefENDLPMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 20), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefENDLPMax.setStatus('current')
terrestrialPrefENFLPIdeal = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 21), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefENFLPIdeal.setStatus('current')
terrestrialPrefENFLPMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 22), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefENFLPMax.setStatus('current')
terrestrialPrefLinearityMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 23), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefLinearityMin.setStatus('current')
terrestrialPrefBERViterbiMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 24), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefBERViterbiMax.setStatus('current')
terrestrialPrefBERViterbiLPMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 25), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefBERViterbiLPMax.setStatus('current')
terrestrialPrefBERRSMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 26), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefBERRSMax.setStatus('current')
terrestrialPrefBERRSLPMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 27), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefBERRSLPMax.setStatus('current')
terrestrialPrefMerTMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 28), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefMerTMin.setStatus('current')
terrestrialPrefSteMeanMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 29), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefSteMeanMax.setStatus('current')
terrestrialPrefSteDeviationMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 30), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefSteDeviationMax.setStatus('current')
terrestrialPrefCsMin = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 31), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefCsMin.setStatus('current')
terrestrialPrefAiMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 32), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefAiMax.setStatus('current')
terrestrialPrefQeMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 33), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefQeMax.setStatus('current')
terrestrialPrefPjMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 34), FloatingPoint()).setUnits('dB').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefPjMax.setStatus('current')
terrestrialPrefMIPTimingLimit = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 35), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefMIPTimingLimit.setStatus('current')
terrestrialPrefMIPDeviationMax = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 36), FloatingPoint()).setUnits('bit/s').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefMIPDeviationMax.setStatus('current')
terrestrialPrefSEPUATMode = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 37), UATMode()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefSEPUATMode.setStatus('current')
terrestrialPrefSEPN = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 38), Unsigned32()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefSEPN.setStatus('current')
terrestrialPrefSEPT = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 39), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefSEPT.setStatus('current')
terrestrialPrefSEPM = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 40), Unsigned32()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefSEPM.setStatus('current')
terrestrialPrefSEPTI = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 41), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefSEPTI.setStatus('current')
terrestrialPrefSEPEBPerCent = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 42), FloatingPoint()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefSEPEBPerCent.setStatus('current')
terrestrialPrefSEPMeasurementInterval = MibTableColumn((1, 3, 6, 1, 4, 1, 2696, 3, 2, 1, 9, 100, 1, 43), FloatingPoint()).setUnits('second').setMaxAccess("readwrite")
if mibBuilder.loadTexts: terrestrialPrefSEPMeasurementInterval.setStatus('current')
tr101290Conformance = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3))
tr101290Compliances = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 1))
complianceTransportStream = ModuleCompliance((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 1, 1)).setObjects(("DVB-MGTR101290-MIB", "groupControl"), ("DVB-MGTR101290-MIB", "groupCapability"), ("DVB-MGTR101290-MIB", "groupTransportStream"), ("DVB-MGTR101290-MIB", "groupTrapControl"), ("DVB-MGTR101290-MIB", "groupTraps"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
complianceTransportStream = complianceTransportStream.setStatus('current')
complianceCable = ModuleCompliance((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 1, 2)).setObjects(("DVB-MGTR101290-MIB", "groupControl"), ("DVB-MGTR101290-MIB", "groupTrapControl"), ("DVB-MGTR101290-MIB", "groupTraps"), ("DVB-MGTR101290-MIB", "groupCapability"), ("DVB-MGTR101290-MIB", "groupCable"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
complianceCable = complianceCable.setStatus('current')
complianceSatellite = ModuleCompliance((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 1, 3)).setObjects(("DVB-MGTR101290-MIB", "groupControl"), ("DVB-MGTR101290-MIB", "groupTrapControl"), ("DVB-MGTR101290-MIB", "groupTraps"), ("DVB-MGTR101290-MIB", "groupCapability"), ("DVB-MGTR101290-MIB", "groupSatellite"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
complianceSatellite = complianceSatellite.setStatus('current')
complianceTerrestrial = ModuleCompliance((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 1, 4)).setObjects(("DVB-MGTR101290-MIB", "groupControl"), ("DVB-MGTR101290-MIB", "groupTrapControl"), ("DVB-MGTR101290-MIB", "groupTraps"), ("DVB-MGTR101290-MIB", "groupCapability"), ("DVB-MGTR101290-MIB", "groupTerrestrial"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
complianceTerrestrial = complianceTerrestrial.setStatus('current')
tr101290ObjectGroups = MibIdentifier((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 2))
groupControl = ObjectGroup((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 2, 1)).setObjects(("DVB-MGTR101290-MIB", "controlNow"), ("DVB-MGTR101290-MIB", "controlEventPersistence"), ("DVB-MGTR101290-MIB", "rfSystemDelivery"), ("DVB-MGTR101290-MIB", "controlSynchronizedTime"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
groupControl = groupControl.setStatus('current')
groupTrapControl = ObjectGroup((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 2, 2)).setObjects(("DVB-MGTR101290-MIB", "trapControlOID"), ("DVB-MGTR101290-MIB", "trapControlGenerationTime"), ("DVB-MGTR101290-MIB", "trapControlMeasurementValue"), ("DVB-MGTR101290-MIB", "trapControlRateStatus"), ("DVB-MGTR101290-MIB", "trapControlPeriod"), ("DVB-MGTR101290-MIB", "trapControlFailureSummary"), ("DVB-MGTR101290-MIB", "trapInput"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
groupTrapControl = groupTrapControl.setStatus('current')
groupTraps = NotificationGroup((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 2, 3)).setObjects(("DVB-MGTR101290-MIB", "testFailTrap"), ("DVB-MGTR101290-MIB", "measurementFailTrap"), ("DVB-MGTR101290-MIB", "measurementUnknownTrap"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
groupTraps = groupTraps.setStatus('current')
groupCapability = ObjectGroup((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 2, 4)).setObjects(("DVB-MGTR101290-MIB", "capabilityMIBRevision"), ("DVB-MGTR101290-MIB", "capabilityTSGroup"), ("DVB-MGTR101290-MIB", "capabilityTSAvailability"), ("DVB-MGTR101290-MIB", "capabilityTSPollInterval"), ("DVB-MGTR101290-MIB", "capabilityCableSatGroup"), ("DVB-MGTR101290-MIB", "capabilityCableSatAvailability"), ("DVB-MGTR101290-MIB", "capabilityCableSatPollInterval"), ("DVB-MGTR101290-MIB", "capabilityCableGroup"), ("DVB-MGTR101290-MIB", "capabilityCableAvailability"), ("DVB-MGTR101290-MIB", "capabilityCablePollInterval"), ("DVB-MGTR101290-MIB", "capabilitySatelliteGroup"), ("DVB-MGTR101290-MIB", "capabilitySatelliteAvailability"), ("DVB-MGTR101290-MIB", "capabilitySatellitePollInterval"), ("DVB-MGTR101290-MIB", "capabilityTerrestrialGroup"), ("DVB-MGTR101290-MIB", "capabilityTerrestrialAvailability"), ("DVB-MGTR101290-MIB", "capabilityTerrestrialPollInterval"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
groupCapability = groupCapability.setStatus('current')
groupTransportStream = ObjectGroup((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 2, 5)).setObjects(("DVB-MGTR101290-MIB", "tsTestsSummaryState"), ("DVB-MGTR101290-MIB", "tsTestsSummaryEnable"), ("DVB-MGTR101290-MIB", "tsTestsSummaryCounter"), ("DVB-MGTR101290-MIB", "tsTestsSummaryCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "tsTestsSummaryCounterReset"), ("DVB-MGTR101290-MIB", "tsTestsSummaryLatestError"), ("DVB-MGTR101290-MIB", "tsTestsSummaryActiveTime"), ("DVB-MGTR101290-MIB", "tsTestsPIDRowStatus"), ("DVB-MGTR101290-MIB", "tsTestsPIDState"), ("DVB-MGTR101290-MIB", "tsTestsPIDEnable"), ("DVB-MGTR101290-MIB", "tsTestsPIDCounter"), ("DVB-MGTR101290-MIB", "tsTestsPIDCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "tsTestsPIDCounterReset"), ("DVB-MGTR101290-MIB", "tsTestsPIDLatestError"), ("DVB-MGTR101290-MIB", "tsTestsPIDActiveTime"), ("DVB-MGTR101290-MIB", "tsTestsPrefTransitionDuration"), ("DVB-MGTR101290-MIB", "tsTestsPrefPATSectionIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefPMTSectionIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefReferredIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefPCRIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefPCRDiscontinuityMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefPCRInaccuracyMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefPTSIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefNITActualIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefNITActualIntervalMin"), ("DVB-MGTR101290-MIB", "tsTestsPrefNITOtherIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefSIGapMin"), ("DVB-MGTR101290-MIB", "tsTestsPrefNITTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefBATTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefSDTActualTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefSDTOtherTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefEITPFActualTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefEITPFOtherTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefEITSActualNearTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefEITSActualFarTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefEITSOtherNearTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefEITSOtherFarTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefTxTTableIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefSDTActualIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefSDTActualIntervalMin"), ("DVB-MGTR101290-MIB", "tsTestsPrefSDTOtherIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefEITActualIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefEITActualIntervalMin"), ("DVB-MGTR101290-MIB", "tsTestsPrefEITOtherIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefRSTIntervalMin"), ("DVB-MGTR101290-MIB", "tsTestsPrefTDTIntervalMax"), ("DVB-MGTR101290-MIB", "tsTestsPrefTDTIntervalMin"), ("DVB-MGTR101290-MIB", "tsTestsPrefPIDRowStatus"), ("DVB-MGTR101290-MIB", "tsTestsPrefPIDReferredIntervalMax"), ("DVB-MGTR101290-MIB", "tsPcrMeasurementRowStatus"), ("DVB-MGTR101290-MIB", "tsPcrMeasurementState"), ("DVB-MGTR101290-MIB", "tsPcrMeasurementEnable"), ("DVB-MGTR101290-MIB", "tsPcrMeasurementCounter"), ("DVB-MGTR101290-MIB", "tsPcrMeasurementCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "tsPcrMeasurementCounterReset"), ("DVB-MGTR101290-MIB", "tsPcrMeasurementLatestError"), ("DVB-MGTR101290-MIB", "tsPcrMeasurementActiveTime"), ("DVB-MGTR101290-MIB", "tsPcrMeasurementMeasurementState"), ("DVB-MGTR101290-MIB", "tsPcrMeasurementValue"), ("DVB-MGTR101290-MIB", "tsTransportStreamBitRateState"), ("DVB-MGTR101290-MIB", "tsTransportStreamBitRateEnable"), ("DVB-MGTR101290-MIB", "tsTransportStreamBitRateCounter"), ("DVB-MGTR101290-MIB", "tsTransportStreamBitRateCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "tsTransportStreamBitRateCounterReset"), ("DVB-MGTR101290-MIB", "tsTransportStreamBitRateLatestError"), ("DVB-MGTR101290-MIB", "tsTransportStreamBitRateActiveTime"), ("DVB-MGTR101290-MIB", "tsTransportStreamBitRateMeasurementState"), ("DVB-MGTR101290-MIB", "tsTransportStreamBitRateValue"), ("DVB-MGTR101290-MIB", "tsTransportStreamBitRateNomenclature"), ("DVB-MGTR101290-MIB", "tsServiceBitRateRowStatus"), ("DVB-MGTR101290-MIB", "tsServiceBitRateState"), ("DVB-MGTR101290-MIB", "tsServiceBitRateEnable"), ("DVB-MGTR101290-MIB", "tsServiceBitRateCounter"), ("DVB-MGTR101290-MIB", "tsServiceBitRateCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "tsServiceBitRateCounterReset"), ("DVB-MGTR101290-MIB", "tsServiceBitRateLatestError"), ("DVB-MGTR101290-MIB", "tsServiceBitRateActiveTime"), ("DVB-MGTR101290-MIB", "tsServiceBitRateMeasurementState"), ("DVB-MGTR101290-MIB", "tsServiceBitRateValue"), ("DVB-MGTR101290-MIB", "tsServiceBitRateNomenclature"), ("DVB-MGTR101290-MIB", "tsPIDBitRateRowStatus"), ("DVB-MGTR101290-MIB", "tsPIDBitRateState"), ("DVB-MGTR101290-MIB", "tsPIDBitRateEnable"), ("DVB-MGTR101290-MIB", "tsPIDBitRateCounter"), ("DVB-MGTR101290-MIB", "tsPIDBitRateCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "tsPIDBitRateCounterReset"), ("DVB-MGTR101290-MIB", "tsPIDBitRateLatestError"), ("DVB-MGTR101290-MIB", "tsPIDBitRateActiveTime"), ("DVB-MGTR101290-MIB", "tsPIDBitRateMeasurementState"), ("DVB-MGTR101290-MIB", "tsPIDBitRateValue"), ("DVB-MGTR101290-MIB", "tsPIDBitRateNomenclature"), ("DVB-MGTR101290-MIB", "tsConsistencyState"), ("DVB-MGTR101290-MIB", "tsConsistencyEnable"), ("DVB-MGTR101290-MIB", "tsConsistencyCounter"), ("DVB-MGTR101290-MIB", "tsConsistencyCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "tsConsistencyCounterReset"), ("DVB-MGTR101290-MIB", "tsConsistencyLatestError"), ("DVB-MGTR101290-MIB", "tsConsistencyActiveTime"), ("DVB-MGTR101290-MIB", "tsMeasurePrefPCRDemarcationFrequency"), ("DVB-MGTR101290-MIB", "tsMeasurePrefPCRFOMax"), ("DVB-MGTR101290-MIB", "tsMeasurePrefPCRDRMax"), ("DVB-MGTR101290-MIB", "tsMeasurePrefPCROJMax"), ("DVB-MGTR101290-MIB", "tsMeasurePrefTSBitRateTau"), ("DVB-MGTR101290-MIB", "tsMeasurePrefTSBitRateN"), ("DVB-MGTR101290-MIB", "tsMeasurePrefTSBitRateElement"), ("DVB-MGTR101290-MIB", "tsMeasurePrefTSBitRateMin"), ("DVB-MGTR101290-MIB", "tsMeasurePrefTSBitRateMax"), ("DVB-MGTR101290-MIB", "tsMeasurePrefAllServiceBitRateTau"), ("DVB-MGTR101290-MIB", "tsMeasurePrefAllServiceBitRateN"), ("DVB-MGTR101290-MIB", "tsMeasurePrefAllServiceBitRateElement"), ("DVB-MGTR101290-MIB", "tsMeasurePrefAllPIDBitRateTau"), ("DVB-MGTR101290-MIB", "tsMeasurePrefAllPIDBitRateN"), ("DVB-MGTR101290-MIB", "tsMeasurePrefAllPIDBitRateElement"), ("DVB-MGTR101290-MIB", "tsMeasurePrefExpectedTSID"), ("DVB-MGTR101290-MIB", "tsMeasurePrefServiceRowStatus"), ("DVB-MGTR101290-MIB", "tsMeasurePrefServiceBitRateTau"), ("DVB-MGTR101290-MIB", "tsMeasurePrefServiceBitRateN"), ("DVB-MGTR101290-MIB", "tsMeasurePrefServiceBitRateElement"), ("DVB-MGTR101290-MIB", "tsMeasurePrefServiceBitRateMin"), ("DVB-MGTR101290-MIB", "tsMeasurePrefServiceBitRateMax"), ("DVB-MGTR101290-MIB", "tsMeasurePrefPIDRowStatus"), ("DVB-MGTR101290-MIB", "tsMeasurePrefPIDBitRateTau"), ("DVB-MGTR101290-MIB", "tsMeasurePrefPIDBitRateN"), ("DVB-MGTR101290-MIB", "tsMeasurePrefPIDBitRateElement"), ("DVB-MGTR101290-MIB", "tsMeasurePrefPIDBitRateMin"), ("DVB-MGTR101290-MIB", "tsMeasurePrefPIDBitRateMax"), ("DVB-MGTR101290-MIB", "tsServicePerformanceState"), ("DVB-MGTR101290-MIB", "tsServicePerformanceEnable"), ("DVB-MGTR101290-MIB", "tsServicePerformanceCounter"), ("DVB-MGTR101290-MIB", "tsServicePerformanceCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "tsServicePerformanceCounterReset"), ("DVB-MGTR101290-MIB", "tsServicePerformanceLatestError"), ("DVB-MGTR101290-MIB", "tsServicePerformanceActiveTime"), ("DVB-MGTR101290-MIB", "tsServicePerformanceMeasurementState"), ("DVB-MGTR101290-MIB", "tsServicePerformanceError"), ("DVB-MGTR101290-MIB", "tsServicePerformanceErrorRatio"), ("DVB-MGTR101290-MIB", "tsSPPrefDeltaT"), ("DVB-MGTR101290-MIB", "tsSPPrefEvaluationTime"), ("DVB-MGTR101290-MIB", "tsSPPrefThreshold"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
groupTransportStream = groupTransportStream.setStatus('current')
groupCable = ObjectGroup((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 2, 6)).setObjects(("DVB-MGTR101290-MIB", "sysAvailabilityTestState"), ("DVB-MGTR101290-MIB", "sysAvailabilityEnable"), ("DVB-MGTR101290-MIB", "sysAvailabilityCounter"), ("DVB-MGTR101290-MIB", "sysAvailabilityCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "sysAvailabilityCounterReset"), ("DVB-MGTR101290-MIB", "sysAvailabilityLatestError"), ("DVB-MGTR101290-MIB", "sysAvailabilityActiveTime"), ("DVB-MGTR101290-MIB", "sysAvailabilityMeasurementState"), ("DVB-MGTR101290-MIB", "sysAvailabilityUnavailableTime"), ("DVB-MGTR101290-MIB", "sysAvailabilityRatio"), ("DVB-MGTR101290-MIB", "sysAvailabilityInSETI"), ("DVB-MGTR101290-MIB", "linkAvailabilityTestState"), ("DVB-MGTR101290-MIB", "linkAvailabilityEnable"), ("DVB-MGTR101290-MIB", "linkAvailabilityCounter"), ("DVB-MGTR101290-MIB", "linkAvailabilityCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "linkAvailabilityCounterReset"), ("DVB-MGTR101290-MIB", "linkAvailabilityLatestError"), ("DVB-MGTR101290-MIB", "linkAvailabilityActiveTime"), ("DVB-MGTR101290-MIB", "linkAvailabilityMeasurementState"), ("DVB-MGTR101290-MIB", "linkAvailabilityUnavailableTime"), ("DVB-MGTR101290-MIB", "linkAvailabilityRatio"), ("DVB-MGTR101290-MIB", "linkAvailabilityInSUTI"), ("DVB-MGTR101290-MIB", "berRSinServiceTestState"), ("DVB-MGTR101290-MIB", "berRSinServiceEnable"), ("DVB-MGTR101290-MIB", "berRSinServiceCounter"), ("DVB-MGTR101290-MIB", "berRSinServiceCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "berRSinServiceCounterReset"), ("DVB-MGTR101290-MIB", "berRSinServiceLatestError"), ("DVB-MGTR101290-MIB", "berRSinServiceActiveTime"), ("DVB-MGTR101290-MIB", "berRSinServiceMeasurementState"), ("DVB-MGTR101290-MIB", "berRSinServiceValue"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerTestState"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerEnable"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerCounter"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerCounterReset"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerLatestError"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerActiveTime"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerMeasurementState"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerValue"), ("DVB-MGTR101290-MIB", "noisePowerTestState"), ("DVB-MGTR101290-MIB", "noisePowerEnable"), ("DVB-MGTR101290-MIB", "noisePowerCounter"), ("DVB-MGTR101290-MIB", "noisePowerCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "noisePowerCounterReset"), ("DVB-MGTR101290-MIB", "noisePowerLatestError"), ("DVB-MGTR101290-MIB", "noisePowerActiveTime"), ("DVB-MGTR101290-MIB", "noisePowerMeasurementState"), ("DVB-MGTR101290-MIB", "noisePowerValue"), ("DVB-MGTR101290-MIB", "merCSTestState"), ("DVB-MGTR101290-MIB", "merCSEnable"), ("DVB-MGTR101290-MIB", "merCSCounter"), ("DVB-MGTR101290-MIB", "merCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "merCSCounterReset"), ("DVB-MGTR101290-MIB", "merCSLatestError"), ("DVB-MGTR101290-MIB", "merCSActiveTime"), ("DVB-MGTR101290-MIB", "merCSMeasurementState"), ("DVB-MGTR101290-MIB", "merCSValue"), ("DVB-MGTR101290-MIB", "steMeanCSTestState"), ("DVB-MGTR101290-MIB", "steMeanCSEnable"), ("DVB-MGTR101290-MIB", "steMeanCSCounter"), ("DVB-MGTR101290-MIB", "steMeanCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "steMeanCSCounterReset"), ("DVB-MGTR101290-MIB", "steMeanCSLatestError"), ("DVB-MGTR101290-MIB", "steMeanCSActiveTime"), ("DVB-MGTR101290-MIB", "steMeanCSMeasurementState"), ("DVB-MGTR101290-MIB", "steMeanCSValue"), ("DVB-MGTR101290-MIB", "steDeviationCSTestState"), ("DVB-MGTR101290-MIB", "steDeviationCSEnable"), ("DVB-MGTR101290-MIB", "steDeviationCSCounter"), ("DVB-MGTR101290-MIB", "steDeviationCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "steDeviationCSCounterReset"), ("DVB-MGTR101290-MIB", "steDeviationCSLatestError"), ("DVB-MGTR101290-MIB", "steDeviationCSActiveTime"), ("DVB-MGTR101290-MIB", "steDeviationCSMeasurementState"), ("DVB-MGTR101290-MIB", "steDeviationCSValue"), ("DVB-MGTR101290-MIB", "csCSTestState"), ("DVB-MGTR101290-MIB", "csCSEnable"), ("DVB-MGTR101290-MIB", "csCSCounter"), ("DVB-MGTR101290-MIB", "csCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "csCSCounterReset"), ("DVB-MGTR101290-MIB", "csCSLatestError"), ("DVB-MGTR101290-MIB", "csCSActiveTime"), ("DVB-MGTR101290-MIB", "csCSMeasurementState"), ("DVB-MGTR101290-MIB", "csCSValue"), ("DVB-MGTR101290-MIB", "aiCSTestState"), ("DVB-MGTR101290-MIB", "aiCSEnable"), ("DVB-MGTR101290-MIB", "aiCSCounter"), ("DVB-MGTR101290-MIB", "aiCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "aiCSCounterReset"), ("DVB-MGTR101290-MIB", "aiCSLatestError"), ("DVB-MGTR101290-MIB", "aiCSActiveTime"), ("DVB-MGTR101290-MIB", "aiCSMeasurementState"), ("DVB-MGTR101290-MIB", "aiCSValue"), ("DVB-MGTR101290-MIB", "qeCSTestState"), ("DVB-MGTR101290-MIB", "qeCSEnable"), ("DVB-MGTR101290-MIB", "qeCSCounter"), ("DVB-MGTR101290-MIB", "qeCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "qeCSCounterReset"), ("DVB-MGTR101290-MIB", "qeCSLatestError"), ("DVB-MGTR101290-MIB", "qeCSActiveTime"), ("DVB-MGTR101290-MIB", "qeCSMeasurementState"), ("DVB-MGTR101290-MIB", "qeCSValue"), ("DVB-MGTR101290-MIB", "rteCSTestState"), ("DVB-MGTR101290-MIB", "rteCSEnable"), ("DVB-MGTR101290-MIB", "rteCSCounter"), ("DVB-MGTR101290-MIB", "rteCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "rteCSCounterReset"), ("DVB-MGTR101290-MIB", "rteCSLatestError"), ("DVB-MGTR101290-MIB", "rteCSActiveTime"), ("DVB-MGTR101290-MIB", "rteCSMeasurementState"), ("DVB-MGTR101290-MIB", "rteCSValue"), ("DVB-MGTR101290-MIB", "ciCSTestState"), ("DVB-MGTR101290-MIB", "ciCSEnable"), ("DVB-MGTR101290-MIB", "ciCSCounter"), ("DVB-MGTR101290-MIB", "ciCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "ciCSCounterReset"), ("DVB-MGTR101290-MIB", "ciCSLatestError"), ("DVB-MGTR101290-MIB", "ciCSActiveTime"), ("DVB-MGTR101290-MIB", "ciCSMeasurementState"), ("DVB-MGTR101290-MIB", "ciCSValue"), ("DVB-MGTR101290-MIB", "pjCSTestState"), ("DVB-MGTR101290-MIB", "pjCSEnable"), ("DVB-MGTR101290-MIB", "pjCSCounter"), ("DVB-MGTR101290-MIB", "pjCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "pjCSCounterReset"), ("DVB-MGTR101290-MIB", "pjCSLatestError"), ("DVB-MGTR101290-MIB", "pjCSActiveTime"), ("DVB-MGTR101290-MIB", "pjCSMeasurementState"), ("DVB-MGTR101290-MIB", "pjCSValue"), ("DVB-MGTR101290-MIB", "snrCSTestState"), ("DVB-MGTR101290-MIB", "snrCSEnable"), ("DVB-MGTR101290-MIB", "snrCSCounter"), ("DVB-MGTR101290-MIB", "snrCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "snrCSCounterReset"), ("DVB-MGTR101290-MIB", "snrCSLatestError"), ("DVB-MGTR101290-MIB", "snrCSActiveTime"), ("DVB-MGTR101290-MIB", "snrCSMeasurementState"), ("DVB-MGTR101290-MIB", "snrCSValue"), ("DVB-MGTR101290-MIB", "cableSatPrefCentreFrequency"), ("DVB-MGTR101290-MIB", "cableSatPrefModulation"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailUATMode"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailN"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailT"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailM"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailTI"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailEBPerCent"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailTotalTime"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailUATMode"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailN"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailT"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailM"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailTI"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailUPPerCent"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailTotalTime"), ("DVB-MGTR101290-MIB", "cableSatPrefBERMax"), ("DVB-MGTR101290-MIB", "cableSatPrefSignalPowerMin"), ("DVB-MGTR101290-MIB", "cableSatPrefSignalPowerMax"), ("DVB-MGTR101290-MIB", "cableSatPrefNoisePowerMax"), ("DVB-MGTR101290-MIB", "cableSatPrefMerCSMin"), ("DVB-MGTR101290-MIB", "cableSatPrefSteMeanCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefSteDeviationCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefCsCSMin"), ("DVB-MGTR101290-MIB", "cableSatPrefAiCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefQeCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefRteCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefCiCSMin"), ("DVB-MGTR101290-MIB", "cableSatPrefPjCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefSnrCSMin"), ("DVB-MGTR101290-MIB", "noiseMarginTestState"), ("DVB-MGTR101290-MIB", "noiseMarginEnable"), ("DVB-MGTR101290-MIB", "noiseMarginCounter"), ("DVB-MGTR101290-MIB", "noiseMarginCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "noiseMarginCounterReset"), ("DVB-MGTR101290-MIB", "noiseMarginLatestError"), ("DVB-MGTR101290-MIB", "noiseMarginActiveTime"), ("DVB-MGTR101290-MIB", "noiseMarginMeasurementState"), ("DVB-MGTR101290-MIB", "noiseMarginValue"), ("DVB-MGTR101290-MIB", "estNoiseMarginTestState"), ("DVB-MGTR101290-MIB", "estNoiseMarginEnable"), ("DVB-MGTR101290-MIB", "estNoiseMarginCounter"), ("DVB-MGTR101290-MIB", "estNoiseMarginCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "estNoiseMarginCounterReset"), ("DVB-MGTR101290-MIB", "estNoiseMarginLatestError"), ("DVB-MGTR101290-MIB", "estNoiseMarginActiveTime"), ("DVB-MGTR101290-MIB", "estNoiseMarginMeasurementState"), ("DVB-MGTR101290-MIB", "estNoiseMarginValue"), ("DVB-MGTR101290-MIB", "signQualMarTTestState"), ("DVB-MGTR101290-MIB", "signQualMarTEnable"), ("DVB-MGTR101290-MIB", "signQualMarTCounter"), ("DVB-MGTR101290-MIB", "signQualMarTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "signQualMarTCounterReset"), ("DVB-MGTR101290-MIB", "signQualMarTLatestError"), ("DVB-MGTR101290-MIB", "signQualMarTActiveTime"), ("DVB-MGTR101290-MIB", "eNDCTestState"), ("DVB-MGTR101290-MIB", "eNDCEnable"), ("DVB-MGTR101290-MIB", "eNDCCounter"), ("DVB-MGTR101290-MIB", "eNDCCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "eNDCCounterReset"), ("DVB-MGTR101290-MIB", "eNDCLatestError"), ("DVB-MGTR101290-MIB", "eNDCActiveTime"), ("DVB-MGTR101290-MIB", "eNDCMeasurementState"), ("DVB-MGTR101290-MIB", "eNDCValue"), ("DVB-MGTR101290-MIB", "outBandEmissTestState"), ("DVB-MGTR101290-MIB", "outBandEmissEnable"), ("DVB-MGTR101290-MIB", "outBandEmissCounter"), ("DVB-MGTR101290-MIB", "outBandEmissCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "outBandEmissCounterReset"), ("DVB-MGTR101290-MIB", "outBandEmissLatestError"), ("DVB-MGTR101290-MIB", "outBandEmissActiveTime"), ("DVB-MGTR101290-MIB", "cablePrefNoiseMarginMin"), ("DVB-MGTR101290-MIB", "cablePrefEstNoiseMarginMin"), ("DVB-MGTR101290-MIB", "cablePrefSignQualBoxSize"), ("DVB-MGTR101290-MIB", "cablePrefSignQualPercentMax"), ("DVB-MGTR101290-MIB", "cablePrefENDBER"), ("DVB-MGTR101290-MIB", "cablePrefENDCtoNSpecified"), ("DVB-MGTR101290-MIB", "cablePrefENDIdeal"), ("DVB-MGTR101290-MIB", "cablePrefENDMax"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
groupCable = groupCable.setStatus('current')
groupSatellite = ObjectGroup((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 2, 7)).setObjects(("DVB-MGTR101290-MIB", "sysAvailabilityTestState"), ("DVB-MGTR101290-MIB", "sysAvailabilityEnable"), ("DVB-MGTR101290-MIB", "sysAvailabilityCounter"), ("DVB-MGTR101290-MIB", "sysAvailabilityCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "sysAvailabilityCounterReset"), ("DVB-MGTR101290-MIB", "sysAvailabilityLatestError"), ("DVB-MGTR101290-MIB", "sysAvailabilityActiveTime"), ("DVB-MGTR101290-MIB", "sysAvailabilityMeasurementState"), ("DVB-MGTR101290-MIB", "sysAvailabilityUnavailableTime"), ("DVB-MGTR101290-MIB", "sysAvailabilityRatio"), ("DVB-MGTR101290-MIB", "sysAvailabilityInSETI"), ("DVB-MGTR101290-MIB", "linkAvailabilityTestState"), ("DVB-MGTR101290-MIB", "linkAvailabilityEnable"), ("DVB-MGTR101290-MIB", "linkAvailabilityCounter"), ("DVB-MGTR101290-MIB", "linkAvailabilityCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "linkAvailabilityCounterReset"), ("DVB-MGTR101290-MIB", "linkAvailabilityLatestError"), ("DVB-MGTR101290-MIB", "linkAvailabilityActiveTime"), ("DVB-MGTR101290-MIB", "linkAvailabilityMeasurementState"), ("DVB-MGTR101290-MIB", "linkAvailabilityUnavailableTime"), ("DVB-MGTR101290-MIB", "linkAvailabilityRatio"), ("DVB-MGTR101290-MIB", "linkAvailabilityInSUTI"), ("DVB-MGTR101290-MIB", "berRSinServiceTestState"), ("DVB-MGTR101290-MIB", "berRSinServiceEnable"), ("DVB-MGTR101290-MIB", "berRSinServiceCounter"), ("DVB-MGTR101290-MIB", "berRSinServiceCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "berRSinServiceCounterReset"), ("DVB-MGTR101290-MIB", "berRSinServiceLatestError"), ("DVB-MGTR101290-MIB", "berRSinServiceActiveTime"), ("DVB-MGTR101290-MIB", "berRSinServiceMeasurementState"), ("DVB-MGTR101290-MIB", "berRSinServiceValue"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerTestState"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerEnable"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerCounter"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerCounterReset"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerLatestError"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerActiveTime"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerMeasurementState"), ("DVB-MGTR101290-MIB", "rfIFsignalPowerValue"), ("DVB-MGTR101290-MIB", "noisePowerTestState"), ("DVB-MGTR101290-MIB", "noisePowerEnable"), ("DVB-MGTR101290-MIB", "noisePowerCounter"), ("DVB-MGTR101290-MIB", "noisePowerCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "noisePowerCounterReset"), ("DVB-MGTR101290-MIB", "noisePowerLatestError"), ("DVB-MGTR101290-MIB", "noisePowerActiveTime"), ("DVB-MGTR101290-MIB", "noisePowerMeasurementState"), ("DVB-MGTR101290-MIB", "noisePowerValue"), ("DVB-MGTR101290-MIB", "merCSTestState"), ("DVB-MGTR101290-MIB", "merCSEnable"), ("DVB-MGTR101290-MIB", "merCSCounter"), ("DVB-MGTR101290-MIB", "merCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "merCSCounterReset"), ("DVB-MGTR101290-MIB", "merCSLatestError"), ("DVB-MGTR101290-MIB", "merCSActiveTime"), ("DVB-MGTR101290-MIB", "merCSMeasurementState"), ("DVB-MGTR101290-MIB", "merCSValue"), ("DVB-MGTR101290-MIB", "steMeanCSTestState"), ("DVB-MGTR101290-MIB", "steMeanCSEnable"), ("DVB-MGTR101290-MIB", "steMeanCSCounter"), ("DVB-MGTR101290-MIB", "steMeanCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "steMeanCSCounterReset"), ("DVB-MGTR101290-MIB", "steMeanCSLatestError"), ("DVB-MGTR101290-MIB", "steMeanCSActiveTime"), ("DVB-MGTR101290-MIB", "steMeanCSMeasurementState"), ("DVB-MGTR101290-MIB", "steMeanCSValue"), ("DVB-MGTR101290-MIB", "steDeviationCSTestState"), ("DVB-MGTR101290-MIB", "steDeviationCSEnable"), ("DVB-MGTR101290-MIB", "steDeviationCSCounter"), ("DVB-MGTR101290-MIB", "steDeviationCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "steDeviationCSCounterReset"), ("DVB-MGTR101290-MIB", "steDeviationCSLatestError"), ("DVB-MGTR101290-MIB", "steDeviationCSActiveTime"), ("DVB-MGTR101290-MIB", "steDeviationCSMeasurementState"), ("DVB-MGTR101290-MIB", "steDeviationCSValue"), ("DVB-MGTR101290-MIB", "csCSTestState"), ("DVB-MGTR101290-MIB", "csCSEnable"), ("DVB-MGTR101290-MIB", "csCSCounter"), ("DVB-MGTR101290-MIB", "csCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "csCSCounterReset"), ("DVB-MGTR101290-MIB", "csCSLatestError"), ("DVB-MGTR101290-MIB", "csCSActiveTime"), ("DVB-MGTR101290-MIB", "csCSMeasurementState"), ("DVB-MGTR101290-MIB", "csCSValue"), ("DVB-MGTR101290-MIB", "aiCSTestState"), ("DVB-MGTR101290-MIB", "aiCSEnable"), ("DVB-MGTR101290-MIB", "aiCSCounter"), ("DVB-MGTR101290-MIB", "aiCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "aiCSCounterReset"), ("DVB-MGTR101290-MIB", "aiCSLatestError"), ("DVB-MGTR101290-MIB", "aiCSActiveTime"), ("DVB-MGTR101290-MIB", "aiCSMeasurementState"), ("DVB-MGTR101290-MIB", "aiCSValue"), ("DVB-MGTR101290-MIB", "qeCSTestState"), ("DVB-MGTR101290-MIB", "qeCSEnable"), ("DVB-MGTR101290-MIB", "qeCSCounter"), ("DVB-MGTR101290-MIB", "qeCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "qeCSCounterReset"), ("DVB-MGTR101290-MIB", "qeCSLatestError"), ("DVB-MGTR101290-MIB", "qeCSActiveTime"), ("DVB-MGTR101290-MIB", "qeCSMeasurementState"), ("DVB-MGTR101290-MIB", "qeCSValue"), ("DVB-MGTR101290-MIB", "rteCSTestState"), ("DVB-MGTR101290-MIB", "rteCSEnable"), ("DVB-MGTR101290-MIB", "rteCSCounter"), ("DVB-MGTR101290-MIB", "rteCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "rteCSCounterReset"), ("DVB-MGTR101290-MIB", "rteCSLatestError"), ("DVB-MGTR101290-MIB", "rteCSActiveTime"), ("DVB-MGTR101290-MIB", "rteCSMeasurementState"), ("DVB-MGTR101290-MIB", "rteCSValue"), ("DVB-MGTR101290-MIB", "ciCSTestState"), ("DVB-MGTR101290-MIB", "ciCSEnable"), ("DVB-MGTR101290-MIB", "ciCSCounter"), ("DVB-MGTR101290-MIB", "ciCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "ciCSCounterReset"), ("DVB-MGTR101290-MIB", "ciCSLatestError"), ("DVB-MGTR101290-MIB", "ciCSActiveTime"), ("DVB-MGTR101290-MIB", "ciCSMeasurementState"), ("DVB-MGTR101290-MIB", "ciCSValue"), ("DVB-MGTR101290-MIB", "pjCSTestState"), ("DVB-MGTR101290-MIB", "pjCSEnable"), ("DVB-MGTR101290-MIB", "pjCSCounter"), ("DVB-MGTR101290-MIB", "pjCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "pjCSCounterReset"), ("DVB-MGTR101290-MIB", "pjCSLatestError"), ("DVB-MGTR101290-MIB", "pjCSActiveTime"), ("DVB-MGTR101290-MIB", "pjCSMeasurementState"), ("DVB-MGTR101290-MIB", "pjCSValue"), ("DVB-MGTR101290-MIB", "snrCSTestState"), ("DVB-MGTR101290-MIB", "snrCSEnable"), ("DVB-MGTR101290-MIB", "snrCSCounter"), ("DVB-MGTR101290-MIB", "snrCSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "snrCSCounterReset"), ("DVB-MGTR101290-MIB", "snrCSLatestError"), ("DVB-MGTR101290-MIB", "snrCSActiveTime"), ("DVB-MGTR101290-MIB", "snrCSMeasurementState"), ("DVB-MGTR101290-MIB", "snrCSValue"), ("DVB-MGTR101290-MIB", "cableSatPrefCentreFrequency"), ("DVB-MGTR101290-MIB", "cableSatPrefModulation"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailUATMode"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailN"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailT"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailM"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailTI"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailEBPerCent"), ("DVB-MGTR101290-MIB", "cableSatPrefSysAvailTotalTime"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailUATMode"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailN"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailT"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailM"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailTI"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailUPPerCent"), ("DVB-MGTR101290-MIB", "cableSatPrefLinkAvailTotalTime"), ("DVB-MGTR101290-MIB", "cableSatPrefBERMax"), ("DVB-MGTR101290-MIB", "cableSatPrefSignalPowerMin"), ("DVB-MGTR101290-MIB", "cableSatPrefSignalPowerMax"), ("DVB-MGTR101290-MIB", "cableSatPrefNoisePowerMax"), ("DVB-MGTR101290-MIB", "cableSatPrefMerCSMin"), ("DVB-MGTR101290-MIB", "cableSatPrefSteMeanCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefSteDeviationCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefCsCSMin"), ("DVB-MGTR101290-MIB", "cableSatPrefAiCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefQeCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefRteCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefCiCSMin"), ("DVB-MGTR101290-MIB", "cableSatPrefPjCSMax"), ("DVB-MGTR101290-MIB", "cableSatPrefSnrCSMin"), ("DVB-MGTR101290-MIB", "berViterbiSTestState"), ("DVB-MGTR101290-MIB", "berViterbiSEnable"), ("DVB-MGTR101290-MIB", "berViterbiSCounter"), ("DVB-MGTR101290-MIB", "berViterbiSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "berViterbiSCounterReset"), ("DVB-MGTR101290-MIB", "berViterbiSLatestError"), ("DVB-MGTR101290-MIB", "berViterbiSActiveTime"), ("DVB-MGTR101290-MIB", "berViterbiSMeasurementState"), ("DVB-MGTR101290-MIB", "berViterbiSIValue"), ("DVB-MGTR101290-MIB", "berViterbiSQValue"), ("DVB-MGTR101290-MIB", "berViterbiSMeasurementMethod"), ("DVB-MGTR101290-MIB", "ifSpectrumTestState"), ("DVB-MGTR101290-MIB", "ifSpectrumEnable"), ("DVB-MGTR101290-MIB", "ifSpectrumCounter"), ("DVB-MGTR101290-MIB", "ifSpectrumCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "ifSpectrumCounterReset"), ("DVB-MGTR101290-MIB", "ifSpectrumLatestError"), ("DVB-MGTR101290-MIB", "ifSpectrumActiveTime"), ("DVB-MGTR101290-MIB", "satellitePrefBERMax"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
groupSatellite = groupSatellite.setStatus('current')
groupTerrestrial = ObjectGroup((1, 3, 6, 1, 4, 1, 2696, 3, 2, 3, 2, 8)).setObjects(("DVB-MGTR101290-MIB", "rfAccuracyTestState"), ("DVB-MGTR101290-MIB", "rfAccuracyEnable"), ("DVB-MGTR101290-MIB", "rfAccuracyCounter"), ("DVB-MGTR101290-MIB", "rfAccuracyCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "rfAccuracyCounterReset"), ("DVB-MGTR101290-MIB", "rfAccuracyLatestError"), ("DVB-MGTR101290-MIB", "rfAccuracyActiveTime"), ("DVB-MGTR101290-MIB", "rfAccuracyMeasurementState"), ("DVB-MGTR101290-MIB", "rfAccuracyValue"), ("DVB-MGTR101290-MIB", "rfChannelWidthTestState"), ("DVB-MGTR101290-MIB", "rfChannelWidthEnable"), ("DVB-MGTR101290-MIB", "rfChannelWidthCounter"), ("DVB-MGTR101290-MIB", "rfChannelWidthCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "rfChannelWidthCounterReset"), ("DVB-MGTR101290-MIB", "rfChannelWidthLatestError"), ("DVB-MGTR101290-MIB", "rfChannelWidthActiveTime"), ("DVB-MGTR101290-MIB", "rfChannelWidthMeasurementState"), ("DVB-MGTR101290-MIB", "rfChannelWidthValue"), ("DVB-MGTR101290-MIB", "symbolLengthTestState"), ("DVB-MGTR101290-MIB", "symbolLengthEnable"), ("DVB-MGTR101290-MIB", "symbolLengthCounter"), ("DVB-MGTR101290-MIB", "symbolLengthCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "symbolLengthCounterReset"), ("DVB-MGTR101290-MIB", "symbolLengthLatestError"), ("DVB-MGTR101290-MIB", "symbolLengthActiveTime"), ("DVB-MGTR101290-MIB", "symbolLengthMeasurementState"), ("DVB-MGTR101290-MIB", "symbolLengthValue"), ("DVB-MGTR101290-MIB", "rfIfPowerTestState"), ("DVB-MGTR101290-MIB", "rfIfPowerEnable"), ("DVB-MGTR101290-MIB", "rfIfPowerCounter"), ("DVB-MGTR101290-MIB", "rfIfPowerCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "rfIfPowerCounterReset"), ("DVB-MGTR101290-MIB", "rfIfPowerLatestError"), ("DVB-MGTR101290-MIB", "rfIfPowerActiveTime"), ("DVB-MGTR101290-MIB", "rfIfPowerMeasurementState"), ("DVB-MGTR101290-MIB", "rfIfPowerValue"), ("DVB-MGTR101290-MIB", "rfIfSpectrumTestState"), ("DVB-MGTR101290-MIB", "rfIfSpectrumEnable"), ("DVB-MGTR101290-MIB", "rfIfSpectrumCounter"), ("DVB-MGTR101290-MIB", "rfIfSpectrumCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "rfIfSpectrumCounterReset"), ("DVB-MGTR101290-MIB", "rfIfSpectrumLatestError"), ("DVB-MGTR101290-MIB", "rfIfSpectrumActiveTime"), ("DVB-MGTR101290-MIB", "eNDTTestState"), ("DVB-MGTR101290-MIB", "eNDTEnable"), ("DVB-MGTR101290-MIB", "eNDTCounter"), ("DVB-MGTR101290-MIB", "eNDTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "eNDTCounterReset"), ("DVB-MGTR101290-MIB", "eNDTLatestError"), ("DVB-MGTR101290-MIB", "eNDTActiveTime"), ("DVB-MGTR101290-MIB", "eNDTMeasurementState"), ("DVB-MGTR101290-MIB", "eNDTValue"), ("DVB-MGTR101290-MIB", "eNFTTestState"), ("DVB-MGTR101290-MIB", "eNFTEnable"), ("DVB-MGTR101290-MIB", "eNFTCounter"), ("DVB-MGTR101290-MIB", "eNFTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "eNFTCounterReset"), ("DVB-MGTR101290-MIB", "eNFTLatestError"), ("DVB-MGTR101290-MIB", "eNFTActiveTime"), ("DVB-MGTR101290-MIB", "eNFTMeasurementState"), ("DVB-MGTR101290-MIB", "eNFTValue"), ("DVB-MGTR101290-MIB", "eNDTLPTestState"), ("DVB-MGTR101290-MIB", "eNDTLPEnable"), ("DVB-MGTR101290-MIB", "eNDTLPCounter"), ("DVB-MGTR101290-MIB", "eNDTLPCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "eNDTLPCounterReset"), ("DVB-MGTR101290-MIB", "eNDTLPLatestError"), ("DVB-MGTR101290-MIB", "eNDTLPActiveTime"), ("DVB-MGTR101290-MIB", "eNDTLPMeasurementState"), ("DVB-MGTR101290-MIB", "eNDTLPValue"), ("DVB-MGTR101290-MIB", "eNFTLPTestState"), ("DVB-MGTR101290-MIB", "eNFTLPEnable"), ("DVB-MGTR101290-MIB", "eNFTLPCounter"), ("DVB-MGTR101290-MIB", "eNFTLPCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "eNFTLPCounterReset"), ("DVB-MGTR101290-MIB", "eNFTLPLatestError"), ("DVB-MGTR101290-MIB", "eNFTLPActiveTime"), ("DVB-MGTR101290-MIB", "eNFTLPMeasurementState"), ("DVB-MGTR101290-MIB", "eNFTLPValue"), ("DVB-MGTR101290-MIB", "linearityTestState"), ("DVB-MGTR101290-MIB", "linearityEnable"), ("DVB-MGTR101290-MIB", "linearityCounter"), ("DVB-MGTR101290-MIB", "linearityCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "linearityCounterReset"), ("DVB-MGTR101290-MIB", "linearityLatestError"), ("DVB-MGTR101290-MIB", "linearityActiveTime"), ("DVB-MGTR101290-MIB", "linearityMeasurementState"), ("DVB-MGTR101290-MIB", "linearityValue"), ("DVB-MGTR101290-MIB", "berViterbiTTestState"), ("DVB-MGTR101290-MIB", "berViterbiTEnable"), ("DVB-MGTR101290-MIB", "berViterbiTCounter"), ("DVB-MGTR101290-MIB", "berViterbiTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "berViterbiTCounterReset"), ("DVB-MGTR101290-MIB", "berViterbiTLatestError"), ("DVB-MGTR101290-MIB", "berViterbiTActiveTime"), ("DVB-MGTR101290-MIB", "berViterbiTMeasurementState"), ("DVB-MGTR101290-MIB", "berViterbiTValue"), ("DVB-MGTR101290-MIB", "berViterbiTLPTestState"), ("DVB-MGTR101290-MIB", "berViterbiTLPEnable"), ("DVB-MGTR101290-MIB", "berViterbiTLPCounter"), ("DVB-MGTR101290-MIB", "berViterbiTLPCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "berViterbiTLPCounterReset"), ("DVB-MGTR101290-MIB", "berViterbiTLPLatestError"), ("DVB-MGTR101290-MIB", "berViterbiTLPActiveTime"), ("DVB-MGTR101290-MIB", "berViterbiTLPMeasurementState"), ("DVB-MGTR101290-MIB", "berViterbiTLPValue"), ("DVB-MGTR101290-MIB", "berRSTestState"), ("DVB-MGTR101290-MIB", "berRSEnable"), ("DVB-MGTR101290-MIB", "berRSCounter"), ("DVB-MGTR101290-MIB", "berRSCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "berRSCounterReset"), ("DVB-MGTR101290-MIB", "berRSLatestError"), ("DVB-MGTR101290-MIB", "berRSActiveTime"), ("DVB-MGTR101290-MIB", "berRSMeasurementState"), ("DVB-MGTR101290-MIB", "berRSValue"), ("DVB-MGTR101290-MIB", "berRSLPTestState"), ("DVB-MGTR101290-MIB", "berRSLPEnable"), ("DVB-MGTR101290-MIB", "berRSLPCounter"), ("DVB-MGTR101290-MIB", "berRSLPCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "berRSLPCounterReset"), ("DVB-MGTR101290-MIB", "berRSLPLatestError"), ("DVB-MGTR101290-MIB", "berRSLPActiveTime"), ("DVB-MGTR101290-MIB", "berRSLPMeasurementState"), ("DVB-MGTR101290-MIB", "berRSLPValue"), ("DVB-MGTR101290-MIB", "merTTestState"), ("DVB-MGTR101290-MIB", "merTEnable"), ("DVB-MGTR101290-MIB", "merTCounter"), ("DVB-MGTR101290-MIB", "merTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "merTCounterReset"), ("DVB-MGTR101290-MIB", "merTLatestError"), ("DVB-MGTR101290-MIB", "merTActiveTime"), ("DVB-MGTR101290-MIB", "merTMeasurementState"), ("DVB-MGTR101290-MIB", "merTValue"), ("DVB-MGTR101290-MIB", "steMeanTTestState"), ("DVB-MGTR101290-MIB", "steMeanTEnable"), ("DVB-MGTR101290-MIB", "steMeanTCounter"), ("DVB-MGTR101290-MIB", "steMeanTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "steMeanTCounterReset"), ("DVB-MGTR101290-MIB", "steMeanTLatestError"), ("DVB-MGTR101290-MIB", "steMeanTActiveTime"), ("DVB-MGTR101290-MIB", "steMeanTMeasurementState"), ("DVB-MGTR101290-MIB", "steMeanTValue"), ("DVB-MGTR101290-MIB", "steDeviationTTestState"), ("DVB-MGTR101290-MIB", "steDeviationTEnable"), ("DVB-MGTR101290-MIB", "steDeviationTCounter"), ("DVB-MGTR101290-MIB", "steDeviationTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "steDeviationTCounterReset"), ("DVB-MGTR101290-MIB", "steDeviationTLatestError"), ("DVB-MGTR101290-MIB", "steDeviationTActiveTime"), ("DVB-MGTR101290-MIB", "steDeviationTMeasurementState"), ("DVB-MGTR101290-MIB", "steDeviationTValue"), ("DVB-MGTR101290-MIB", "csTTestState"), ("DVB-MGTR101290-MIB", "csTEnable"), ("DVB-MGTR101290-MIB", "csTCounter"), ("DVB-MGTR101290-MIB", "csTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "csTCounterReset"), ("DVB-MGTR101290-MIB", "csTLatestError"), ("DVB-MGTR101290-MIB", "csTActiveTime"), ("DVB-MGTR101290-MIB", "csTMeasurementState"), ("DVB-MGTR101290-MIB", "csTValue"), ("DVB-MGTR101290-MIB", "aiTTestState"), ("DVB-MGTR101290-MIB", "aiTEnable"), ("DVB-MGTR101290-MIB", "aiTCounter"), ("DVB-MGTR101290-MIB", "aiTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "aiTCounterReset"), ("DVB-MGTR101290-MIB", "aiTLatestError"), ("DVB-MGTR101290-MIB", "aiTActiveTime"), ("DVB-MGTR101290-MIB", "aiTMeasurementState"), ("DVB-MGTR101290-MIB", "aiTValue"), ("DVB-MGTR101290-MIB", "qeTTestState"), ("DVB-MGTR101290-MIB", "qeTEnable"), ("DVB-MGTR101290-MIB", "qeTCounter"), ("DVB-MGTR101290-MIB", "qeTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "qeTCounterReset"), ("DVB-MGTR101290-MIB", "qeTLatestError"), ("DVB-MGTR101290-MIB", "qeTActiveTime"), ("DVB-MGTR101290-MIB", "qeTMeasurementState"), ("DVB-MGTR101290-MIB", "qeTValue"), ("DVB-MGTR101290-MIB", "pjTTestState"), ("DVB-MGTR101290-MIB", "pjTEnable"), ("DVB-MGTR101290-MIB", "pjTCounter"), ("DVB-MGTR101290-MIB", "pjTCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "pjTCounterReset"), ("DVB-MGTR101290-MIB", "pjTLatestError"), ("DVB-MGTR101290-MIB", "pjTActiveTime"), ("DVB-MGTR101290-MIB", "pjTMeasurementState"), ("DVB-MGTR101290-MIB", "pjTValue"), ("DVB-MGTR101290-MIB", "mipSyntaxState"), ("DVB-MGTR101290-MIB", "mipSyntaxEnable"), ("DVB-MGTR101290-MIB", "mipSyntaxCounter"), ("DVB-MGTR101290-MIB", "mipSyntaxCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "mipSyntaxCounterReset"), ("DVB-MGTR101290-MIB", "mipSyntaxLatestError"), ("DVB-MGTR101290-MIB", "mipSyntaxActiveTime"), ("DVB-MGTR101290-MIB", "sepEtiTestState"), ("DVB-MGTR101290-MIB", "sepEtiEnable"), ("DVB-MGTR101290-MIB", "sepEtiCounter"), ("DVB-MGTR101290-MIB", "sepEtiCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "sepEtiCounterReset"), ("DVB-MGTR101290-MIB", "sepEtiLatestError"), ("DVB-MGTR101290-MIB", "sepEtiActiveTime"), ("DVB-MGTR101290-MIB", "sepEtiMeasurementState"), ("DVB-MGTR101290-MIB", "sepEtiValue"), ("DVB-MGTR101290-MIB", "sepSetiTestState"), ("DVB-MGTR101290-MIB", "sepSetiEnable"), ("DVB-MGTR101290-MIB", "sepSetiCounter"), ("DVB-MGTR101290-MIB", "sepSetiCounterDiscontinuity"), ("DVB-MGTR101290-MIB", "sepSetiCounterReset"), ("DVB-MGTR101290-MIB", "sepSetiLatestError"), ("DVB-MGTR101290-MIB", "sepSetiActiveTime"), ("DVB-MGTR101290-MIB", "sepSetiMeasurementState"), ("DVB-MGTR101290-MIB", "sepSetiValue"), ("DVB-MGTR101290-MIB", "terrestrialPrefCentreFrequency"), ("DVB-MGTR101290-MIB", "terrestrialPrefBandwidth"), ("DVB-MGTR101290-MIB", "terrestrialPrefModulation"), ("DVB-MGTR101290-MIB", "terrestrialPrefTransmissionMode"), ("DVB-MGTR101290-MIB", "terrestrialPrefGuardInterval"), ("DVB-MGTR101290-MIB", "terrestrialPrefHierarchical"), ("DVB-MGTR101290-MIB", "terrestrialPrefCentreFreqExpected"), ("DVB-MGTR101290-MIB", "terrestrialPrefCentreFreqLimit"), ("DVB-MGTR101290-MIB", "terrestrialPrefChannelWidthLimit"), ("DVB-MGTR101290-MIB", "terrestrialPrefSymbolLengthLimit"), ("DVB-MGTR101290-MIB", "terrestrialPrefPowerMin"), ("DVB-MGTR101290-MIB", "terrestrialPrefPowerMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefENDBER"), ("DVB-MGTR101290-MIB", "terrestrialPrefENDIdeal"), ("DVB-MGTR101290-MIB", "terrestrialPrefENDMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefENFIdeal"), ("DVB-MGTR101290-MIB", "terrestrialPrefENFMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefENDLPIdeal"), ("DVB-MGTR101290-MIB", "terrestrialPrefENDLPMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefENFLPIdeal"), ("DVB-MGTR101290-MIB", "terrestrialPrefENFLPMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefLinearityMin"), ("DVB-MGTR101290-MIB", "terrestrialPrefBERViterbiMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefBERViterbiLPMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefBERRSMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefBERRSLPMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefMerTMin"), ("DVB-MGTR101290-MIB", "terrestrialPrefSteMeanMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefSteDeviationMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefCsMin"), ("DVB-MGTR101290-MIB", "terrestrialPrefAiMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefQeMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefPjMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefMIPTimingLimit"), ("DVB-MGTR101290-MIB", "terrestrialPrefMIPDeviationMax"), ("DVB-MGTR101290-MIB", "terrestrialPrefSEPUATMode"), ("DVB-MGTR101290-MIB", "terrestrialPrefSEPN"), ("DVB-MGTR101290-MIB", "terrestrialPrefSEPT"), ("DVB-MGTR101290-MIB", "terrestrialPrefSEPM"), ("DVB-MGTR101290-MIB", "terrestrialPrefSEPTI"), ("DVB-MGTR101290-MIB", "terrestrialPrefSEPEBPerCent"), ("DVB-MGTR101290-MIB", "terrestrialPrefSEPMeasurementInterval"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
groupTerrestrial = groupTerrestrial.setStatus('current')
mibBuilder.exportSymbols("DVB-MGTR101290-MIB", steDeviationTEntry=steDeviationTEntry, capabilityTSAvailability=capabilityTSAvailability, outBandEmissCounter=outBandEmissCounter, csTTable=csTTable, berRSInputNumber=berRSInputNumber, pjTCounter=pjTCounter, iqAnalysisCS=iqAnalysisCS, outBandEmissTestState=outBandEmissTestState, merTCounterReset=merTCounterReset, qeTActiveTime=qeTActiveTime, eNDCEntry=eNDCEntry, sepSetiMeasurementState=sepSetiMeasurementState, tsTestsSummaryEntry=tsTestsSummaryEntry, eNFTLPMeasurementState=eNFTLPMeasurementState, mipSyntaxTable=mipSyntaxTable, linearityEntry=linearityEntry, controlSynchronizationInputNumber=controlSynchronizationInputNumber, cableSatPrefQeCSMax=cableSatPrefQeCSMax, tsConsistencyActiveTime=tsConsistencyActiveTime, berViterbiTLPMeasurementState=berViterbiTLPMeasurementState, terrestrialPrefGuardInterval=terrestrialPrefGuardInterval, symbolLengthMeasurementState=symbolLengthMeasurementState, berRSLPActiveTime=berRSLPActiveTime, tsServicePerformanceTable=tsServicePerformanceTable, tsServiceBitRateNomenclature=tsServiceBitRateNomenclature, tsMeasurePrefServiceBitRateElement=tsMeasurePrefServiceBitRateElement, cableSatPrefCsCSMin=cableSatPrefCsCSMin, tsServicePerformanceCounter=tsServicePerformanceCounter, trapPrefix=trapPrefix, Modulation=Modulation, tsPcrMeasurementNumber=tsPcrMeasurementNumber, steDeviationTLatestError=steDeviationTLatestError, rteCSCounterReset=rteCSCounterReset, eNFTCounter=eNFTCounter, capabilityTS=capabilityTS, tsTransportStreamBitRateEntry=tsTransportStreamBitRateEntry, tsTestsPrefSDTOtherIntervalMax=tsTestsPrefSDTOtherIntervalMax, rfSystemInputNumber=rfSystemInputNumber, csCSCounter=csCSCounter, tsSPPrefThreshold=tsSPPrefThreshold, berViterbiTValue=berViterbiTValue, sysAvailabilityTestState=sysAvailabilityTestState, csCSMeasurementState=csCSMeasurementState, tsTestsPrefNITActualIntervalMin=tsTestsPrefNITActualIntervalMin, signQualMarTActiveTime=signQualMarTActiveTime, pjTTable=pjTTable, tsPcrMeasurementMeasurementState=tsPcrMeasurementMeasurementState, sepEtiValue=sepEtiValue, tsServicePerformanceNumber=tsServicePerformanceNumber, capabilityCablePollInterval=capabilityCablePollInterval, linkAvailabilityCounter=linkAvailabilityCounter, tsPcrMeasurementTable=tsPcrMeasurementTable, tsPIDBitRateState=tsPIDBitRateState, eNDTCounterReset=eNDTCounterReset, merTMeasurementState=merTMeasurementState, pjTEnable=pjTEnable, aiTMeasurementState=aiTMeasurementState, capabilitySatelliteGroup=capabilitySatelliteGroup, tsTestsPrefPIDRowStatus=tsTestsPrefPIDRowStatus, tsPIDBitRateTable=tsPIDBitRateTable, PYSNMP_MODULE_ID=tr101290, linkAvailabilityCounterDiscontinuity=linkAvailabilityCounterDiscontinuity, steMeanCSValue=steMeanCSValue, trapControlTable=trapControlTable, snrCSValue=snrCSValue, pjTInputNumber=pjTInputNumber, pjTTestState=pjTTestState, tsMeasurePrefInputNumber=tsMeasurePrefInputNumber, tsTestsPIDActiveTime=tsTestsPIDActiveTime, estNoiseMarginValue=estNoiseMarginValue, BERMeasurementMethod=BERMeasurementMethod, berViterbiSTable=berViterbiSTable, sepEtiCounterDiscontinuity=sepEtiCounterDiscontinuity, symbolLengthActiveTime=symbolLengthActiveTime, eNDCValue=eNDCValue, ciCSEnable=ciCSEnable, merCSCounter=merCSCounter, rteCSInputNumber=rteCSInputNumber, steDeviationCSCounterReset=steDeviationCSCounterReset, eNFTLPTable=eNFTLPTable, tsTestsPrefSDTActualIntervalMax=tsTestsPrefSDTActualIntervalMax, tsPIDBitRatePID=tsPIDBitRatePID, tsPcrMeasurementPID=tsPcrMeasurementPID, eNDTLPEnable=eNDTLPEnable, capabilitySatellitePollInterval=capabilitySatellitePollInterval, rfAccuracyCounter=rfAccuracyCounter, linkAvailabilityTestState=linkAvailabilityTestState, aiCSTestState=aiCSTestState, tsTestsPrefNITOtherIntervalMax=tsTestsPrefNITOtherIntervalMax, IndexPCRMeasurement=IndexPCRMeasurement, berViterbiSMeasurementState=berViterbiSMeasurementState, Enable=Enable, noiseMarginCounterReset=noiseMarginCounterReset, steDeviationTValue=steDeviationTValue, rfTerr=rfTerr, eNFTLPLatestError=eNFTLPLatestError, sysAvailabilityInputNumber=sysAvailabilityInputNumber, trapControlInputNumber=trapControlInputNumber, signQualMarTLatestError=signQualMarTLatestError, mg=mg, steDeviationCSActiveTime=steDeviationCSActiveTime, trapControlGenerationTime=trapControlGenerationTime, noiseMarginEnable=noiseMarginEnable, eNDTLPMeasurementState=eNDTLPMeasurementState, steMeanTCounter=steMeanTCounter, estNoiseMarginInputNumber=estNoiseMarginInputNumber, terrestrialPreferencesTable=terrestrialPreferencesTable, tsServicePerformancePreferencesTable=tsServicePerformancePreferencesTable, satellitePrefBERMax=satellitePrefBERMax, tsConsistencyEntry=tsConsistencyEntry, tsMeasurePrefPIDBitRateElement=tsMeasurePrefPIDBitRateElement, tsServicePerformanceLatestError=tsServicePerformanceLatestError, berRSinServiceValue=berRSinServiceValue, noiseMarginInputNumber=noiseMarginInputNumber, rfIfSpectrumEnable=rfIfSpectrumEnable, ActiveTime=ActiveTime, steDeviationTTestState=steDeviationTTestState, terrestrialPrefPowerMin=terrestrialPrefPowerMin, merTEnable=merTEnable, tsTransportStreamBitRateMeasurementState=tsTransportStreamBitRateMeasurementState, berViterbiSMeasurementMethod=berViterbiSMeasurementMethod, cableSatPrefCentreFrequency=cableSatPrefCentreFrequency, eNDCCounterDiscontinuity=eNDCCounterDiscontinuity, tsTestsPIDTestNumber=tsTestsPIDTestNumber, berRSValue=berRSValue, aiTInputNumber=aiTInputNumber, tsServiceBitRateLatestError=tsServiceBitRateLatestError, eNDCTestState=eNDCTestState, tsServicePerformanceError=tsServicePerformanceError, csCSEnable=csCSEnable, linearityValue=linearityValue, noiseMarginTable=noiseMarginTable, merCSTestState=merCSTestState, capabilityCableEntry=capabilityCableEntry, steDeviationTActiveTime=steDeviationTActiveTime, signQualMarTCounterDiscontinuity=signQualMarTCounterDiscontinuity, eNDCEnable=eNDCEnable, tsServiceBitRateService=tsServiceBitRateService, pjCSCounterReset=pjCSCounterReset, tsTransportStreamBitRateCounterReset=tsTransportStreamBitRateCounterReset, tsServicePerformanceEntry=tsServicePerformanceEntry, rfIfPowerTable=rfIfPowerTable, rfIfPowerCounter=rfIfPowerCounter, capabilityTSGroup=capabilityTSGroup, rfIFsignalPowerEntry=rfIFsignalPowerEntry, csCSLatestError=csCSLatestError, estNoiseMarginTestState=estNoiseMarginTestState, rfIfSpectrumCounterDiscontinuity=rfIfSpectrumCounterDiscontinuity, tsMeasurePreferencesEntry=tsMeasurePreferencesEntry, merTEntry=merTEntry, linearityTable=linearityTable, tsMeasurePrefPIDBitRateTau=tsMeasurePrefPIDBitRateTau, aiCSMeasurementState=aiCSMeasurementState, berRSTestState=berRSTestState, noisePowerLatestError=noisePowerLatestError, aiTLatestError=aiTLatestError, terrestrialPrefMerTMin=terrestrialPrefMerTMin, linkAvailabilityMeasurementState=linkAvailabilityMeasurementState, rfIFsignalPowerLatestError=rfIFsignalPowerLatestError, berViterbiTLPCounterDiscontinuity=berViterbiTLPCounterDiscontinuity, berRSinServiceMeasurementState=berRSinServiceMeasurementState, tsMeasurePrefServiceRowStatus=tsMeasurePrefServiceRowStatus, symbolLengthCounter=symbolLengthCounter, linkAvailabilityTable=linkAvailabilityTable, ifSpectrumTestState=ifSpectrumTestState, berViterbiTLPActiveTime=berViterbiTLPActiveTime, mipSyntaxCounter=mipSyntaxCounter, tsPIDBitRateLatestError=tsPIDBitRateLatestError, ciCSMeasurementState=ciCSMeasurementState, rfAccuracyTable=rfAccuracyTable, capabilityCableSatOID=capabilityCableSatOID, sepSetiLatestError=sepSetiLatestError, rfChannelWidthInputNumber=rfChannelWidthInputNumber, rfIfPowerTestState=rfIfPowerTestState, signQualMarTEnable=signQualMarTEnable, tsTestsPrefNITTableIntervalMax=tsTestsPrefNITTableIntervalMax, capabilityTSEntry=capabilityTSEntry, pjCSCounter=pjCSCounter, tsMeasurePrefAllServiceBitRateElement=tsMeasurePrefAllServiceBitRateElement, sysAvailabilityCounterDiscontinuity=sysAvailabilityCounterDiscontinuity, cableSatPrefSnrCSMin=cableSatPrefSnrCSMin, cablePrefENDBER=cablePrefENDBER, tr101290Objects=tr101290Objects, tsTestsPrefEITSActualNearTableIntervalMax=tsTestsPrefEITSActualNearTableIntervalMax, controlSynchronizationTable=controlSynchronizationTable, tsPcrMeasurementCounterDiscontinuity=tsPcrMeasurementCounterDiscontinuity, linkAvailabilityEntry=linkAvailabilityEntry, steMeanTInputNumber=steMeanTInputNumber, cableSatPrefSysAvailT=cableSatPrefSysAvailT, eNFTLPEnable=eNFTLPEnable, estNoiseMarginCounterReset=estNoiseMarginCounterReset, tsPIDBitRateCounterReset=tsPIDBitRateCounterReset, steMeanTTestState=steMeanTTestState, symbolLengthCounterReset=symbolLengthCounterReset, mipSyntaxTestNumber=mipSyntaxTestNumber, tsPcrMeasurementState=tsPcrMeasurementState, tsMeasurePreferencesServiceEntry=tsMeasurePreferencesServiceEntry, qeCSLatestError=qeCSLatestError, tr101290Compliances=tr101290Compliances, cableSatPreferencesEntry=cableSatPreferencesEntry, pjTLatestError=pjTLatestError, tsTestsSummaryActiveTime=tsTestsSummaryActiveTime, linearityInputNumber=linearityInputNumber, terrestrialPrefSymbolLengthLimit=terrestrialPrefSymbolLengthLimit, rfAccuracyEnable=rfAccuracyEnable, tsConsistencyLatestError=tsConsistencyLatestError, berRSinServiceCounterDiscontinuity=berRSinServiceCounterDiscontinuity, tsTestsPrefPATSectionIntervalMax=tsTestsPrefPATSectionIntervalMax, cableSatPrefLinkAvailUATMode=cableSatPrefLinkAvailUATMode, tsPcrMeasurementValue=tsPcrMeasurementValue, symbolLengthEntry=symbolLengthEntry, berViterbiTCounter=berViterbiTCounter, tsServiceBitRateCounterDiscontinuity=tsServiceBitRateCounterDiscontinuity, tsPIDBitRateMeasurementState=tsPIDBitRateMeasurementState, TestSummary=TestSummary, rfIfPowerMeasurementState=rfIfPowerMeasurementState, berRSMeasurementState=berRSMeasurementState, noisePowerCounter=noisePowerCounter, tsTestsPreferencesPIDTable=tsTestsPreferencesPIDTable, mipSyntaxCounterDiscontinuity=mipSyntaxCounterDiscontinuity, tsTestsPrefPTSIntervalMax=tsTestsPrefPTSIntervalMax, cableSatPrefAiCSMax=cableSatPrefAiCSMax, sepEtiEntry=sepEtiEntry, tsTestsPrefEITSActualFarTableIntervalMax=tsTestsPrefEITSActualFarTableIntervalMax, steDeviationCSLatestError=steDeviationCSLatestError, noiseMarginMeasurementState=noiseMarginMeasurementState, rfIfSpectrumCounterReset=rfIfSpectrumCounterReset, capabilityTSOID=capabilityTSOID, tsMeasurePrefPIDRowStatus=tsMeasurePrefPIDRowStatus, tr101290CableSat=tr101290CableSat, noisePowerCounterDiscontinuity=noisePowerCounterDiscontinuity, berRSLPLatestError=berRSLPLatestError, berRSEnable=berRSEnable, tsMeasurePrefTSBitRateMax=tsMeasurePrefTSBitRateMax, sepSetiInputNumber=sepSetiInputNumber, csCSInputNumber=csCSInputNumber, capabilityTerrestrialAvailability=capabilityTerrestrialAvailability, cableSatPrefLinkAvailTotalTime=cableSatPrefLinkAvailTotalTime, sepEtiCounter=sepEtiCounter, tsTestsPIDPID=tsTestsPIDPID, tsMeasurePrefServiceInputNumber=tsMeasurePrefServiceInputNumber, csCSValue=csCSValue, snrCSEntry=snrCSEntry, groupTerrestrial=groupTerrestrial, capabilityCableOID=capabilityCableOID, cableSatPrefSysAvailTI=cableSatPrefSysAvailTI, berRSLPTestState=berRSLPTestState, tsTestsPrefEITOtherIntervalMax=tsTestsPrefEITOtherIntervalMax, cableSatPrefLinkAvailM=cableSatPrefLinkAvailM, berRSLPCounterDiscontinuity=berRSLPCounterDiscontinuity, capabilityCable=capabilityCable, rfAccuracyMeasurementState=rfAccuracyMeasurementState, merTValue=merTValue, eNDTLPInputNumber=eNDTLPInputNumber)
mibBuilder.exportSymbols("DVB-MGTR101290-MIB", eNDCInputNumber=eNDCInputNumber, sepSetiActiveTime=sepSetiActiveTime, rfChannelWidthEnable=rfChannelWidthEnable, tsMeasurePrefServiceService=tsMeasurePrefServiceService, qeTCounterDiscontinuity=qeTCounterDiscontinuity, tsTestsPrefSDTActualIntervalMin=tsTestsPrefSDTActualIntervalMin, tsConsistencyTable=tsConsistencyTable, eNDTCounter=eNDTCounter, aiCSValue=aiCSValue, eNFTLPCounterReset=eNFTLPCounterReset, groupTraps=groupTraps, terrestrialPrefBERViterbiLPMax=terrestrialPrefBERViterbiLPMax, berViterbiSEnable=berViterbiSEnable, tsTransportStreamBitRateValue=tsTransportStreamBitRateValue, rfChannelWidthTestState=rfChannelWidthTestState, berViterbiTLPCounter=berViterbiTLPCounter, noiseMarginLatestError=noiseMarginLatestError, tsMeasurePrefTSBitRateElement=tsMeasurePrefTSBitRateElement, rfChannelWidthEntry=rfChannelWidthEntry, rfChannelWidthValue=rfChannelWidthValue, berRSLPInputNumber=berRSLPInputNumber, controlNow=controlNow, tsTestsPrefPCRDiscontinuityMax=tsTestsPrefPCRDiscontinuityMax, rfChannelWidthLatestError=rfChannelWidthLatestError, terrestrialPrefHierarchical=terrestrialPrefHierarchical, merCSCounterReset=merCSCounterReset, qeTEntry=qeTEntry, noiseMarginActiveTime=noiseMarginActiveTime, eNFTLPCounterDiscontinuity=eNFTLPCounterDiscontinuity, eNDTLatestError=eNDTLatestError, rteCSTestState=rteCSTestState, berRSTable=berRSTable, tsTestsSummaryLatestError=tsTestsSummaryLatestError, DeliverySystemType=DeliverySystemType, linkAvailabilityInputNumber=linkAvailabilityInputNumber, tsPIDBitRateNomenclature=tsPIDBitRateNomenclature, qeCSEnable=qeCSEnable, ciCSActiveTime=ciCSActiveTime, aiTTestState=aiTTestState, mipSyntaxInputNumber=mipSyntaxInputNumber, aiCSEnable=aiCSEnable, sepSetiCounterReset=sepSetiCounterReset, terrestrialPrefAiMax=terrestrialPrefAiMax, terrestrialPrefSEPTI=terrestrialPrefSEPTI, eNDCTable=eNDCTable, cableSatPrefSignalPowerMin=cableSatPrefSignalPowerMin, BitRateElement=BitRateElement, qeTInputNumber=qeTInputNumber, rfAccuracyTestState=rfAccuracyTestState, mipSyntaxCounterReset=mipSyntaxCounterReset, capabilityCableSatTable=capabilityCableSatTable, estNoiseMarginEnable=estNoiseMarginEnable, ciCSCounter=ciCSCounter, eNDTLPCounter=eNDTLPCounter, symbolLengthCounterDiscontinuity=symbolLengthCounterDiscontinuity, iqAnalysisT=iqAnalysisT, tsMeasurePrefAllPIDBitRateN=tsMeasurePrefAllPIDBitRateN, symbolLengthTable=symbolLengthTable, eNFTTable=eNFTTable, mipSyntaxState=mipSyntaxState, csTInputNumber=csTInputNumber, terrestrialPrefSteMeanMax=terrestrialPrefSteMeanMax, qeCSTestState=qeCSTestState, linearityCounterReset=linearityCounterReset, terrestrialPrefChannelWidthLimit=terrestrialPrefChannelWidthLimit, ciCSCounterReset=ciCSCounterReset, tsTransportStreamBitRateInputNumber=tsTransportStreamBitRateInputNumber, cablePrefNoiseMarginMin=cablePrefNoiseMarginMin, tsTestsPIDTable=tsTestsPIDTable, estNoiseMarginCounter=estNoiseMarginCounter, sysAvailabilityEntry=sysAvailabilityEntry, qeTMeasurementState=qeTMeasurementState, eNDTActiveTime=eNDTActiveTime, signQualMarTTestState=signQualMarTTestState, controlEventPersistence=controlEventPersistence, terrestrialPrefENDLPIdeal=terrestrialPrefENDLPIdeal, tsMeasurePrefPCRFOMax=tsMeasurePrefPCRFOMax, capabilityTerrestrial=capabilityTerrestrial, qeTCounter=qeTCounter, berRSEntry=berRSEntry, rfIfSpectrumCounter=rfIfSpectrumCounter, steDeviationCSEntry=steDeviationCSEntry, capabilityCableSatAvailability=capabilityCableSatAvailability, mipSyntaxLatestError=mipSyntaxLatestError, berRSinServiceCounter=berRSinServiceCounter, terrestrialPrefENDIdeal=terrestrialPrefENDIdeal, berViterbiTLPCounterReset=berViterbiTLPCounterReset, tsTestsPrefInputNumber=tsTestsPrefInputNumber, measurementFailTrap=measurementFailTrap, cablePrefSignQualPercentMax=cablePrefSignQualPercentMax, terrestrialPrefBERRSMax=terrestrialPrefBERRSMax, tsMeasurePrefAllPIDBitRateTau=tsMeasurePrefAllPIDBitRateTau, tsSPPrefInputNumber=tsSPPrefInputNumber, csCSCounterDiscontinuity=csCSCounterDiscontinuity, groupCable=groupCable, eNDCCounterReset=eNDCCounterReset, systemErrorPerformance=systemErrorPerformance, steMeanCSInputNumber=steMeanCSInputNumber, signQualMarTCounterReset=signQualMarTCounterReset, tsTestsPrefSDTOtherTableIntervalMax=tsTestsPrefSDTOtherTableIntervalMax, outBandEmissEnable=outBandEmissEnable, eNFTLPActiveTime=eNFTLPActiveTime, tsTestsPIDLatestError=tsTestsPIDLatestError, trapControlOID=trapControlOID, rfIfPowerActiveTime=rfIfPowerActiveTime, trapControlPeriod=trapControlPeriod, eNFTTestState=eNFTTestState, steMeanCSActiveTime=steMeanCSActiveTime, snrCSLatestError=snrCSLatestError, terrestrialPrefBERRSLPMax=terrestrialPrefBERRSLPMax, rfIFsignalPowerEnable=rfIFsignalPowerEnable, tsMeasurePrefTSBitRateTau=tsMeasurePrefTSBitRateTau, berViterbiSActiveTime=berViterbiSActiveTime, eNDTEnable=eNDTEnable, sysAvailabilityActiveTime=sysAvailabilityActiveTime, tsPIDBitRateEnable=tsPIDBitRateEnable, linkAvailabilityActiveTime=linkAvailabilityActiveTime, eNDTEntry=eNDTEntry, cableSatPreferencesTable=cableSatPreferencesTable, pjCSActiveTime=pjCSActiveTime, berViterbiTActiveTime=berViterbiTActiveTime, steMeanTActiveTime=steMeanTActiveTime, outBandEmissInputNumber=outBandEmissInputNumber, UATMode=UATMode, outBandEmissLatestError=outBandEmissLatestError, terrestrialPrefQeMax=terrestrialPrefQeMax, berRSLPMeasurementState=berRSLPMeasurementState, berRSLPTable=berRSLPTable, tsTestsSummaryTable=tsTestsSummaryTable, tsTestsPIDInputNumber=tsTestsPIDInputNumber, tsTestsPrefPIDReferredIntervalMax=tsTestsPrefPIDReferredIntervalMax, merTCounterDiscontinuity=merTCounterDiscontinuity, eNFTLatestError=eNFTLatestError, linkAvailabilityInSUTI=linkAvailabilityInSUTI, capabilitySatelliteEntry=capabilitySatelliteEntry, sepEtiTestState=sepEtiTestState, tsMeasurePrefPIDPID=tsMeasurePrefPIDPID, ciCSCounterDiscontinuity=ciCSCounterDiscontinuity, berViterbiTEnable=berViterbiTEnable, sepSetiEntry=sepSetiEntry, InputNumber=InputNumber, tsPcrMeasurementActiveTime=tsPcrMeasurementActiveTime, controlRFSystemEntry=controlRFSystemEntry, merCSMeasurementState=merCSMeasurementState, IndexMIPSyntaxTest=IndexMIPSyntaxTest, capabilitySatelliteAvailability=capabilitySatelliteAvailability, sepSetiEnable=sepSetiEnable, cablePreferencesEntry=cablePreferencesEntry, cableSatPrefRteCSMax=cableSatPrefRteCSMax, measurementUnknownTrap=measurementUnknownTrap, steDeviationCSCounterDiscontinuity=steDeviationCSCounterDiscontinuity, bitRate=bitRate, ciCSValue=ciCSValue, steMeanTValue=steMeanTValue, GroupAvailability=GroupAvailability, berRSCounterReset=berRSCounterReset, rteCSValue=rteCSValue, tr101290Control=tr101290Control, tsMeasurePrefPIDBitRateMin=tsMeasurePrefPIDBitRateMin, capabilityMIBRevision=capabilityMIBRevision, berRSinServiceEnable=berRSinServiceEnable, tsTestsPIDCounterDiscontinuity=tsTestsPIDCounterDiscontinuity, rfChannelWidthCounterReset=rfChannelWidthCounterReset, tsMeasurePreferencesServiceTable=tsMeasurePreferencesServiceTable, rteCSMeasurementState=rteCSMeasurementState, capabilityTerrestrialPollInterval=capabilityTerrestrialPollInterval, tsServicePerformanceCounterReset=tsServicePerformanceCounterReset, TransportStreamID=TransportStreamID, linkAvailabilityUnavailableTime=linkAvailabilityUnavailableTime, ifSpectrumCounterDiscontinuity=ifSpectrumCounterDiscontinuity, terrestrialPrefENFLPMax=terrestrialPrefENFLPMax, IndexConsistencyTest=IndexConsistencyTest, tsTests=tsTests, groupCapability=groupCapability, cableSatPrefInputNumber=cableSatPrefInputNumber, snrCSMeasurementState=snrCSMeasurementState, rfIFsignalPowerCounter=rfIFsignalPowerCounter, tsTestsSummaryCounterDiscontinuity=tsTestsSummaryCounterDiscontinuity, berViterbiSCounterDiscontinuity=berViterbiSCounterDiscontinuity, tsTestsSummaryCounter=tsTestsSummaryCounter, berViterbiSIValue=berViterbiSIValue, csTTestState=csTTestState, pjCSInputNumber=pjCSInputNumber, csTCounterDiscontinuity=csTCounterDiscontinuity, noisePowerTestState=noisePowerTestState, tsMeasurePrefPIDBitRateN=tsMeasurePrefPIDBitRateN, berViterbiTMeasurementState=berViterbiTMeasurementState, cablePrefENDCtoNSpecified=cablePrefENDCtoNSpecified, rfIfPowerEnable=rfIfPowerEnable, steT=steT, eNFTValue=eNFTValue, terrestrialPrefModulation=terrestrialPrefModulation, tsTestsSummaryState=tsTestsSummaryState, snrCSActiveTime=snrCSActiveTime, rfIFsignalPowerInputNumber=rfIFsignalPowerInputNumber, capabilityCableTable=capabilityCableTable, tsTestsSummaryTestNumber=tsTestsSummaryTestNumber, noiseMarginValue=noiseMarginValue, capabilityTSTable=capabilityTSTable, cableSatPrefSteDeviationCSMax=cableSatPrefSteDeviationCSMax, rfChannelWidthCounterDiscontinuity=rfChannelWidthCounterDiscontinuity, complianceSatellite=complianceSatellite, rfAccuracyCounterReset=rfAccuracyCounterReset, cableSatPrefBERMax=cableSatPrefBERMax, capabilityTerrestrialEntry=capabilityTerrestrialEntry, aiTValue=aiTValue, terrestrialPrefPjMax=terrestrialPrefPjMax, noiseMarginTestState=noiseMarginTestState, trapInput=trapInput, aiTCounterReset=aiTCounterReset, tr101290Satellite=tr101290Satellite, satellitePreferencesEntry=satellitePreferencesEntry, eNDCActiveTime=eNDCActiveTime, steDeviationCSCounter=steDeviationCSCounter, steDeviationCSMeasurementState=steDeviationCSMeasurementState, cableSatPrefSignalPowerMax=cableSatPrefSignalPowerMax, noisePowerMeasurementState=noisePowerMeasurementState, cableSatPrefSteMeanCSMax=cableSatPrefSteMeanCSMax, linearityMeasurementState=linearityMeasurementState, rteCSCounterDiscontinuity=rteCSCounterDiscontinuity, eNDCCounter=eNDCCounter, tsServicePerformanceMeasurementState=tsServicePerformanceMeasurementState, tsPIDBitRateCounter=tsPIDBitRateCounter, tsPIDBitRateCounterDiscontinuity=tsPIDBitRateCounterDiscontinuity, capabilityTerrestrialOID=capabilityTerrestrialOID, rfIFsignalPowerTable=rfIFsignalPowerTable, berViterbiSTestState=berViterbiSTestState, rfIfPowerEntry=rfIfPowerEntry, tsPcrMeasurementRowStatus=tsPcrMeasurementRowStatus, qeCSMeasurementState=qeCSMeasurementState, sepEtiCounterReset=sepEtiCounterReset, berRSLPCounter=berRSLPCounter, sepEtiActiveTime=sepEtiActiveTime, terrestrialPrefSEPUATMode=terrestrialPrefSEPUATMode, cableSatPrefPjCSMax=cableSatPrefPjCSMax, tsServicePerformanceCounterDiscontinuity=tsServicePerformanceCounterDiscontinuity, eNDCLatestError=eNDCLatestError, steMeanTCounterDiscontinuity=steMeanTCounterDiscontinuity, eNDTLPTable=eNDTLPTable, dvb=dvb, cableSatPrefLinkAvailT=cableSatPrefLinkAvailT, tsTestsPrefEITActualIntervalMin=tsTestsPrefEITActualIntervalMin, berViterbiTCounterReset=berViterbiTCounterReset, controlRFSystemTable=controlRFSystemTable, noisePowerEnable=noisePowerEnable, tsServicePerformanceEnable=tsServicePerformanceEnable, pjCSValue=pjCSValue, qeTLatestError=qeTLatestError, steMeanCSTestState=steMeanCSTestState, pjCSEntry=pjCSEntry, pjTMeasurementState=pjTMeasurementState, berRSLPEnable=berRSLPEnable, rfIfPowerValue=rfIfPowerValue, csCSCounterReset=csCSCounterReset)
mibBuilder.exportSymbols("DVB-MGTR101290-MIB", linearityLatestError=linearityLatestError, tsPIDBitRateActiveTime=tsPIDBitRateActiveTime, berViterbiSEntry=berViterbiSEntry, qeCSValue=qeCSValue, tsTestsPrefSDTActualTableIntervalMax=tsTestsPrefSDTActualTableIntervalMax, tr101290Cable=tr101290Cable, sysAvailabilityEnable=sysAvailabilityEnable, capabilityCableSat=capabilityCableSat, tsMeasurePreferencesTable=tsMeasurePreferencesTable, ifSpectrumCounter=ifSpectrumCounter, steMeanTMeasurementState=steMeanTMeasurementState, tr101290Terrestrial=tr101290Terrestrial, tsTestsPrefTDTIntervalMin=tsTestsPrefTDTIntervalMin, sysAvailabilityTable=sysAvailabilityTable, eNFTCounterDiscontinuity=eNFTCounterDiscontinuity, terrestrialPrefMIPDeviationMax=terrestrialPrefMIPDeviationMax, tsMeasurePrefTSBitRateN=tsMeasurePrefTSBitRateN, pjCSTestState=pjCSTestState, terrestrialPrefBERViterbiMax=terrestrialPrefBERViterbiMax, cablePrefSignQualBoxSize=cablePrefSignQualBoxSize, tsTransportStreamBitRateTable=tsTransportStreamBitRateTable, berViterbiTLPTable=berViterbiTLPTable, ifSpectrumLatestError=ifSpectrumLatestError, eNDCMeasurementState=eNDCMeasurementState, rfIfSpectrumLatestError=rfIfSpectrumLatestError, berViterbiSCounterReset=berViterbiSCounterReset, complianceCable=complianceCable, terrestrialPrefCentreFreqExpected=terrestrialPrefCentreFreqExpected, sysAvailabilityUnavailableTime=sysAvailabilityUnavailableTime, ciCSInputNumber=ciCSInputNumber, capabilityTerrestrialGroup=capabilityTerrestrialGroup, eNFTEnable=eNFTEnable, tsPcrMeasurementEntry=tsPcrMeasurementEntry, cableSatPrefCiCSMin=cableSatPrefCiCSMin, tsTestsPrefPIDInputNumber=tsTestsPrefPIDInputNumber, complianceTerrestrial=complianceTerrestrial, cableSatPrefSysAvailM=cableSatPrefSysAvailM, rfAccuracyActiveTime=rfAccuracyActiveTime, steMeanTCounterReset=steMeanTCounterReset, outBandEmissCounterDiscontinuity=outBandEmissCounterDiscontinuity, tsMeasurements=tsMeasurements, rteCSActiveTime=rteCSActiveTime, csTCounterReset=csTCounterReset, rfIfPowerCounterReset=rfIfPowerCounterReset, complianceTransportStream=complianceTransportStream, aiTCounter=aiTCounter, tsMeasurePrefServiceBitRateTau=tsMeasurePrefServiceBitRateTau, berViterbiTInputNumber=berViterbiTInputNumber, tsMeasurePrefServiceBitRateN=tsMeasurePrefServiceBitRateN, sepSetiTable=sepSetiTable, berViterbiSCounter=berViterbiSCounter, tsMeasurePrefServiceBitRateMin=tsMeasurePrefServiceBitRateMin, sysAvailabilityCounter=sysAvailabilityCounter, tsTestsPrefTDTIntervalMax=tsTestsPrefTDTIntervalMax, tsPIDBitRateInputNumber=tsPIDBitRateInputNumber, tsMeasurePreferencesPIDTable=tsMeasurePreferencesPIDTable, rteCSLatestError=rteCSLatestError, rfIfSpectrumActiveTime=rfIfSpectrumActiveTime, tsConsistencyState=tsConsistencyState, berRSLPValue=berRSLPValue, cablePrefENDMax=cablePrefENDMax, merTTestState=merTTestState, steDeviationTTable=steDeviationTTable, terrestrialPrefMIPTimingLimit=terrestrialPrefMIPTimingLimit, tsTestsPrefReferredIntervalMax=tsTestsPrefReferredIntervalMax, tsTestsPIDState=tsTestsPIDState, cableSatPrefSysAvailUATMode=cableSatPrefSysAvailUATMode, ciCSEntry=ciCSEntry, tsPIDBitRateEntry=tsPIDBitRateEntry, ifSpectrumEnable=ifSpectrumEnable, PIDPlusOne=PIDPlusOne, linearityCounter=linearityCounter, tsServiceBitRateEnable=tsServiceBitRateEnable, rteCSEnable=rteCSEnable, eNDTInputNumber=eNDTInputNumber, steMeanTTable=steMeanTTable, berRSCounter=berRSCounter, rfAccuracyInputNumber=rfAccuracyInputNumber, FloatingPoint=FloatingPoint, tsMeasurePrefTSBitRateMin=tsMeasurePrefTSBitRateMin, outBandEmissTable=outBandEmissTable, tsMeasurePrefAllServiceBitRateTau=tsMeasurePrefAllServiceBitRateTau, capabilityCableSatGroup=capabilityCableSatGroup, qeTValue=qeTValue, estNoiseMarginEntry=estNoiseMarginEntry, sysAvailabilityMeasurementState=sysAvailabilityMeasurementState, merCSEnable=merCSEnable, tsTransportStreamBitRateNomenclature=tsTransportStreamBitRateNomenclature, aiTEnable=aiTEnable, estNoiseMarginActiveTime=estNoiseMarginActiveTime, steDeviationCSInputNumber=steDeviationCSInputNumber, GuardInterval=GuardInterval, merCSInputNumber=merCSInputNumber, tsPcrMeasurementInputNumber=tsPcrMeasurementInputNumber, pjTEntry=pjTEntry, tsServiceBitRateRowStatus=tsServiceBitRateRowStatus, pjTCounterReset=pjTCounterReset, tsTransportStreamBitRateCounter=tsTransportStreamBitRateCounter, pjTActiveTime=pjTActiveTime, terrestrialPrefENDMax=terrestrialPrefENDMax, eNDT=eNDT, qeTCounterReset=qeTCounterReset, tsTestsSummaryCounterReset=tsTestsSummaryCounterReset, steMeanCSCounter=steMeanCSCounter, terrestrialPrefBandwidth=terrestrialPrefBandwidth, terrestrialPrefCsMin=terrestrialPrefCsMin, tsTestsSummaryEnable=tsTestsSummaryEnable, tsTestsPrefEITSOtherFarTableIntervalMax=tsTestsPrefEITSOtherFarTableIntervalMax, testFailTrap=testFailTrap, rfIfSpectrumTable=rfIfSpectrumTable, terrestrialPrefENFIdeal=terrestrialPrefENFIdeal, tsTestsPrefTransitionDuration=tsTestsPrefTransitionDuration, rteCSTable=rteCSTable, tsTransportStreamBitRateEnable=tsTransportStreamBitRateEnable, sepSetiValue=sepSetiValue, MeasurementState=MeasurementState, csCSTestState=csCSTestState, berViterbiSInputNumber=berViterbiSInputNumber, ciCSLatestError=ciCSLatestError, satellitePreferencesTable=satellitePreferencesTable, eNDTTable=eNDTTable, noiseMarginCounterDiscontinuity=noiseMarginCounterDiscontinuity, rfIfPowerCounterDiscontinuity=rfIfPowerCounterDiscontinuity, berViterbiTLPLatestError=berViterbiTLPLatestError, tsMeasurePreferencesPIDEntry=tsMeasurePreferencesPIDEntry, tsServicePerformancePreferencesEntry=tsServicePerformancePreferencesEntry, symbolLengthInputNumber=symbolLengthInputNumber, qeTTable=qeTTable, tsTestsPrefNITActualIntervalMax=tsTestsPrefNITActualIntervalMax, tsTransportStreamBitRateActiveTime=tsTransportStreamBitRateActiveTime, terrestrialPrefSEPMeasurementInterval=terrestrialPrefSEPMeasurementInterval, trapControlRateStatus=trapControlRateStatus, terrestrialPrefENFMax=terrestrialPrefENFMax, eNDTLPCounterReset=eNDTLPCounterReset, trapControlMeasurementValue=trapControlMeasurementValue, eNFTLPTestState=eNFTLPTestState, estNoiseMarginTable=estNoiseMarginTable, berViterbiTTable=berViterbiTTable, berViterbiTLPValue=berViterbiTLPValue, tsMeasurePrefPIDBitRateMax=tsMeasurePrefPIDBitRateMax, trapControlEntry=trapControlEntry, berRS=berRS, tsTestsPIDEnable=tsTestsPIDEnable, tsTestsPIDCounter=tsTestsPIDCounter, eNFTActiveTime=eNFTActiveTime, steMeanCSEntry=steMeanCSEntry, sepSetiTestState=sepSetiTestState, qeCSActiveTime=qeCSActiveTime, cableSatPrefModulation=cableSatPrefModulation, steMeanCSMeasurementState=steMeanCSMeasurementState, eNDTMeasurementState=eNDTMeasurementState, snrCSCounterReset=snrCSCounterReset, rfIfSpectrumEntry=rfIfSpectrumEntry, linearityEnable=linearityEnable, terrestrialPrefSEPEBPerCent=terrestrialPrefSEPEBPerCent, tsTestsPIDRowStatus=tsTestsPIDRowStatus, aiCSCounterReset=aiCSCounterReset, merCSValue=merCSValue, outBandEmissCounterReset=outBandEmissCounterReset, noisePowerCounterReset=noisePowerCounterReset, tsSPPrefEvaluationTime=tsSPPrefEvaluationTime, aiCSCounterDiscontinuity=aiCSCounterDiscontinuity, rfChannelWidthActiveTime=rfChannelWidthActiveTime, berRSinServiceInputNumber=berRSinServiceInputNumber, aiTActiveTime=aiTActiveTime, tsMeasurePrefExpectedTSID=tsMeasurePrefExpectedTSID, berRSinServiceTestState=berRSinServiceTestState, berRSinServiceLatestError=berRSinServiceLatestError, tsTestsPrefPIDPID=tsTestsPrefPIDPID, rfAccuracyEntry=rfAccuracyEntry, tsTestsPreferencesTable=tsTestsPreferencesTable, steDeviationTCounter=steDeviationTCounter, steDeviationTMeasurementState=steDeviationTMeasurementState, tsTestsPrefEITPFOtherTableIntervalMax=tsTestsPrefEITPFOtherTableIntervalMax, berViterbiSQValue=berViterbiSQValue, ServiceId=ServiceId, estNoiseMarginCounterDiscontinuity=estNoiseMarginCounterDiscontinuity, berViterbiSLatestError=berViterbiSLatestError, tsConsistencyInputNumber=tsConsistencyInputNumber, tsTestsPIDEntry=tsTestsPIDEntry, PollingInterval=PollingInterval, groupSatellite=groupSatellite, steDeviationTEnable=steDeviationTEnable, pjCSMeasurementState=pjCSMeasurementState, tsServiceBitRateState=tsServiceBitRateState, sepEtiInputNumber=sepEtiInputNumber, controlSynchronizedTime=controlSynchronizedTime, tsTestsPrefPCRIntervalMax=tsTestsPrefPCRIntervalMax, noisePowerEntry=noisePowerEntry, sysAvailabilityLatestError=sysAvailabilityLatestError, tsServiceBitRateCounterReset=tsServiceBitRateCounterReset, qeTEnable=qeTEnable, merTActiveTime=merTActiveTime, capabilitySatelliteOID=capabilitySatelliteOID, sysAvailabilityCounterReset=sysAvailabilityCounterReset, rfIFsignalPowerCounterDiscontinuity=rfIFsignalPowerCounterDiscontinuity, snrCSTestState=snrCSTestState, eNDTValue=eNDTValue, capabilitySatellite=capabilitySatellite, tsTestsPrefPCRInaccuracyMax=tsTestsPrefPCRInaccuracyMax, tsMeasurePrefPCRDRMax=tsMeasurePrefPCRDRMax, linkAvailabilityLatestError=linkAvailabilityLatestError, outBandEmissEntry=outBandEmissEntry, eNFTCounterReset=eNFTCounterReset, capabilityTerrestrialTable=capabilityTerrestrialTable, tsTestsPrefTxTTableIntervalMax=tsTestsPrefTxTTableIntervalMax, tsServicePerformance=tsServicePerformance, rfAccuracyLatestError=rfAccuracyLatestError, cableSatPrefSysAvailTotalTime=cableSatPrefSysAvailTotalTime, merTLatestError=merTLatestError, trapControlFailureSummary=trapControlFailureSummary, qeCSEntry=qeCSEntry, tsTestsPreferencesEntry=tsTestsPreferencesEntry, rfIFsignalPowerTestState=rfIFsignalPowerTestState, merCSTable=merCSTable, aiCSInputNumber=aiCSInputNumber, symbolLengthEnable=symbolLengthEnable, eNDTLPValue=eNDTLPValue, terrestrialPrefENFLPIdeal=terrestrialPrefENFLPIdeal, eNFTMeasurementState=eNFTMeasurementState, tsServicePerformanceActiveTime=tsServicePerformanceActiveTime, ciCSTable=ciCSTable, merCSEntry=merCSEntry, tsTestsSummaryInputNumber=tsTestsSummaryInputNumber, cableSatPrefMerCSMin=cableSatPrefMerCSMin, tsSPPrefDeltaT=tsSPPrefDeltaT, pjTValue=pjTValue, rfChannelWidthMeasurementState=rfChannelWidthMeasurementState, steMeanCSCounterDiscontinuity=steMeanCSCounterDiscontinuity, linearityActiveTime=linearityActiveTime, rfIFsignalPowerCounterReset=rfIFsignalPowerCounterReset, terrestrialPrefSEPT=terrestrialPrefSEPT, tsTestsPrefSIGapMin=tsTestsPrefSIGapMin, merTInputNumber=merTInputNumber, tsMeasurePrefAllPIDBitRateElement=tsMeasurePrefAllPIDBitRateElement, tr101290TS=tr101290TS, csTCounter=csTCounter, IndexServicePerformance=IndexServicePerformance, berViterbiTLPEnable=berViterbiTLPEnable, capabilitySatelliteTable=capabilitySatelliteTable, sysAvailabilityRatio=sysAvailabilityRatio, berRSinServiceEntry=berRSinServiceEntry, tr101290Conformance=tr101290Conformance, cableSatPrefSysAvailEBPerCent=cableSatPrefSysAvailEBPerCent, qeTTestState=qeTTestState, csTEntry=csTEntry, mipSyntaxActiveTime=mipSyntaxActiveTime, steDeviationCSTestState=steDeviationCSTestState, pjCSEnable=pjCSEnable, pjCSCounterDiscontinuity=pjCSCounterDiscontinuity, noisePowerActiveTime=noisePowerActiveTime, merCSActiveTime=merCSActiveTime, csCSTable=csCSTable, tsMeasurePrefPCRDemarcationFrequency=tsMeasurePrefPCRDemarcationFrequency)
mibBuilder.exportSymbols("DVB-MGTR101290-MIB", linkAvailabilityRatio=linkAvailabilityRatio, steMeanCSCounterReset=steMeanCSCounterReset, rfIFsignalPowerMeasurementState=rfIFsignalPowerMeasurementState, capabilityCableSatPollInterval=capabilityCableSatPollInterval, tsServiceBitRateMeasurementState=tsServiceBitRateMeasurementState, tsMeasurePreferences=tsMeasurePreferences, tsSPPrefNumber=tsSPPrefNumber, cableSatPrefSysAvailN=cableSatPrefSysAvailN, rfChannelWidthCounter=rfChannelWidthCounter, pjTCounterDiscontinuity=pjTCounterDiscontinuity, outBandEmissActiveTime=outBandEmissActiveTime, terrestrialPrefSteDeviationMax=terrestrialPrefSteDeviationMax, ciCSTestState=ciCSTestState, pjCSTable=pjCSTable, Availability=Availability, tsServiceBitRateTable=tsServiceBitRateTable, csTEnable=csTEnable, steMeanTEnable=steMeanTEnable, IndexTransportStreamTest=IndexTransportStreamTest, tsTestsPrefEITPFActualTableIntervalMax=tsTestsPrefEITPFActualTableIntervalMax, qeCSCounterDiscontinuity=qeCSCounterDiscontinuity, eNDTLPCounterDiscontinuity=eNDTLPCounterDiscontinuity, tsTestsPrefEITActualIntervalMax=tsTestsPrefEITActualIntervalMax, berViterbiTCounterDiscontinuity=berViterbiTCounterDiscontinuity, tsConsistencyTestNumber=tsConsistencyTestNumber, tsConsistencyEnable=tsConsistencyEnable, eNFTLPValue=eNFTLPValue, tsConsistencyCounter=tsConsistencyCounter, terrestrialPrefInputNumber=terrestrialPrefInputNumber, terrestrialPrefPowerMax=terrestrialPrefPowerMax, terrestrialPrefTransmissionMode=terrestrialPrefTransmissionMode, tsTestsPrefEITSOtherNearTableIntervalMax=tsTestsPrefEITSOtherNearTableIntervalMax, csTValue=csTValue, tsServicePerformanceErrorRatio=tsServicePerformanceErrorRatio, rfIFsignalPowerActiveTime=rfIFsignalPowerActiveTime, berRSLatestError=berRSLatestError, capabilityCableSatEntry=capabilityCableSatEntry, tsPcrMeasurementCounterReset=tsPcrMeasurementCounterReset, steDeviationCSValue=steDeviationCSValue, rfIfPowerInputNumber=rfIfPowerInputNumber, capabilityTSPollInterval=capabilityTSPollInterval, cableSatPrefLinkAvailUPPerCent=cableSatPrefLinkAvailUPPerCent, cablePrefEstNoiseMarginMin=cablePrefEstNoiseMarginMin, tsServiceBitRateEntry=tsServiceBitRateEntry, noiseMarginEntry=noiseMarginEntry, aiTEntry=aiTEntry, berRSActiveTime=berRSActiveTime, aiCSLatestError=aiCSLatestError, signQualMarTEntry=signQualMarTEntry, mipSyntaxEnable=mipSyntaxEnable, merTCounter=merTCounter, eNDTLPActiveTime=eNDTLPActiveTime, berViterbiT=berViterbiT, steCS=steCS, symbolLengthLatestError=symbolLengthLatestError, rfIFsignalPowerValue=rfIFsignalPowerValue, snrCSCounter=snrCSCounter, berViterbiTLatestError=berViterbiTLatestError, linearityTestState=linearityTestState, capabilityCableAvailability=capabilityCableAvailability, cableSatPrefLinkAvailN=cableSatPrefLinkAvailN, tsPIDBitRateValue=tsPIDBitRateValue, TestState=TestState, terrestrialPrefSEPN=terrestrialPrefSEPN, csTActiveTime=csTActiveTime, qeCSTable=qeCSTable, linkAvailabilityCounterReset=linkAvailabilityCounterReset, tsPIDBitRateRowStatus=tsPIDBitRateRowStatus, tsTestsPreferencesPIDEntry=tsTestsPreferencesPIDEntry, eNDTCounterDiscontinuity=eNDTCounterDiscontinuity, TerrestrialTransmissionMode=TerrestrialTransmissionMode, terrestrialPreferencesEntry=terrestrialPreferencesEntry, groupTransportStream=groupTransportStream, cablePreferencesTable=cablePreferencesTable, steDeviationCSEnable=steDeviationCSEnable, tsConsistencyCounterReset=tsConsistencyCounterReset, berViterbiTLPTestState=berViterbiTLPTestState, aiTTable=aiTTable, ifSpectrumTable=ifSpectrumTable, RateStatus=RateStatus, eNDTLPTestState=eNDTLPTestState, berViterbiTEntry=berViterbiTEntry, cableSatPrefLinkAvailTI=cableSatPrefLinkAvailTI, sepEtiEnable=sepEtiEnable, tsServicePerformanceState=tsServicePerformanceState, terrestrialPrefLinearityMin=terrestrialPrefLinearityMin, cablePrefENDIdeal=cablePrefENDIdeal, tsTestsPreferences=tsTestsPreferences, steMeanCSEnable=steMeanCSEnable, cablePrefInputNumber=cablePrefInputNumber, berRSLPEntry=berRSLPEntry, terrestrialPrefENDBER=terrestrialPrefENDBER, steMeanTLatestError=steMeanTLatestError, qeCSCounterReset=qeCSCounterReset, tsPcrMeasurementCounter=tsPcrMeasurementCounter, sepEtiLatestError=sepEtiLatestError, berRSinServiceActiveTime=berRSinServiceActiveTime, tsTestsPIDCounterReset=tsTestsPIDCounterReset, noiseMarginCounter=noiseMarginCounter, signQualMarTCounter=signQualMarTCounter, tsMeasurePrefAllServiceBitRateN=tsMeasurePrefAllServiceBitRateN, aiCSActiveTime=aiCSActiveTime, tsServicePerformanceInputNumber=tsServicePerformanceInputNumber, tsServiceBitRateCounter=tsServiceBitRateCounter, signQualMarTTable=signQualMarTTable, rteCSCounter=rteCSCounter, steMeanTEntry=steMeanTEntry, aiCSTable=aiCSTable, berRSCounterDiscontinuity=berRSCounterDiscontinuity, eNFTInputNumber=eNFTInputNumber, groupTrapControl=groupTrapControl, tsTransportStreamBitRateCounterDiscontinuity=tsTransportStreamBitRateCounterDiscontinuity, rfIfSpectrumTestState=rfIfSpectrumTestState, eNFTEntry=eNFTEntry, tsMeasurePrefPCROJMax=tsMeasurePrefPCROJMax, linkAvailabilityEnable=linkAvailabilityEnable, sepSetiCounter=sepSetiCounter, snrCSCounterDiscontinuity=snrCSCounterDiscontinuity, sepEtiMeasurementState=sepEtiMeasurementState, tsServiceBitRateValue=tsServiceBitRateValue, tsTestsPrefBATTableIntervalMax=tsTestsPrefBATTableIntervalMax, berViterbiTLPInputNumber=berViterbiTLPInputNumber, tr101290Trap=tr101290Trap, tsPcrMeasurementLatestError=tsPcrMeasurementLatestError, rfAccuracyValue=rfAccuracyValue, ifSpectrumEntry=ifSpectrumEntry, qeCSInputNumber=qeCSInputNumber, rfChannelWidthTable=rfChannelWidthTable, groupControl=groupControl, noisePowerValue=noisePowerValue, cableSatPrefNoisePowerMax=cableSatPrefNoisePowerMax, eNDTLPLatestError=eNDTLPLatestError, csTLatestError=csTLatestError, satellitePrefInputNumber=satellitePrefInputNumber, tr101290Capability=tr101290Capability, Hierarchy=Hierarchy, sysAvailabilityInSETI=sysAvailabilityInSETI, berViterbiTLPEntry=berViterbiTLPEntry, berRSinServiceCounterReset=berRSinServiceCounterReset, csCSEntry=csCSEntry, berViterbiTTestState=berViterbiTTestState, controlSynchronizationEntry=controlSynchronizationEntry, aiTCounterDiscontinuity=aiTCounterDiscontinuity, ifSpectrumCounterReset=ifSpectrumCounterReset, steDeviationTInputNumber=steDeviationTInputNumber, eNDTLPEntry=eNDTLPEntry, signQualMarTInputNumber=signQualMarTInputNumber, csCSActiveTime=csCSActiveTime, berRSLPCounterReset=berRSLPCounterReset, linearityCounterDiscontinuity=linearityCounterDiscontinuity, eNFTLPEntry=eNFTLPEntry, snrCSEnable=snrCSEnable, merCSCounterDiscontinuity=merCSCounterDiscontinuity, ifSpectrumActiveTime=ifSpectrumActiveTime, mipSyntaxEntry=mipSyntaxEntry, steDeviationTCounterDiscontinuity=steDeviationTCounterDiscontinuity, rfIfSpectrumInputNumber=rfIfSpectrumInputNumber, terrestrialPrefSEPM=terrestrialPrefSEPM, capabilityCableGroup=capabilityCableGroup, rteCSEntry=rteCSEntry, estNoiseMarginLatestError=estNoiseMarginLatestError, estNoiseMarginMeasurementState=estNoiseMarginMeasurementState, csTMeasurementState=csTMeasurementState, eNFTLPInputNumber=eNFTLPInputNumber, rfAccuracyCounterDiscontinuity=rfAccuracyCounterDiscontinuity, rfSystemDelivery=rfSystemDelivery, tsPcrMeasurementEnable=tsPcrMeasurementEnable, tsTransportStreamBitRateLatestError=tsTransportStreamBitRateLatestError, merTTable=merTTable, merCSLatestError=merCSLatestError, terrestrialPrefENDLPMax=terrestrialPrefENDLPMax, aiCSEntry=aiCSEntry, tsServiceBitRateInputNumber=tsServiceBitRateInputNumber, noisePowerInputNumber=noisePowerInputNumber, pjCSLatestError=pjCSLatestError, sepSetiCounterDiscontinuity=sepSetiCounterDiscontinuity, rfIfPowerLatestError=rfIfPowerLatestError, berRSinServiceTable=berRSinServiceTable, tsConsistencyCounterDiscontinuity=tsConsistencyCounterDiscontinuity, sepEtiTable=sepEtiTable, steDeviationCSTable=steDeviationCSTable, tsTransportStreamBitRateState=tsTransportStreamBitRateState, snrCSTable=snrCSTable, tr101290=tr101290, snrCSInputNumber=snrCSInputNumber, eNFTLPCounter=eNFTLPCounter, tsTestsPrefPMTSectionIntervalMax=tsTestsPrefPMTSectionIntervalMax, terrestrialPrefCentreFreqLimit=terrestrialPrefCentreFreqLimit, tr101290ObjectGroups=tr101290ObjectGroups, tsTestsPrefRSTIntervalMin=tsTestsPrefRSTIntervalMin, symbolLengthTestState=symbolLengthTestState, symbolLengthValue=symbolLengthValue, aiCSCounter=aiCSCounter, noisePowerTable=noisePowerTable, steDeviationTCounterReset=steDeviationTCounterReset, tsMeasurePrefServiceBitRateMax=tsMeasurePrefServiceBitRateMax, terrestrialPrefCentreFrequency=terrestrialPrefCentreFrequency, steMeanCSTable=steMeanCSTable, eNDTTestState=eNDTTestState, tsServiceBitRateActiveTime=tsServiceBitRateActiveTime, tsMeasurePrefPIDInputNumber=tsMeasurePrefPIDInputNumber, qeCSCounter=qeCSCounter, steMeanCSLatestError=steMeanCSLatestError, ifSpectrumInputNumber=ifSpectrumInputNumber)
|
"""
Entradas --> 1 valor float que es el monto total de la compra
Costo total --> float --> a
Salidas --> 3-4 valores float según a, costo fondos de la empresa, la cantidad a pagar a crédito,
el monto a pagar por intereses y si es necesario, la cantidad prestada al banco.
Fondos de la empresa --> float --> b
Cantidad a pagar a credito --> float --> c
Intereses --> float --> d
Prestamo del banco --> float --> e
"""
# Entradas
a = float(input("\nDime el valor total de la compra "))
# Caja negra
if a > 5000000:
b = float(a*.55)
c = float(a*.25)
e = float(a*.30)
d = float(c*.20)
else:
b = float(a*.70)
c = float(a*.30)
d = float(c*.20)
e = 0
# Salida
print(f"\nLos fondos utilizados de la empresa son: {b} \nEl credito al fabricante es de: {c} \nPor intereses del fabricante tenemos {d}\nEl prestamo del banco es: {e}\n")
|
#!/home/cbrl/.virtualenvs/cbrl-PqEIqGlc/bin/python3.7
from django.core import management
if __name__ == "__main__":
management.execute_from_command_line()
|
import re
import networkx as nx
from .nodes import Assert, Inequal, Output, Dummy
label_map = {
"yes": True,
"no": False,
"true": True,
"false": False,
}
def generate_node_id(node, data):
"""Generate a node ID from the node label, extracts data from: [$ID].
Return the extracted node ID and the label, without the ID part, so
it can be the expression if one isn't specified in the description."""
pat = r"\[(?P<node_id>\w+)\]"
m = re.search(pat, data["label"])
if m:
return m.group("node_id"), re.sub(pat, '', data["label"]).strip()
assert m, ("node_id_func must return a valid node ID for each nodes, but "
f"it didn't for node {node}, {data}")
def load(pandag, path, custom_ids=False, node_id_func=generate_node_id):
"""Loads GraphML into Pandag algo."""
G = nx.read_graphml(path)
node_map = {}
for node, data in G.nodes(data=True):
node_id = node
if custom_ids:
node_id, custom_expr = node_id_func(node, data)
node_map[node] = node_id
edges = G.edges(node)
shape = data.get("shape_type")
label = data["label"]
description = data.get("description")
if not shape:
continue
if shape in ("com.yworks.flowchart.start1",
"com.yworks.flowchart.start2",
"com.yworks.flowchart.terminator"):
pandag.get_node_id(Dummy(label, _id=node_id))
if custom_ids:
expr = custom_expr
else:
expr = label
if shape == "com.yworks.flowchart.process":
if description:
# description can contain a multi-line expression
expr = description
pandag.get_node_id(Output(label, _id=node_id, expr=expr))
if shape == "com.yworks.flowchart.decision":
if len(edges) == 2:
pandag.get_node_id(Assert(expr, _label=label, _id=node_id))
else:
pandag.get_node_id(Inequal(expr, _label=label, _id=node_id))
for src_node_id, dst_node_id in nx.edge_dfs(G):
edge_data = G.get_edge_data(src_node_id, dst_node_id)
label = edge_data.get("label")
if label and label.lower() in label_map:
label = label_map[label.lower()]
if label is not None:
pandag.G.add_edge(node_map[src_node_id], node_map[dst_node_id],
label=label)
else:
pandag.G.add_edge(node_map[src_node_id], node_map[dst_node_id])
|
from rest_framework.serializers import ModelSerializer
from rest_framework.validators import ValidationError
from owner.utils import get_latlng
from .models import ProfessionalListing
class ProfessionalSerializer(ModelSerializer):
class Meta:
model = ProfessionalListing
exclude = ('listing_id',)
def create(self, validated_data):
address = validated_data.pop('brand_address')
city = validated_data.pop('city')
full_address = '{}, {}'.format(address, city)
request = self.context.get('request', None)
if request is not None and hasattr(request, 'user'):
user = request.user
lat = request.query_params.get('lat', '')
long = request.query_params.get('long', '')
image_path = validated_data.pop('images')
#latlng = get_latlng(full_address)
create_professional_listing = ProfessionalListing.objects.create(listing_id=user,
address=address, city=city, **validated_data)
return create_professional_listing
else:
raise ValidationError({'response': 'An error occured ', 'res': False, 'message': 'False'})
|
import pandas as pd
# Concatenate pandas objects along a particular axis with optional set logic along the
# other axes.
# Can also add a layer of hierarchical indexing on the concatenation axis, which may be
# useful if the labels are the same (or overlapping) on the passed axis number.
# Combine two series
s1 = pd.Series(data=['a', 'b'])
s2 = pd.Series(data=['c', 'd'])
print("<---- Concatenated Series ---->")
print(pd.concat(objs=[s1, s2]))
# Clear the existing index and reset it in the result by setting the ignore_index
# option to True.
print("<---- Concatenated Series with ignore_index = True ---->")
print(pd.concat(objs=[s1, s2], ignore_index=True))
# Add a hierarchical index at the outermost level of the data with the keys option.
print("<---- Concatenated Series with keys option ---->")
print(pd.concat(objs=[s1, s2], keys=['series1', 'series2']))
# Label the index keys you create with the names option.
print("<---- Concatenated Series with keys and name option ---->")
print(pd.concat(objs=[s1, s2], keys=['series1', 'series2'],
names=['Series Name', 'Row ID']))
# Combine two DataFrame objects with identical columns
df1 = pd.DataFrame(data=[['foo', 'foo@123'], ['bar', 'bar@123']],
columns=['username', 'password'])
print("<---- First DataFrame ---->")
print(df1)
df2 = pd.DataFrame(data=[['buz', 'buz@123'], ['qux', 'qux@123']],
columns=['username', 'password'])
print("<---- Second DataFrame ---->")
print(df2)
print("<---- Concatenated DataFrame ---->")
print(pd.concat(objs=[df1, df2]))
# Combine DataFrame objects with overlapping columns and return everything. Columns
# outside the intersection will be filled with NaN values.
df3 = pd.DataFrame(data=[['buz', 'buz@123', 'developer'], ['qux', 'qux@123', 'tester']],
columns=['username', 'password', 'designation'])
print("<---- Concatenated DataFrame with NaN Value ---->")
# value of sort is default False
print(pd.concat(objs=[df1, df3], sort=True, ignore_index=True))
# Combine DataFrame objects with overlapping columns and return only those that are
# shared by passing inner to the join keyword argument.
print("<---- Concatenated DataFrame join option ---->")
# value of join is default "outer"
print(pd.concat(objs=[df1, df3], join="inner", ignore_index=True))
# Combine DataFrame objects horizontally along the x axis by passing in axis=1
# value of axis is default 0
print("<---- Concatenated DataFrame axis option ---->")
df4 = pd.DataFrame(data= [['[email protected]',True],['[email protected]',False]],
columns=['email','login'])
print(pd.concat(objs=[df1,df4],axis=1))
# Prevent the result from including duplicate index values with the
# verify_integrity option.
'''print("<---- Concatenated DataFrame verify_integrity option ---->")
df5 = pd.DataFrame(data=[1],columns=['A'])
print("<---- First DataFrame ----->")
print(df5)
df6 = pd.DataFrame(data=[1],columns=['A'])
print("<---- Second DataFrame ----->")
print(df6)
print(pd.concat(objs=[df5,df6],verify_integrity=True))'''
|
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
from . import ngram_synthetic_reward # noqa
from . import sequence_synthetic_reward # noqa
from . import single_step_synthetic_reward # noqa
from . import single_step_synthetic_reward_sparse_arch # noqa
|
# Import folder where sorting algorithms
import sys
import unittest
# For importing from different folders
# OBS: This is supposed to be done with automated testing, hence relative to folder we want to import from
sys.path.append('Algorithms/other')
# If run from local:
#sys.path.append('../../Algorithms/other')
from interval_scheduling import interval_scheduling
class test_intervalscheduling(unittest.TestCase):
def setUp(self):
# test cases we wish to run
self.R1 = [(0, 5), (3, 6),(5, 10)]
self.R1_correct = [(0,5), (5,10)]
self.R2 = []
self.R2_correct = []
self.R3 = [(0, 3), (3,6), (6,9), (9, 10)]
self.R3_correct = [(0, 3), (3,6), (6,9), (9, 10)]
self.R4 = [(1, 3), (0, 2), (1, 4), (2, 5)]
self.R4_correct = [(0,2), (2,5)]
self.R5 = [(0,3)]
self.R5_correct = [(0,3)]
def test_intervalscheduling_basic(self):
O = []
O = interval_scheduling(self.R1, O)
self.assertEqual(O, self.R1_correct)
def test_intervalscheduling_empty(self):
O = []
O = interval_scheduling(self.R2, O)
self.assertEqual(O, self.R2_correct)
def test_intervalscheduling_take_all(self):
O = []
O = interval_scheduling(self.R3, O)
self.assertEqual(O, self.R3_correct)
def test_intervalscheduling_unsorted(self):
O = []
O = interval_scheduling(self.R4, O)
self.assertEqual(O, self.R4_correct)
def test_intervalscheduling_one_element(self):
O = []
O = interval_scheduling(self.R5, O)
self.assertEqual(O, self.R5_correct)
if __name__ == '__main__':
print("Running Interval Scheduling tests:")
unittest.main() |
class BaseFSM:
# TODO add logger mixIN?
# TODO auto complete able event function
def __init__(self):
self.initial_state = None
self._state = None
self._states = []
self._events = []
self._state_machine = {}
self._state_to_str = {}
self._state_to_num = {}
self._event_to_str = {}
self._event_to_num = {}
self._check_state = {}
self._check_event = {}
@property
def state(self):
return self._state
@property
def get_events(self):
return self._events
@property
def states(self):
return self._states
@property
def get_state_machine(self):
return self._state_machine
@property
def state_to_str(self):
return self._state_to_str
@property
def state_to_num(self):
return self._state_to_num
@property
def event_to_num(self):
return self._event_to_num
@property
def event_to_str(self):
return self._event_to_str
def _update_state(self, new_state):
if type(new_state) == int:
self._state = self.state_to_str[new_state]
elif type(new_state) == str:
self._state = self._check_state[new_state]
else:
raise ValueError(f'{new_state} does not expected state')
def _raise_event(self, event):
if type(event) is int:
event = self._event_to_str[event]
elif type(event) is str:
event = self._check_event[event]
else:
raise ValueError(f'{event} does not expected event')
self._state = self._state_machine[self._state][event]
def add_state(self, name, num=None, initial_state=False):
if num is None:
num = len(self.states)
if initial_state:
self.initial_state = name
self._state = name
self._states += [name]
self._state_to_num[name] = num
self._state_to_str[num] = name
self._state_machine[name] = {}
self._check_state[name] = name
def add_event(self, name, source, destination, num=None):
if num is None:
num = len(self._events)
if source not in self.states:
raise ValueError(f"""'{source}' state is not in states""")
if destination not in self.states:
raise ValueError(f"""'{destination}' state is not in state""")
self._events += [name]
self._event_to_str[num] = name
self._event_to_num[name] = num
self._state_machine[source][name] = destination
self._check_event[name] = name
def event_func():
self._raise_event(name)
event_func.__name__ = name
setattr(self, name, event_func)
|
from .session import *
from .xvfb import *
import dryscrape.driver
|
"""Implementations of logging abstract base class managers."""
# pylint: disable=invalid-name
# Method names comply with OSID specification.
# pylint: disable=no-init
# Abstract classes do not define __init__.
# pylint: disable=too-few-public-methods
# Some interfaces are specified as 'markers' and include no methods.
# pylint: disable=too-many-public-methods
# Number of methods are defined in specification
# pylint: disable=too-many-ancestors
# Inheritance defined in specification
# pylint: disable=too-many-arguments
# Argument signature defined in specification.
# pylint: disable=duplicate-code
# All apparent duplicates have been inspected. They aren't.
import abc
class LoggingProfile:
"""The logging profile describes the interoperability among logging services."""
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def supports_visible_federation(self):
"""Tests if visible federation is supported.
:return: ``true`` if visible federation is supported, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_logging(self):
"""Tests if logging is supported.
:return: ``true`` if logging is supported, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_entry_lookup(self):
"""Tests if reading logs is supported.
:return: ``true`` if reading logs is supported, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_entry_query(self):
"""Tests if querying log entries is supported.
:return: ``true`` if querying log entries is supported, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_entry_search(self):
"""Tests if searching log entries is supported.
:return: ``true`` if searching log entries is supported, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_entry_notification(self):
"""Tests if log entry notification is supported,.
:return: ``true`` if log entry notification is available, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_entry_log(self):
"""Tests if looking up log entry log mappings is supported.
:return: ``true`` if log entry logs is supported, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_entry_log_assignment(self):
"""Tests if managing log entry log mappings is supported.
:return: ``true`` if log entry logs mapping assignment is supported, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_entry_smart_log(self):
"""Tests if smart logs is supported.
:return: ``true`` if smart logs is supported, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_lookup(self):
"""Tests for the availability of a log lookup service.
:return: ``true`` if log lookup is available, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_query(self):
"""Tests if querying logs is available.
:return: ``true`` if log query is available, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_search(self):
"""Tests if searching for logs is available.
:return: ``true`` if log search is available, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_admin(self):
"""Tests for the availability of a log administrative service for creating and deleting logs.
:return: ``true`` if log administration is available, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_notification(self):
"""Tests for the availability of a log notification service.
:return: ``true`` if log notification is available, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented in all
providers.*
"""
return # boolean
@abc.abstractmethod
def supports_log_hierarchy(self):
"""Tests for the availability of a log hierarchy traversal service.
:return: ``true`` if log hierarchy traversal is available, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_hierarchy_design(self):
"""Tests for the availability of a log hierarchy design service.
:return: ``true`` if log hierarchy design is available, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented in all
providers.*
"""
return # boolean
@abc.abstractmethod
def supports_logging_batch(self):
"""Tests for the availability of a logging batch service.
:return: ``true`` if loggin batch service is available, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented in all
providers.*
"""
return # boolean
@abc.abstractmethod
def get_log_entry_record_types(self):
"""Gets the supported ``Log`` record types.
:return: a list containing the supported log record types
:rtype: ``osid.type.TypeList``
*compliance: mandatory -- This method must be implemented.*
"""
return # osid.type.TypeList
log_entry_record_types = property(fget=get_log_entry_record_types)
@abc.abstractmethod
def supports_log_entry_record_type(self, log_entry_record_type):
"""Tests if the given ``LogEntry`` record type is supported.
:param log_entry_record_type: a ``Type`` indicating a ``LogEntry`` record type
:type log_entry_record_type: ``osid.type.Type``
:return: ``true`` if the given ``Type`` is supported, ``false`` otherwise
:rtype: ``boolean``
:raise: ``NullArgument`` -- ``log_entry_record_type`` is ``null``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def get_log_entry_search_record_types(self):
"""Gets the supported log entry search record types.
:return: a list containing the supported log entry search record types
:rtype: ``osid.type.TypeList``
*compliance: mandatory -- This method must be implemented.*
"""
return # osid.type.TypeList
log_entry_search_record_types = property(fget=get_log_entry_search_record_types)
@abc.abstractmethod
def supports_log_entry_search_record_type(self, log_entry_search_record_type):
"""Tests if the given log entry search record type is supported.
:param log_entry_search_record_type: a ``Type`` indicating a log entry record type
:type log_entry_search_record_type: ``osid.type.Type``
:return: ``true`` if the given ``Type`` is supported, ``false`` otherwise
:rtype: ``boolean``
:raise: ``NullArgument`` -- ``log_entry_search_record_type`` is ``null``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def get_log_record_types(self):
"""Gets the supported ``Log`` record types.
:return: a list containing the supported log record types
:rtype: ``osid.type.TypeList``
*compliance: mandatory -- This method must be implemented.*
"""
return # osid.type.TypeList
log_record_types = property(fget=get_log_record_types)
@abc.abstractmethod
def supports_log_record_type(self, log_record_type):
"""Tests if the given ``Log`` record type is supported.
:param log_record_type: a ``Type`` indicating a ``Log`` record type
:type log_record_type: ``osid.type.Type``
:return: ``true`` if the given ``Type`` is supported, ``false`` otherwise
:rtype: ``boolean``
:raise: ``NullArgument`` -- ``log_record_type`` is ``null``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def get_log_search_record_types(self):
"""Gets the supported log search record types.
:return: a list containing the supported log search record types
:rtype: ``osid.type.TypeList``
*compliance: mandatory -- This method must be implemented.*
"""
return # osid.type.TypeList
log_search_record_types = property(fget=get_log_search_record_types)
@abc.abstractmethod
def supports_log_search_record_type(self, log_search_record_type):
"""Tests if the given log search record type is supported.
:param log_search_record_type: a ``Type`` indicating a log record type
:type log_search_record_type: ``osid.type.Type``
:return: ``true`` if the given ``Type`` is supported, ``false`` otherwise
:rtype: ``boolean``
:raise: ``NullArgument`` -- ``log_search_record_type`` is ``null``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def get_priority_types(self):
"""Gets the priority types supported, in ascending order of the priority level.
:return: a list containing the supported priority types
:rtype: ``osid.type.TypeList``
*compliance: mandatory -- This method must be implemented.*
"""
return # osid.type.TypeList
priority_types = property(fget=get_priority_types)
@abc.abstractmethod
def supports_priority_type(self, priority_type):
"""Tests if the priority type is supported.
:param priority_type: a ``Type`` indicating a priority type
:type priority_type: ``osid.type.Type``
:return: ``true`` if the given ``Type`` is supported, ``false`` otherwise
:rtype: ``boolean``
:raise: ``NullArgument`` -- ``priority_type`` is ``null``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def get_content_types(self):
"""Gets the content types supported.
:return: a list containing the supported content types
:rtype: ``osid.type.TypeList``
*compliance: mandatory -- This method must be implemented.*
"""
return # osid.type.TypeList
content_types = property(fget=get_content_types)
@abc.abstractmethod
def supports_content_type(self, content_type):
"""Tests if the content type is supported.
:param content_type: a ``Type`` indicating a content type
:type content_type: ``osid.type.Type``
:return: ``true`` if the given ``Type`` is supported, ``false`` otherwise
:rtype: ``boolean``
:raise: ``NullArgument`` -- ``content_type`` is ``null``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
@abc.abstractmethod
def supports_log_entry_admin(self):
"""Tests if log entry admin is supported.
:return: ``true`` if log entry admin is supported, ``false`` otherwise
:rtype: ``boolean``
*compliance: mandatory -- This method must be implemented.*
"""
return # boolean
class LoggingManager:
"""The logging manager provides access to logging sessions and provides interoperability tests for various aspects of this service.
The sessions included in this manager are:
* ``LoggingSession:`` a session to write to a log
* ``LogEntryLookupSession:`` a session to read a log
* ``LogEntryQuerySession:`` a session to search a log
* ``LogEntrySearchSession:`` a session to search a log
* ``LogEntryAdminSession:`` a session to manage log entries in a
log
* ``LogEntryNotificationSession:`` a session to subscribe to
notifications of new log entries
* ``LogEntryLogSession:`` a session to examine log entry to log
mappings
* ``LogEntryLogAssignmentSession:`` a session to manage log entry
to log mappings
* ``LogEntrySmartLogSession:`` a session to manage dynamic logs
* ``LogLookupSession:`` a session to retrieve log objects
* ``LogQuerySession:`` a session to search for logs
* ``LogSearchSession:`` a session to search for logs
* ``LogAdminSession:`` a session to create, update and delete logs
* ``LogNotificationSession:`` a session to receive notifications
for changes in logs
* ``LogHierarchyTraversalSession:`` a session to traverse
hierarchies of logs
* ``LogHierarchyDesignSession:`` a session to manage hierarchies
of logs
The logging manager also provides a profile for determing the
supported search types supported by this service.
"""
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_logging_session(self):
"""Gets the ``OsidSession`` associated with the logging service.
:return: a ``LoggingSession``
:rtype: ``osid.logging.LoggingSession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_logging()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_logging()`` is ``true``.*
"""
return # osid.logging.LoggingSession
logging_session = property(fget=get_logging_session)
@abc.abstractmethod
def get_logging_session_for_log(self, log_id):
"""Gets the ``OsidSession`` associated with the logging service for the given log.
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:return: a ``LoggingSession``
:rtype: ``osid.logging.LoggingSession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_id`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_logging()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_logging()`` and ``supports_visible_federation()`` are
``true``*
"""
return # osid.logging.LoggingSession
@abc.abstractmethod
def get_log_entry_lookup_session(self):
"""Gets the ``OsidSession`` associated with the log reading service.
:return: a ``LogEntryLookupSession``
:rtype: ``osid.logging.LogEntryLookupSession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_lookup()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_lookup()`` is ``true``.*
"""
return # osid.logging.LogEntryLookupSession
log_entry_lookup_session = property(fget=get_log_entry_lookup_session)
@abc.abstractmethod
def get_log_entry_lookup_session_for_log(self, log_id):
"""Gets the ``OsidSession`` associated with the log reading service for the given log.
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:return: a ``LogEntryLookupSession``
:rtype: ``osid.logging.LogEntryLookupSession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_id`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_lookup()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_lookup()`` and
``supports_visible_federation()`` are ``true``*
"""
return # osid.logging.LogEntryLookupSession
@abc.abstractmethod
def get_log_entry_query_session(self):
"""Gets the ``OsidSession`` associated with the logging entry query service.
:return: a ``LogEntryQuerySession``
:rtype: ``osid.logging.LogEntryQuerySession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_query()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_query()`` is ``true``.*
"""
return # osid.logging.LogEntryQuerySession
log_entry_query_session = property(fget=get_log_entry_query_session)
@abc.abstractmethod
def get_log_entry_query_session_for_log(self, log_id):
"""Gets the ``OsidSession`` associated with the log entry query service for the given log.
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:return: a ``LogEntryQuerySession``
:rtype: ``osid.logging.LogEntryQuerySession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_id`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_query()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_query()`` and
``supports_visible_federation()`` are ``true``*
"""
return # osid.logging.LogEntryQuerySession
@abc.abstractmethod
def get_log_entry_search_session(self):
"""Gets the ``OsidSession`` associated with the logging entry search service.
:return: a ``LogEntrySearchSession``
:rtype: ``osid.logging.LogEntrySearchSession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_search()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_search()`` is ``true``.*
"""
return # osid.logging.LogEntrySearchSession
log_entry_search_session = property(fget=get_log_entry_search_session)
@abc.abstractmethod
def get_log_entry_search_session_for_log(self, log_id):
"""Gets the ``OsidSession`` associated with the log entry search service for the given log.
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:return: a ``LogEntrySearchSession``
:rtype: ``osid.logging.LogEntrySearchSession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_id`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_search()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_search()`` and
``supports_visible_federation()`` are ``true``*
"""
return # osid.logging.LogEntrySearchSession
@abc.abstractmethod
def get_log_entry_admin_session(self):
"""Gets the ``OsidSession`` associated with the logging entry administrative service.
:return: a ``LogEntryAdminSession``
:rtype: ``osid.logging.LogEntryAdminSession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_admin()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_admin()`` is ``true``.*
"""
return # osid.logging.LogEntryAdminSession
log_entry_admin_session = property(fget=get_log_entry_admin_session)
@abc.abstractmethod
def get_log_entry_admin_session_for_log(self, log_id):
"""Gets the ``OsidSession`` associated with the log entry administrative service for the given log.
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:return: a ``LogEntryAdminSession``
:rtype: ``osid.logging.LogEntryAdminSession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_id`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_admin()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_admin()`` and
``supports_visible_federation()`` are ``true``*
"""
return # osid.logging.LogEntryAdminSession
@abc.abstractmethod
def get_log_entry_notification_session(self, log_entry_receiver):
"""Gets the ``OsidSession`` associated with the logging entry notification service.
:param log_entry_receiver: the receiver
:type log_entry_receiver: ``osid.logging.LogEntryReceiver``
:return: a ``LogEntryNotificationSession``
:rtype: ``osid.logging.LogEntryNotificationSession``
:raise: ``NullArgument`` -- ``log_entry_receiver`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_notification()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_notification()`` is ``true``.*
"""
return # osid.logging.LogEntryNotificationSession
@abc.abstractmethod
def get_log_entry_notification_session_for_log(self, log_entry_receiver, log_id):
"""Gets the ``OsidSession`` associated with the log entry notification service for the given log.
:param log_entry_receiver: the receiver
:type log_entry_receiver: ``osid.logging.LogEntryReceiver``
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:return: a ``LogEntryNotificationSession``
:rtype: ``osid.logging.LogEntryNotificationSession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_entry_receiver`` or ``log_id`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_notification()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_notification()`` and
``supports_visible_federation()`` are ``true``*
"""
return # osid.logging.LogEntryNotificationSession
@abc.abstractmethod
def get_log_entry_log_session(self):
"""Gets the session for retrieving log entry to log mappings.
:return: a ``LogEntryLogSession``
:rtype: ``osid.logging.LogEntryLogSession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_log()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_log()`` is ``true``.*
"""
return # osid.logging.LogEntryLogSession
log_entry_log_session = property(fget=get_log_entry_log_session)
@abc.abstractmethod
def get_log_entry_log_assignment_session(self):
"""Gets the session for assigning log entry to logs mappings.
:return: a ``LogEntryLogAssignmentSession``
:rtype: ``osid.logging.LogEntryLogAssignmentSession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_log_assignment()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_log_assignment()`` is ``true``.*
"""
return # osid.logging.LogEntryLogAssignmentSession
log_entry_log_assignment_session = property(fget=get_log_entry_log_assignment_session)
@abc.abstractmethod
def get_log_entry_smart_log_session(self, log_id):
"""Gets the session for managing dynamic logEntry log.
:param log_id: the ``Id`` of the log
:type log_id: ``osid.id.Id``
:return: a ``LogEntrySmartLogSession``
:rtype: ``osid.logging.LogEntrySmartLogSession``
:raise: ``NotFound`` -- ``log_id`` not found
:raise: ``NullArgument`` -- ``log_id`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_smart_log()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_smart_log()`` is ``true``.*
"""
return # osid.logging.LogEntrySmartLogSession
@abc.abstractmethod
def get_log_lookup_session(self):
"""Gets the ``OsidSession`` associated with the log lookup service.
:return: a ``LogLookupSession``
:rtype: ``osid.logging.LogLookupSession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_lookup()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_lookup()`` is ``true``.*
"""
return # osid.logging.LogLookupSession
log_lookup_session = property(fget=get_log_lookup_session)
@abc.abstractmethod
def get_log_query_session(self):
"""Gets the ``OsidSession`` associated with the log query service.
:return: a ``LogQuerySession``
:rtype: ``osid.logging.LogQuerySession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_query()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_query()`` is ``true``.*
"""
return # osid.logging.LogQuerySession
log_query_session = property(fget=get_log_query_session)
@abc.abstractmethod
def get_log_search_session(self):
"""Gets the ``OsidSession`` associated with the log search service.
:return: a ``LogSearchSession``
:rtype: ``osid.logging.LogSearchSession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_search()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_search()`` is ``true``.*
"""
return # osid.logging.LogSearchSession
log_search_session = property(fget=get_log_search_session)
@abc.abstractmethod
def get_log_admin_session(self):
"""Gets the ``OsidSession`` associated with the log administrative service.
:return: a ``LogAdminSession``
:rtype: ``osid.logging.LogAdminSession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_admin()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_admin()`` is ``true``.*
"""
return # osid.logging.LogAdminSession
log_admin_session = property(fget=get_log_admin_session)
@abc.abstractmethod
def get_log_notification_session(self, log_receiver):
"""Gets the ``OsidSession`` associated with the log notification service.
:param log_receiver: the receiver
:type log_receiver: ``osid.logging.LogReceiver``
:return: a ``LogNotificationSession``
:rtype: ``osid.logging.LogNotificationSession``
:raise: ``NullArgument`` -- ``log_receiver`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_notification()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_notification()`` is ``true``.*
"""
return # osid.logging.LogNotificationSession
@abc.abstractmethod
def get_log_hierarchy_session(self):
"""Gets the ``OsidSession`` associated with the log hierarchy service.
:return: a ``LogHierarchySession`` for logs
:rtype: ``osid.logging.LogHierarchySession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_hierarchy()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_hierarchy()`` is ``true``.*
"""
return # osid.logging.LogHierarchySession
log_hierarchy_session = property(fget=get_log_hierarchy_session)
@abc.abstractmethod
def get_log_hierarchy_design_session(self):
"""Gets the ``OsidSession`` associated with the log hierarchy design service.
:return: a ``HierarchyDesignSession`` for logs
:rtype: ``osid.logging.LogHierarchyDesignSession``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_hierarchy_design()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_hierarchy_design()`` is ``true``.*
"""
return # osid.logging.LogHierarchyDesignSession
log_hierarchy_design_session = property(fget=get_log_hierarchy_design_session)
@abc.abstractmethod
def get_logging_batch_manager(self):
"""Gets a ``LoggingBatchManager``.
:return: a ``LoggingBatchManager``
:rtype: ``osid.logging.batch.LoggingBatchManager``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_logging_batch()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_logging_batch()`` is ``true``.*
"""
return # osid.logging.batch.LoggingBatchManager
logging_batch_manager = property(fget=get_logging_batch_manager)
class LoggingProxyManager:
"""The logging manager provides access to logging sessions and provides interoperability tests for various aspects of this service.
Methods in this manager support the passing of a ``Proxy`` for the
purposes of passing information from server environments. The
sessions included in this manager are:
* ``LoggingSession:`` a session to write to a log
* ``LogEntryLookupSession:`` a session to read a log
* ``LogEntryQuerySession:`` a session to search a log
* ``LogEntrySearchSession:`` a session to search a log
* ``LogEntryAdminSession:`` a session to manage log entries in a
log
* ``LogEntryNotificationSession:`` a session to subscribe to
notifications of new log entries
* ``LogEntryLogSession:`` a session to examine log entry to log
mappings
* ``LogEntryLogAssignmentSession:`` a session to manage log entry
to log mappings
* ``LogEntrySmartLogSession:`` a session to manage dynamic logs
* ``LogLookupSession:`` a session to retrieve log objects
* ``LogQuerySession:`` a session to search for logs
* ``LogSearchSession:`` a session to search for logs
* ``LogAdminSession:`` a session to create, update and delete logs
* ``LogNotificationSession:`` a session to receive notifications
for changes in logs
* ``LogHierarchyTraversalSession:`` a session to traverse
hierarchies of logs
* ``LogHierarchyDesignSession:`` a session to manage hierarchies
of logs
The logging manager also provides a profile for determing the
supported search types supported by this service.
"""
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_logging_session(self, proxy):
"""Gets the ``OsidSession`` associated with the logging service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LoggingSession``
:rtype: ``osid.logging.LoggingSession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_logging()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_logging()`` is ``true``.*
"""
return # osid.logging.LoggingSession
@abc.abstractmethod
def get_logging_session_for_log(self, log_id, proxy):
"""Gets the ``OsidSession`` associated with the logging service for the given log.
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LoggingSession``
:rtype: ``osid.logging.LoggingSession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_id`` or ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_logging()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_logging()`` and ``supports_visible_federation()`` are
``true``*
"""
return # osid.logging.LoggingSession
@abc.abstractmethod
def get_log_entry_lookup_session(self, proxy):
"""Gets the ``OsidSession`` associated with the logging reading service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntryLookupSession``
:rtype: ``osid.logging.LogEntryLookupSession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_lookup()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_lookup()`` is ``true``.*
"""
return # osid.logging.LogEntryLookupSession
@abc.abstractmethod
def get_log_entry_lookup_session_for_log(self, log_id, proxy):
"""Gets the ``OsidSession`` associated with the log reading service for the given log.
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntryLookupSession``
:rtype: ``osid.logging.LogEntryLookupSession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_id`` or ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_lookup()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_lookup()`` and
``supports_visible_federation()`` are ``true``*
"""
return # osid.logging.LogEntryLookupSession
@abc.abstractmethod
def get_log_entry_query_session(self, proxy):
"""Gets the ``OsidSession`` associated with the logging entry query service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntryQuerySession``
:rtype: ``osid.logging.LogEntryQuerySession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_query()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_query()`` is ``true``.*
"""
return # osid.logging.LogEntryQuerySession
@abc.abstractmethod
def get_log_entry_query_session_for_log(self, log_id, proxy):
"""Gets the ``OsidSession`` associated with the log entry query service for the given log.
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntryQuerySession``
:rtype: ``osid.logging.LogEntryQuerySession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_id`` or ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_query()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_query()`` and
``supports_visible_federation()`` are ``true``*
"""
return # osid.logging.LogEntryQuerySession
@abc.abstractmethod
def get_log_entry_search_session(self, proxy):
"""Gets the ``OsidSession`` associated with the logging entry search service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntrySearchSession``
:rtype: ``osid.logging.LogEntrySearchSession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_search()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_search()`` is ``true``.*
"""
return # osid.logging.LogEntrySearchSession
@abc.abstractmethod
def get_log_entry_search_session_for_log(self, log_id, proxy):
"""Gets the ``OsidSession`` associated with the log entry search service for the given log.
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntrySearchSession``
:rtype: ``osid.logging.LogEntrySearchSession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_id`` or ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_search()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_search()`` and
``supports_visible_federation()`` are ``true``*
"""
return # osid.logging.LogEntrySearchSession
@abc.abstractmethod
def get_log_entry_admin_session(self, proxy):
"""Gets the ``OsidSession`` associated with the logging entry administrative service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntryAdminSession``
:rtype: ``osid.logging.LogEntryAdminSession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_admin()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_admin()`` is ``true``.*
"""
return # osid.logging.LogEntryAdminSession
@abc.abstractmethod
def get_log_entry_admin_session_for_log(self, log_id, proxy):
"""Gets the ``OsidSession`` associated with the log entry administrative service for the given log.
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntryAdminSession``
:rtype: ``osid.logging.LogEntryAdminSession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_id`` or ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_admin()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_admin()`` and
``supports_visible_federation()`` are ``true``*
"""
return # osid.logging.LogEntryAdminSession
@abc.abstractmethod
def get_log_entry_notification_session(self, log_entry_receiver, proxy):
"""Gets the ``OsidSession`` associated with the logging entry notification service.
:param log_entry_receiver: the receiver
:type log_entry_receiver: ``osid.logging.LogEntryReceiver``
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntryNotificationSession``
:rtype: ``osid.logging.LogEntryNotificationSession``
:raise: ``NullArgument`` -- ``log_entry_receiver`` or ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_notification()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_notification()`` is ``true``.*
"""
return # osid.logging.LogEntryNotificationSession
@abc.abstractmethod
def get_log_entry_notification_session_for_log(self, log_entry_receiver, log_id, proxy):
"""Gets the ``OsidSession`` associated with the log entry notification service for the given log.
:param log_entry_receiver: the receiver
:type log_entry_receiver: ``osid.logging.LogEntryReceiver``
:param log_id: the ``Id`` of the ``Log``
:type log_id: ``osid.id.Id``
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntryNotificationSession``
:rtype: ``osid.logging.LogEntryNotificationSession``
:raise: ``NotFound`` -- no ``Log`` found by the given ``Id``
:raise: ``NullArgument`` -- ``log_entry_receiver, log_id`` or ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_notification()`` or ``supports_visible_federation()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_notification()`` and
``supports_visible_federation()`` are ``true``*
"""
return # osid.logging.LogEntryNotificationSession
@abc.abstractmethod
def get_log_entry_log_session(self, proxy):
"""Gets the session for retrieving log entry to log mappings.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntryLogSession``
:rtype: ``osid.logging.LogEntryLogSession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_log()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_log()`` is ``true``.*
"""
return # osid.logging.LogEntryLogSession
@abc.abstractmethod
def get_log_entry_log_assignment_session(self, proxy):
"""Gets the session for assigning log entry to log mappings.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntryLogAssignmentSession``
:rtype: ``osid.logging.LogEntryLogAssignmentSession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_log_assignment()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_log_assignment()`` is ``true``.*
"""
return # osid.logging.LogEntryLogAssignmentSession
@abc.abstractmethod
def get_log_entry_smart_log_session(self, log_id, proxy):
"""Gets the session for managing dynamic log entry logs.
:param log_id: the ``Id`` of the log
:type log_id: ``osid.id.Id``
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogEntrySmartLogSession``
:rtype: ``osid.logging.LogEntrySmartLogSession``
:raise: ``NotFound`` -- ``log_id`` not found
:raise: ``NullArgument`` -- ``log_id`` or ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_entry_smart_log()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_entry_smart_log()`` is ``true``.*
"""
return # osid.logging.LogEntrySmartLogSession
@abc.abstractmethod
def get_log_lookup_session(self, proxy):
"""Gets the ``OsidSession`` associated with the log lookup service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogLookupSession``
:rtype: ``osid.logging.LogLookupSession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_lookup()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_lookup()`` is ``true``.*
"""
return # osid.logging.LogLookupSession
@abc.abstractmethod
def get_log_query_session(self, proxy):
"""Gets the ``OsidSession`` associated with the log query service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogQuerySession``
:rtype: ``osid.logging.LogQuerySession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_query()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_query()`` is ``true``.*
"""
return # osid.logging.LogQuerySession
@abc.abstractmethod
def get_log_search_session(self, proxy):
"""Gets the ``OsidSession`` associated with the log search service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogSearchSession``
:rtype: ``osid.logging.LogSearchSession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_search()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_search()`` is ``true``.*
"""
return # osid.logging.LogSearchSession
@abc.abstractmethod
def get_log_admin_session(self, proxy):
"""Gets the ``OsidSession`` associated with the log administrative service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogAdminSession``
:rtype: ``osid.logging.LogAdminSession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_admin()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_admin()`` is ``true``.*
"""
return # osid.logging.LogAdminSession
@abc.abstractmethod
def get_log_notification_session(self, log_receiver, proxy):
"""Gets the ``OsidSession`` associated with the log notification service.
:param log_receiver: the receiver
:type log_receiver: ``osid.logging.LogReceiver``
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogNotificationSession``
:rtype: ``osid.logging.LogNotificationSession``
:raise: ``NullArgument`` -- ``log_receiver`` or ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_notification()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_notification()`` is ``true``.*
"""
return # osid.logging.LogNotificationSession
@abc.abstractmethod
def get_log_hierarchy_session(self, proxy):
"""Gets the ``OsidSession`` associated with the log hierarchy service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``LogHierarchySession`` for logs
:rtype: ``osid.logging.LogHierarchySession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_hierarchy()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_hierarchy()`` is ``true``.*
"""
return # osid.logging.LogHierarchySession
@abc.abstractmethod
def get_log_hierarchy_design_session(self, proxy):
"""Gets the ``OsidSession`` associated with the log hierarchy design service.
:param proxy: a proxy
:type proxy: ``osid.proxy.Proxy``
:return: a ``HierarchyDesignSession`` for logs
:rtype: ``osid.logging.LogHierarchyDesignSession``
:raise: ``NullArgument`` -- ``proxy`` is ``null``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_log_hierarchy_design()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_log_hierarchy_design()`` is ``true``.*
"""
return # osid.logging.LogHierarchyDesignSession
@abc.abstractmethod
def get_logging_batch_proxy_manager(self):
"""Gets a ``LoggingBatchProxyManager``.
:return: a ``LoggingBatchProxyManager``
:rtype: ``osid.logging.batch.LoggingBatchProxyManager``
:raise: ``OperationFailed`` -- unable to complete request
:raise: ``Unimplemented`` -- ``supports_logging_batch()`` is ``false``
*compliance: optional -- This method must be implemented if
``supports_logging_batch()`` is ``true``.*
"""
return # osid.logging.batch.LoggingBatchProxyManager
logging_batch_proxy_manager = property(fget=get_logging_batch_proxy_manager)
|
def mapper(key, value):
# value is ignored, key is a line of text
for k in key.lower().split():
yield k.strip(), 1
|
# ## Object Oriented Programming
import numpy as np
import matplotlib.pyplot as plt
# ### Basics of Python Classes
class ExampleOne(object):
pass
c = ExampleOne()
c.__str__()
type(c)
class ExampleTwo(object):
def __init__(self, a, b):
self.a = a
self.b = b
c = ExampleTwo(1, 'text')
c.a
c.b
c.a = 100
c.a
class Math(object):
def __init__(self, a, b):
self.a = a
self.b = b
def addition(self):
return self.a + self.b
def difference(self):
return self.a-self.b
c = Math(10, 15)
c.addition()
c.difference()
class MoreMath(Math):
def multiplication(self):
return self.a * self.b
def sumproduct(self):
return self.multiplication()+self.addition()
c = MoreMath(10, 15)
# ### Simple Short Rate Class
class ShortRate(object):
''' Class to model a constant short rate object.
Parameters
==========
name : string
name of the object
rate : float
positive, constant short rate
Methods
=======
get_discount_factors :
returns discount factors for given list/array
of dates/times (as year fractions)
'''
def __init__(self, rate):
self.rate = rate
def get_discount_factors(self, times):
''' times : list/array-like '''
times = np.array(times)
return np.exp(-self.rate * times)
sr = ShortRate(0.05)
sr.name, sr.rate
times = [0.0, 0.5, 1.0, 1.25, 1.75, 2.0] # in year fractions
sr.get_discount_factors(times)
# Discount factors for different short rates over 5 years
for r in [0.025, 0.05, 0.1, 0.15]:
sr.rate = r
plt.plot(times, sr.get_discount_factors(times),
label='r=%4.2f' % sr.rate, lw=1.5)
plt.xlabel('years')
plt.ylabel('discount factor')
plt.grid(True)
plt.legend(loc=0)
# Calculate present values of future cash flows
sr.rate = 0.05
cash_flows = np.array([-100, 50, 75])
times = [0.0, 1.0, 2.0]
disc_facts = sr.get_discount_factors(times)
disc_facts
# present value list
disc_facts * cash_flows
# net present value
np.sum(disc_facts * cash_flows)
sr.rate = 0.15
np.sum(sr.get_discount_factors(times) * cash_flows)
# EXERCISES:
# 1) Make a class that wraps up these computations
# Your class should take as attributes
# a name, times, cash_flows, instance of ShortRate class
# and methods to calculate a present value list and the net present value
# 2) Extend your class to analyze the sensitivity to the short rate
# ### SOLUTION: Cash Flow Series Class
#
class CashFlowSeries:
''' Class to model a cash flows series.
Attributes
==========
name : string
name of the object
times : list/array-like
list of (positive) year fractions
cash_flows : list/array-like
corresponding list of cash flow values
short_rate : instance of short_rate class
short rate object used for discounting
Methods
=======
present_value_list :
returns an array with present values
net_present_value :
returns NPV for cash flow series
'''
def __init__(self, name, times, cash_flows, short_rate):
self.name = name
self.times = times
self.cash_flows = cash_flows
self.short_rate = short_rate
def present_value_list(self):
df = self.short_rate.get_discount_factors(self.times)
return np.array(self.cash_flows) * df
def net_present_value(self):
return np.sum(self.present_value_list())
sr.rate = 0.05
cfs = CashFlowSeries('cfs', times, cash_flows, sr)
cfs.cash_flows
cfs.times
cfs.present_value_list()
cfs.net_present_value()
class CashFlowSeriesSensitivity(CashFlowSeries):
def npv_sensitivity(self, short_rates):
npvs = []
for rate in short_rates:
sr.rate = rate
npvs.append(self.net_present_value())
return np.array(npvs)
cfs_sens = CashFlowSeriesSensitivity('cfs', times, cash_flows, sr)
short_rates = [0.01, 0.025, 0.05, 0.075, 0.1, 0.125, 0.15, 0.2]
npvs = cfs_sens.npv_sensitivity(short_rates)
npvs
plt.plot(short_rates, npvs, 'b')
plt.plot(short_rates, npvs, 'ro')
plt.plot((0, max(short_rates)), (0, 0), 'r', lw=2)
plt.grid(True)
plt.xlabel('short rate')
plt.ylabel('net present value')
plt.show() |
#!/usr/bin/env python
import os
import re
import sys
import h5py
import random
import numpy as np
from tqdm import tqdm
poi = np.array([])
def dist(point1):
global poi
return np.linalg.norm(point1-poi)
# One way to reach a specified number of points, is to remove points from "bigger" pointclouds
# The idea is to remove the points that are farthest away from the center of the pointcloud
# The problem here:
# Is the shape of the pointcloud maintained, or we mutated it?
# Possible solution:
# Apply a light shape-maintaing sampling method and then remove the farthest points (but is this easy?)
def clearPointcloudOuterPoints(pointcloud, target_no_points):
global poi
if len(pointcloud) - target_no_points <= 0:
return pointcloud
else:
pointcloud = np.array(pointcloud)
cx = np.mean([point[0] for point in pointcloud])
cy = np.mean([point[1] for point in pointcloud])
cz = np.mean([point[2] for point in pointcloud])
poi = np.array([cx,cy,cz])
dists = np.array(map(dist, pointcloud))
sorted_dists_ind = np.argpartition(dists, target_no_points-1)
return pointcloud[sorted_dists_ind][:target_no_points]
# Another way to reach a specified number of points is to add points to "smaller" pointclouds
# The idea is to add points at the exact same position as others in the pointcloud
# The problem here:
# Do these extra points add bias?
def addPointsToPointcloud(pointcloud, target_no_points):
while len(pointcloud) < target_no_points:
pointcloud.append(random.choice(pointcloud))
return pointcloud
def main():
if len(sys.argv) < 2:
print("Not enough arguments")
return
# Note to self, currently using this csv:
# /home/gstavrinos/catkin_ws/src/new_hpr/pointcloud2_segments_tools/dataset2.csv
input_file = sys.argv[1]
path, f = sys.argv[1].rsplit(os.sep, 1)
output_file = path + os.sep + f.rsplit(".", 1)[0] + ".h5"
print("---")
print("Your h5 will be written in:")
print(output_file)
print("---")
data = []
labels = []
print("Processing csv file...")
with open(input_file, "rb") as if_:
for line in tqdm(if_.readlines()):
dt, lbl = line.rsplit(",", 1)
i = 0
tmp = []
for d in re.split(r"\(([^)]+)\)", dt):
# Skip every other element, because we get "," characters between each tuple
if i % 2 != 0:
d = d.split(",")
tmp.append(np.array([float(d[0]), float(d[1]), float(d[2])]))
i += 1
if len(tmp) > 20:
tmp = addPointsToPointcloud(tmp, 1024)
tmp = clearPointcloudOuterPoints(tmp, 1024)
data.append(tmp)
labels.append(int(lbl))
print("---")
print("Generating h5 file...")
if os.path.exists(output_file):
os.remove(output_file)
with h5py.File(output_file, "a") as h5out:
h5out.create_dataset("data", data=data, compression="gzip", compression_opts=4, dtype="float32")
h5out.create_dataset("label", data=labels, compression="gzip", compression_opts=4, dtype="int")
print("All done! bb")
main() |
# -*- encoding: utf-8 -*-
import click
from . import stack
from ..utils import command_exception_handler, tail_stack_events
from ...cli import ClickContext
@stack.command()
@click.option('--timeout', '-t', type=click.IntRange(min=0, max=3600),
default=300, help='wait time in seconds before exit')
@click.option('--events', '-n', type=click.IntRange(min=0, max=100),
default=0,
help='number of latest stack events, 0 means fetch all'
'stack events')
@click.pass_context
@command_exception_handler
def tail(ctx, timeout, events):
"""Wath stack events, not this command will only select first one
if mutable stacks matches stack selector."""
assert isinstance(ctx.obj, ClickContext)
for stack_context in ctx.obj.runner.contexts:
stack_context.make_boto3_parameters()
ctx.obj.ppt.pprint_stack_name(
stack_context.stack_key,
stack_context.parameters['StackName'],
'Stack events for '
)
session = stack_context.session
cfn = session.resource('cloudformation')
stack = cfn.Stack(stack_context.parameters['StackName'])
tail_stack_events(session, stack, latest_events=events,
time_limit=timeout)
|
# -*- coding: utf-8 -*-
import hmac
from hashlib import sha1 as sha
py3k = False
try:
from urlparse import urlparse, unquote
from base64 import encodestring
except:
py3k = True
from urllib.parse import urlparse, unquote
from base64 import encodebytes as encodestring
from email.utils import formatdate
class S3Auth():
"""Attaches AWS Authentication to the given Request object."""
service_base_url = 's3.amazonaws.com'
# List of Query String Arguments of Interest
special_params = [
'acl', 'location', 'logging', 'partNumber', 'policy', 'requestPayment',
'torrent', 'versioning', 'versionId', 'versions', 'website', 'uploads',
'uploadId', 'response-content-type', 'response-content-language',
'response-expires', 'response-cache-control', 'delete', 'lifecycle',
'response-content-disposition', 'response-content-encoding', 'tagging',
'notification', 'cors', 'syncing'
]
def __init__(self, access_key, secret_key, service_url=None, url=None, headers={},method='GET'):
if service_url:
self.service_base_url = service_url
self.access_key = str(access_key)
self.secret_key = str(secret_key)
self.headers = headers
self.url = url
self.method = method
def sign(self):
# Create date header if it is not created yet.
if 'date' not in self.headers and 'x-amz-date' not in self.headers:
self.headers['date'] = formatdate(
timeval=None,
localtime=False,
usegmt=True)
signature = self.get_signature()
if py3k:
signature = signature.decode('utf-8')
self.headers['Authorization'] = 'AWS %s:%s' % (self.access_key, signature)
return self
def get_signature(self):
canonical_string = self.get_canonical_string(
self.url, self.headers, self.method)
if py3k:
key = self.secret_key.encode('utf-8')
msg = canonical_string.encode('utf-8')
else:
key = self.secret_key
msg = canonical_string
h = hmac.new(key, msg, digestmod=sha)
return encodestring(h.digest()).strip()
def get_canonical_string(self, url, headers, method):
parsedurl = urlparse(url)
objectkey = parsedurl.path[1:]
query_args = sorted(parsedurl.query.split('&'))
bucket = parsedurl.netloc[:-len(self.service_base_url)]
if len(bucket) > 1:
# remove last dot
bucket = bucket[:-1]
interesting_headers = {
'content-md5': '',
'content-type': '',
'date': ''}
for key in headers:
lk = key.lower()
try:
lk = lk.decode('utf-8')
except:
pass
if headers[key] and (lk in interesting_headers.keys()
or lk.startswith('x-amz-')):
interesting_headers[lk] = headers[key].strip()
# If x-amz-date is used it supersedes the date header.
if not py3k:
if 'x-amz-date' in interesting_headers:
interesting_headers['date'] = ''
else:
if 'x-amz-date' in interesting_headers:
interesting_headers['date'] = ''
buf = '%s\n' % method
for key in sorted(interesting_headers.keys()):
val = interesting_headers[key]
if key.startswith('x-amz-'):
buf += '%s:%s\n' % (key, val)
else:
buf += '%s\n' % val
# append the bucket if it exists
if bucket != '':
buf += '/%s' % bucket
# add the objectkey. even if it doesn't exist, add the slash
buf += '/%s' % objectkey
params_found = False
# handle special query string arguments
for q in query_args:
k = q.split('=')[0]
if k in self.special_params:
buf += '&' if params_found else '?'
params_found = True
try:
k, v = q.split('=', 1)
except ValueError:
buf += q
else:
buf += '{key}={value}'.format(key=k, value=unquote(v))
return buf
url='/test1/1.txt'
import urllib
url=urllib.quote("/test1/中文")
a = S3Auth('onest', 'onest', service_url='zgp2z1.ecloud.today',url=url, headers={
'X-Amz-Date': 'Sat, 04 Nov 2017 07:47:41 GMT',
'X-Amz-User-Agent':'aws-sdk-js/2.100.0 callback',
'Content-Type': 'text/plain'
},method='PUT').sign()
print a.headers['Authorization']
raw='''
Accept:*/*
Accept-Encoding:gzip, deflate, br
Accept-Language:zh-CN,zh;q=0.9,en;q=0.8,ja;q=0.7
Authorization:AWS onest:O3QnkuFZfPgbys33XHduZSvzcPg=
Connection:keep-alive
Content-Length:0
Content-Type:text/plain
DNT:1
Host:zgp2z1.ecloud.today
Origin:null
User-Agent:Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36
X-Amz-Date:Sat, 04 Nov 2017 07:47:41 GMT
X-Amz-User-Agent:aws-sdk-js/2.100.0 callback
'''
# import requests
# import logging
# from requests_toolbelt.utils import dump
# logging.basicConfig(level=logging.DEBUG)
# response = requests.put(url,headers= a.headers)
# data = dump.dump_all(response)
# print(data.decode('utf-8'))
|
import cv2
import numpy as np
from sklearn.metrics import pairwise
cap=cv2.Videocapture(0)
kernelOpen=np.ones((5,5))
kernelClose=np.ones((20,20))
lb=np.array([20,100,100])
ub=np.array([120,255,255])
while true:
ret,frame=cap.read()
flipped=cv2.flip(frame,1)
flipped=cv2.resize(flipped,(500,500))
imgSeg=cv2.cvtColor(frame,cv2.COLOR_BGR2HSV)
imgSegFlipped=cv2.flip(imgSeg,1)
imgSegFlipped=cv2.resize(imgSegFlipped,(500,400))
mask=cv2.inRange(imgSegFlipped,lb,ub)
mask=cv2.resize(mask,(500,400))
maskOpen=cv2.morphologyEx(mask,cv2.MORPH_OPEN,kernelOpen)
maskOpen=cv2.resize(maskOpen,(500,400))
maskClose=cv2.morphologyEx(maskOpen,cv2.MORPH_CLOSE,kernelClose)
maskClose=cv2.resize(maskClose,(500,400))
final=maskClose
_,conts,h=cv2.findContours(maskClose,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)
if(len(conts)!=0):
b=max(conts,key=cv2.contourArea)
west=tuple(b[b[:,:,0].argmin()][0])
east=tuple(b[b[:,:,0].argmax()][0])
north=tuple(b[b[:,:,0].argmin()][0])
south=tuple(b[b[:,:,0].argmax()][0])
center_x=(west[0]+east[0])/2
center_y=(north[0]+south[0])/2
cv2.drawContours(flipped,b,-1,(0,255,0),3)
cv2.circle(flipped,west,7,(0,0,255),-1)
cv2.circle(flipped,east,7,(0,0,255),-1)
cv2.circle(flipped,north,7,(0,0,255),-1)
cv2.circle(flipped,south,7,(0,0,255),-1)
cv2.circle(flipped,(int(center_x),int(center_y)),7,(0,0,255),-1)
cv2.imshow('video',flipped)
#cv2.imshow('mask',mask)
#cv2.imshow('maskOpen',maskOpen)
#cv2.imshow('maskClose',maskClose)
if cv2.waitKey(1)&0xFF==ord(''):
break
cap.release()
cv2.destroyAllWindows() |
import sys
import math
import os
import json
import subprocess
from transformers import GPT2TokenizerFast
from string import Template
import fcntl
# Shut up the warning
os.environ['TOKENIZERS_PARALLELISM'] = 'true'
FASTDATA = '/fastdata'
BASEDIR = os.path.join(FASTDATA, 'CodeLMs')
INDIR = os.path.join(BASEDIR, 'conf')
OUTDIR = os.path.join(BASEDIR, 'out')
os.makedirs(INDIR, exist_ok=True)
os.makedirs(OUTDIR, exist_ok=True)
DOCKER_IMG = 'moyix/polycoder:base'
VOCAB_FILE = os.path.join(BASEDIR, 'data/code-vocab.json')
MERGE_FILE = os.path.join(BASEDIR, 'data/code-merges.txt')
tok = GPT2TokenizerFast(VOCAB_FILE, MERGE_FILE)
MAX_TOKENS = 2048
def detect_gpus():
"""
Returns the number of GPUs available on the system.
"""
try:
nvidia_smi = subprocess.check_output(['nvidia-smi', '--query-gpu=gpu_name', '--format=csv,noheader'])
return len(nvidia_smi.splitlines())
except subprocess.CalledProcessError:
return -1
def trim_prompt(prompt, n):
"""
Trim a prompt to fit within the PolyCoder prompt length limit.
Trims whole lines at a time.
prompt: a string
n: the number of tokens we want to generate
Returns: a trimmed prompt such that len(tokenize(prompt)) + n <= MAX_TOKENS
"""
tokens = tok.encode(prompt)
if len(tokens) + n <= MAX_TOKENS: return prompt
tokens = tokens[-(MAX_TOKENS-n+1):]
token_strs = [tok.decode([t]) for t in tokens]
try:
first_nl = next(i for i in range(len(token_strs)) if '\n' in token_strs[i])
except StopIteration:
# No newlines in prompt, and the prompt is too big
raise ValueError(f"Prompt cannot be trimmed to fit within {MAX_TOKENS} tokens")
# Potential concern: if the last token containing a newline had trailing characters
# after the newline, we might accidentally lop off those characters. But I checked
# that for the PolyCoder tokenizer all the tokens with newlines have no trailing
# characters.
trimmed_prompt = ''.join(token_strs[first_nl+1:])
return trimmed_prompt
# How to invoke Docker
DOCKER_CMD = [
'nvidia-docker', 'run',
'--privileged', '--rm',
'--shm-size=1g',
'--ulimit', 'memlock=-1',
'--mount', f'type=bind,src={BASEDIR}/checkpoints-2-7B,dst=/gpt-neox/checkpoints',
# NB: want host and container paths to be the same to avoid
# having to translate between them
'-v', f'{FASTDATA}:{FASTDATA}',
DOCKER_IMG,
]
CONTAINER_CMD = [
'./deepy.py',
'generate.py',
'${config}',
'checkpoints/configs/local_setup.yml',
'checkpoints/configs/2-7B.yml'
]
def template_cmd(cmd, **kwargs):
return [Template(c).safe_substitute(**kwargs) for c in cmd]
# Atomic counter for naming files
def get_counter():
cfname = os.path.join(BASEDIR, 'counter.txt')
try:
counter_file = open(cfname, 'r+')
fcntl.flock(counter_file, fcntl.LOCK_EX)
try:
counter = int(counter_file.read())
except ValueError as ve:
print(ve)
counter = 0
except FileNotFoundError:
counter_file = open(cfname, 'w+')
counter = 0
counter_file.seek(0)
counter_file.write(str(counter+1))
fcntl.flock(counter_file, fcntl.LOCK_UN)
counter_file.close()
return counter
def prepare_cmd(prompt, max_tokens, temperature, top_p, n, gpu_num=0):
"""
Prepares the codegen command to be run in a Docker container.
Returns (cmd, outfile)
"""
counter = get_counter()
top_k = 0
# Save the prompt to a file
filename_pattern = f'PolyCoder_t{temperature:.2f}_p{top_p:.2f}_n{n}_max{max_tokens}.{counter:03d}'
prompt_file = os.path.join(INDIR, f'Prompt_{filename_pattern}.txt')
with open(prompt_file, 'w') as f:
f.write(prompt)
output_file = os.path.join(OUTDIR, f'Gen_{filename_pattern}.jsonl')
TEXTGEN_CONFIG = {
# Text gen type: `input-file`, `unconditional` or `interactive`
"text-gen-type": "input-file",
# Params for all
"maximum_tokens": max_tokens,
"temperature": temperature, # Raise for higher sample-counts.
"top_p": top_p,
"top_k": top_k,
"recompute": False,
# `unconditional`/`input-file`: samples
"num-samples": n,
# input/output file
"sample-input-file": prompt_file,
"sample-output-file": output_file,
# DeepSpeed doesn't respect CUDA_VISIBLE_DEVICES, so we need to set this
"include": f"localhost:{gpu_num}",
# Magic: even though we're doing inference, DeepSpeed still checks
# that train_batch_size == micro_batch_per_gpu * gradient_acc_step * world_size64
"train_batch_size": 32,
}
# Save the config to a file. Extension is YML but it's really JSON
config_file = os.path.join(INDIR,
f'Config_{filename_pattern}.yml')
with open(config_file, 'w') as f:
json.dump(TEXTGEN_CONFIG, f)
# Run the container
cmd = template_cmd(DOCKER_CMD + CONTAINER_CMD,
config=config_file)
print('Cmd:', ' '.join(cmd))
return cmd, output_file
def create(prompt, max_tokens, temperature, top_p, n):
cmd, output_file = prepare_cmd(prompt, max_tokens, temperature, top_p, n)
subprocess.run(cmd)
# Read the output
results = []
with open(output_file, 'r') as f:
for line in f:
results.append(json.loads(line))
return results
def prepare_batch(args, gpu_num=0):
"""
Prepares the codegen command to be run in a Docker container.
Returns (cmd, outfile)
"""
# Save the prompt to a file
glob_counter = get_counter()
output_files = []
objs = []
for prompt, max_tokens, temperature, top_p, top_k, n in args:
counter = get_counter()
filename_pattern = f'PolyCoder_t{temperature:.2f}_p{top_p:.2f}_n{n}_max{max_tokens}.{counter:03d}'
output_file = os.path.join(OUTDIR, f'Gen_{filename_pattern}.jsonl')
obj = {}
obj['prompt'] = prompt
obj['max_tokens'] = max_tokens
obj['temperature'] = temperature
obj['top_p'] = top_p
obj['top_k'] = top_k
obj['num_samples'] = n
obj['output_file'] = output_file
obj['recompute'] = False
objs.append(obj)
output_files.append(output_file)
out_json = os.path.join(INDIR, f'Batch_{glob_counter:03d}.json')
with open(out_json, 'w') as f:
json.dump(objs, f)
TEXTGEN_CONFIG = {
# Text gen type: `input-file`, `unconditional` or `interactive`
"text-gen-type": "batch",
"batch-input-file": out_json,
"recompute": False,
# DeepSpeed doesn't respect CUDA_VISIBLE_DEVICES, so we need to set this
"include": f"localhost:{gpu_num}",
# Magic: even though we're doing inference, DeepSpeed still checks
# that train_batch_size == micro_batch_per_gpu * gradient_acc_step * world_size64
"train_batch_size": 32,
}
# Save the config to a file. Extension is YML but it's really JSON
config_file = os.path.join(INDIR,
f'Config_{glob_counter:03d}.yml')
with open(config_file, 'w') as f:
json.dump(TEXTGEN_CONFIG, f)
# Run the container
cmd = template_cmd(DOCKER_CMD + CONTAINER_CMD,
config=config_file, gpu_num=gpu_num)
print('Cmd:', ' '.join(cmd))
return cmd, output_files
def create_batch(batch):
part_size = math.ceil(len(batch) / NUM_GPUS)
output_files = []
procs = []
for i in range(0, len(batch), part_size):
argpart = batch[i:i+part_size]
gpunum = i // part_size
cmd, output_files_part = prepare_batch(argpart, gpu_num=gpunum)
print(f"Launching container for batch generation of {part_size} tasks on GPU {gpunum}")
procs.append(subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL))
output_files += output_files_part
for proc in procs:
proc.wait()
return output_files
if __name__ == "__main__":
import argparse
import time
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-m', '--max_tokens', type=int, default=512, help='Max number of tokens to generate')
parser.add_argument('-n', '--num_samples', type=int, default=10, help='Number of samples to generate per prompt')
parser.add_argument('-p', '--top_p', type=float, default=0.0, help='Top p')
parser.add_argument('-k', '--top_k', type=float, default=0.0, help='Top k')
parser.add_argument('-t', '--temperature', type=float, default=0.5, help='Temperature')
parser.add_argument('--num_gpus', type=int, default=argparse.SUPPRESS, help='Number of GPUs to use (default: autodetect)')
parser.add_argument('prompt_files', nargs='+', help='Prompt files')
args = parser.parse_args()
# A few checks to make sure the model is downloaded
if not os.path.exists(f"{BASEDIR}/checkpoints-2-7B"):
print("Hmm, I didn't find the model at {BASEDIR}/checkpoints-2-7B.", file=sys.stderr)
print("", file=sys.stderr)
sys.exit(1)
if 'num_gpus' not in args:
NUM_GPUS = detect_gpus()
if NUM_GPUS == -1:
print("WARNING: Couldn't detect the number of GPUs using nvidia-smi.", file=sys.stderr)
print("Assuming NUM_GPUS = 1, but you can fix this with --num_gpus", file=sys.stderr)
NUM_GPUS = 1
else:
NUM_GPUS = args.num_gpus
prompts = []
for f in args.prompt_files:
with open(f, 'r') as fp:
prompt = fp.read()
trimmed_prompt = trim_prompt(prompt, args.max_tokens)
if prompt != trimmed_prompt:
print(f"Note: prompt trimmed from {len(prompt.splitlines())} to {len(trimmed_prompt.splitlines())} lines")
print(f"Saving trimmed prompt to {f}.trimmed")
open(f + '.trimmed', 'w').write(trimmed_prompt)
prompts.append((trimmed_prompt, args.max_tokens, args.temperature, args.top_p, args.top_k, args.num_samples))
# j = create(TEST_PROMPT, max_tokens=100, temperature=0.5, top_p=0.0, n=10)
start = time.time()
result_files = create_batch(prompts)
end = time.time()
taken = end - start
print("All done, results are in:")
for pf, res in zip(args.prompt_files, result_files):
print(f" {pf} -> {res}")
samples_generated = args.num_samples * len(prompts)
tokens_generated = samples_generated * args.max_tokens
print(f"Took {taken:.2f} seconds to generate {samples_generated} samples, {tokens_generated} tokens")
print(f"Generated {samples_generated/taken:.2f} samples/second, {tokens_generated/taken:.2f} tokens/second")
|
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: mediapipe/calculators/tflite/tflite_converter_calculator.proto
import sys
_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobuf import reflection as _reflection
from google.protobuf import symbol_database as _symbol_database
from google.protobuf import descriptor_pb2
# @@protoc_insertion_point(imports)
_sym_db = _symbol_database.Default()
from mediapipe.framework import calculator_pb2 as mediapipe_dot_framework_dot_calculator__pb2
mediapipe_dot_framework_dot_calculator__options__pb2 = mediapipe_dot_framework_dot_calculator__pb2.mediapipe_dot_framework_dot_calculator__options__pb2
DESCRIPTOR = _descriptor.FileDescriptor(
name='mediapipe/calculators/tflite/tflite_converter_calculator.proto',
package='mediapipe',
syntax='proto2',
serialized_pb=_b('\n>mediapipe/calculators/tflite/tflite_converter_calculator.proto\x12\tmediapipe\x1a$mediapipe/framework/calculator.proto\"\x84\x04\n TfLiteConverterCalculatorOptions\x12\x19\n\x0bzero_center\x18\x01 \x01(\x08:\x04true\x12\'\n\x18use_custom_normalization\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\x16\n\ncustom_div\x18\x07 \x01(\x02:\x02-1\x12\x16\n\ncustom_sub\x18\x08 \x01(\x02:\x02-1\x12\x1e\n\x0f\x66lip_vertically\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x10max_num_channels\x18\x03 \x01(\x05:\x01\x33\x12\x1f\n\x10row_major_matrix\x18\x04 \x01(\x08:\x05\x66\x61lse\x12$\n\x15use_quantized_tensors\x18\x05 \x01(\x08:\x05\x66\x61lse\x12_\n\x19output_tensor_float_range\x18\t \x01(\x0b\x32<.mediapipe.TfLiteConverterCalculatorOptions.TensorFloatRange\x1a,\n\x10TensorFloatRange\x12\x0b\n\x03min\x18\x01 \x01(\x02\x12\x0b\n\x03max\x18\x02 \x01(\x02\x32Y\n\x03\x65xt\x12\x1c.mediapipe.CalculatorOptions\x18\xc5\xc3\x9bu \x01(\x0b\x32+.mediapipe.TfLiteConverterCalculatorOptions')
,
dependencies=[mediapipe_dot_framework_dot_calculator__pb2.DESCRIPTOR,])
_sym_db.RegisterFileDescriptor(DESCRIPTOR)
_TFLITECONVERTERCALCULATOROPTIONS_TENSORFLOATRANGE = _descriptor.Descriptor(
name='TensorFloatRange',
full_name='mediapipe.TfLiteConverterCalculatorOptions.TensorFloatRange',
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name='min', full_name='mediapipe.TfLiteConverterCalculatorOptions.TensorFloatRange.min', index=0,
number=1, type=2, cpp_type=6, label=1,
has_default_value=False, default_value=float(0),
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='max', full_name='mediapipe.TfLiteConverterCalculatorOptions.TensorFloatRange.max', index=1,
number=2, type=2, cpp_type=6, label=1,
has_default_value=False, default_value=float(0),
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
],
extensions=[
],
nested_types=[],
enum_types=[
],
options=None,
is_extendable=False,
syntax='proto2',
extension_ranges=[],
oneofs=[
],
serialized_start=497,
serialized_end=541,
)
_TFLITECONVERTERCALCULATOROPTIONS = _descriptor.Descriptor(
name='TfLiteConverterCalculatorOptions',
full_name='mediapipe.TfLiteConverterCalculatorOptions',
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name='zero_center', full_name='mediapipe.TfLiteConverterCalculatorOptions.zero_center', index=0,
number=1, type=8, cpp_type=7, label=1,
has_default_value=True, default_value=True,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='use_custom_normalization', full_name='mediapipe.TfLiteConverterCalculatorOptions.use_custom_normalization', index=1,
number=6, type=8, cpp_type=7, label=1,
has_default_value=True, default_value=False,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='custom_div', full_name='mediapipe.TfLiteConverterCalculatorOptions.custom_div', index=2,
number=7, type=2, cpp_type=6, label=1,
has_default_value=True, default_value=float(-1),
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='custom_sub', full_name='mediapipe.TfLiteConverterCalculatorOptions.custom_sub', index=3,
number=8, type=2, cpp_type=6, label=1,
has_default_value=True, default_value=float(-1),
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='flip_vertically', full_name='mediapipe.TfLiteConverterCalculatorOptions.flip_vertically', index=4,
number=2, type=8, cpp_type=7, label=1,
has_default_value=True, default_value=False,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='max_num_channels', full_name='mediapipe.TfLiteConverterCalculatorOptions.max_num_channels', index=5,
number=3, type=5, cpp_type=1, label=1,
has_default_value=True, default_value=3,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='row_major_matrix', full_name='mediapipe.TfLiteConverterCalculatorOptions.row_major_matrix', index=6,
number=4, type=8, cpp_type=7, label=1,
has_default_value=True, default_value=False,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='use_quantized_tensors', full_name='mediapipe.TfLiteConverterCalculatorOptions.use_quantized_tensors', index=7,
number=5, type=8, cpp_type=7, label=1,
has_default_value=True, default_value=False,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='output_tensor_float_range', full_name='mediapipe.TfLiteConverterCalculatorOptions.output_tensor_float_range', index=8,
number=9, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
],
extensions=[
_descriptor.FieldDescriptor(
name='ext', full_name='mediapipe.TfLiteConverterCalculatorOptions.ext', index=0,
number=245817797, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=True, extension_scope=None,
options=None),
],
nested_types=[_TFLITECONVERTERCALCULATOROPTIONS_TENSORFLOATRANGE, ],
enum_types=[
],
options=None,
is_extendable=False,
syntax='proto2',
extension_ranges=[],
oneofs=[
],
serialized_start=116,
serialized_end=632,
)
_TFLITECONVERTERCALCULATOROPTIONS_TENSORFLOATRANGE.containing_type = _TFLITECONVERTERCALCULATOROPTIONS
_TFLITECONVERTERCALCULATOROPTIONS.fields_by_name['output_tensor_float_range'].message_type = _TFLITECONVERTERCALCULATOROPTIONS_TENSORFLOATRANGE
DESCRIPTOR.message_types_by_name['TfLiteConverterCalculatorOptions'] = _TFLITECONVERTERCALCULATOROPTIONS
TfLiteConverterCalculatorOptions = _reflection.GeneratedProtocolMessageType('TfLiteConverterCalculatorOptions', (_message.Message,), dict(
TensorFloatRange = _reflection.GeneratedProtocolMessageType('TensorFloatRange', (_message.Message,), dict(
DESCRIPTOR = _TFLITECONVERTERCALCULATOROPTIONS_TENSORFLOATRANGE,
__module__ = 'mediapipe.calculators.tflite.tflite_converter_calculator_pb2'
# @@protoc_insertion_point(class_scope:mediapipe.TfLiteConverterCalculatorOptions.TensorFloatRange)
))
,
DESCRIPTOR = _TFLITECONVERTERCALCULATOROPTIONS,
__module__ = 'mediapipe.calculators.tflite.tflite_converter_calculator_pb2'
# @@protoc_insertion_point(class_scope:mediapipe.TfLiteConverterCalculatorOptions)
))
_sym_db.RegisterMessage(TfLiteConverterCalculatorOptions)
_sym_db.RegisterMessage(TfLiteConverterCalculatorOptions.TensorFloatRange)
_TFLITECONVERTERCALCULATOROPTIONS.extensions_by_name['ext'].message_type = _TFLITECONVERTERCALCULATOROPTIONS
mediapipe_dot_framework_dot_calculator__options__pb2.CalculatorOptions.RegisterExtension(_TFLITECONVERTERCALCULATOROPTIONS.extensions_by_name['ext'])
# @@protoc_insertion_point(module_scope)
|
class Solution:
def sortTransformedArray(self, nums: List[int], a: int, b: int, c: int) -> List[int]:
"""
Given a sorted array of integers nums and integer values a, b and c.
Apply a quadratic function of the form f(x) = ax2 + bx + c to
each element x in the array.
The returned array must be in sorted order.
Expected time complexity: O(n)
"""
if a==0:
for i in range(len(nums)):
nums[i]=b*nums[i]+c
if b<0:
return nums[::-1]
else:
return nums
else:
symmetry = -b/2.0/a
lo,hi = 0, len(nums)-1
ans = []
while lo<=hi:
if abs(nums[lo]-symmetry)>abs(nums[hi]-symmetry):
ans.append(a*nums[lo]**2+b*nums[lo]+c)
lo+=1
else:
ans.append(a*nums[hi]**2+b*nums[hi]+c)
hi-=1
if a<0:
return ans
else:
return ans[::-1] |
import os
import time
import numpy as np
from opensimplex import OpenSimplex
#https://prod.liveshare.vsengsaas.visualstudio.com/join?91D41FFC1FF54C18E80F478C19B8AFFED337
def dist(pos1, pos2):
return (abs(pos1[0] - pos2[0]) ** 2 + abs(pos1[1] - pos2[1]) ** 2) ** 0.5
def cloudEffect(width, height, x, y, wind):
output = np.array([])
n = OpenSimplex()
middle = width//2, height//2
for i in np.arange(height):
newLine = np.array([])
for j in np.arange(width):
d = dist((j,i), middle)
# newLine = np.append(newLine, d)
newLine = np.append(newLine, (n.noise2d(i/5 + y*2.5,j/100 + x/5 + wind) + 1) * (d))
output = np.append(output, newLine)
output = np.reshape(output, (height,width))
return output
if __name__ == '__main__':
for x in np.arange(0,40):
for line in cloudEffect(30, 30, x, 0):
for p in line:
print(' ' if p < 4 else ' ' if p < 6 else 'MM', end='')
print('')
time.sleep(0.1)
os.system('cls')
|
"""
Python client for the Last.fm API with a pythonic interface to all methods,
including auth, etc. An async, Tornado-based client included as well.
"""
from .client import LastfmClient
__version__ = '0.0.4'
__author__ = 'Jakub Roztocil'
__email__ = 'BSD'
__licence__ = 'BSD'
|
import pyaudio
import numpy as np
import matplotlib.pyplot as plt
import struct
import scipy.io.wavfile as wavefile
CHUNK = 16000 * 2 # samples per frame
FORMAT = pyaudio.paInt16 # audio format (bytes per sample?)
CHANNELS = 1 # single channel for microphone
RATE = 16000 # samples per second
p = pyaudio.PyAudio()
stream = p.open(
format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
output=True,
frames_per_buffer=CHUNK
)
# binary data
data = stream.read(CHUNK)
len(data)
# convert data to integers, make np array, then offset it by 127
data_int = struct.unpack(str(2 * CHUNK) + 'B', data)
test_int = np.array(data_int)
plt.plot(test_int)
plt.show()
# create np array and offset by 128
data_np = np.array(data_int, dtype='b')[::2] + 128
wavefile.write('d:/test.wav', 16000, test_int) |
class PresentationTraceLevel(Enum,IComparable,IFormattable,IConvertible):
"""
Describes the level of detail to trace about a particular object.
enum PresentationTraceLevel,values: High (3),Low (1),Medium (2),None (0)
"""
def __eq__(self,*args):
""" x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
pass
def __format__(self,*args):
""" __format__(formattable: IFormattable,format: str) -> str """
pass
def __ge__(self,*args):
pass
def __gt__(self,*args):
pass
def __init__(self,*args):
""" x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
pass
def __le__(self,*args):
pass
def __lt__(self,*args):
pass
def __ne__(self,*args):
pass
def __reduce_ex__(self,*args):
pass
def __str__(self,*args):
pass
High=None
Low=None
Medium=None
None=None
value__=None
|
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.collections as collections
import matplotlib.patches as mpatches
import matplotlib.animation as animation
import matplotlib.colorbar as colorbar
import matplotlib.colors as colors
import matplotlib.gridspec as gridspec
import seaborn as sns
def lattice(N=10, geometry = "square", periodic = False, method = "construction", Ny = 4):
'''
function to create a lattice object "lat" defined as a dictionary with numerical keys describing
each cell. Each cell itself is a dictionary containing position and indexes of neighbouring cells
N --- is the number of rows and columns (NxN lattice)
Ny --- Aspect ratio is 1 if Ny is None, otherwise Ny is the number of cells in y-axis
distance between cells is set to 1
geometry --- the geometry of the lattice and the neighbours and can be:
"square": square lattice with 4 neighbours per square
"squarediag": square lattice with 8 neighbours (it consider diagonals)
"hexagonal": hexagonal lattive with 6 neighbours (use an even number for N)
periodic -- sets toroidal periiodic conditions in the tissue
method --- calls to the two different methods to build the network that are:
"distance" : determins the neighbours as the elments under a given distance
"construction" : The nearest neighbours are given by the topology
'''
if (N%2 == 1) and (geometry == "hexagonal"):
print("Hexagonal geometry requires an even dimension N")
elif (method == "distance"):
return lattice_distance(N=N, geometry = geometry, periodic = periodic)
elif (method == "construction"):
return lattice_construction(N=N, geometry = geometry, periodic = periodic, Ny = Ny)
else:
"Wrong lattice method, lattice not created"
def lattice_distance(N=10, geometry = "square", periodic = False):
'''
construction of the lattice given an interaction distance. Defult at the moment
is chosing nearest neighbours
'''
print("Creating lattice...")
lat = {}
idx = 0
if geometry == 'square' or geometry == 'squarediag' :
Lx = N # Length of the tissue in the x dimension
Ly = N # Length of the tissue in the y dimension
for row in range(N):
for col in range(N):
lat[idx] = {
"mpos": (row,col), # matrix position
"xpos": 1.0*col,
"ypos": 1.0*row,
"neighbours": [] # Neighbours filled later
}
idx = idx + 1
elif geometry == 'hexagonal':
Lx = N # Length of the tissue in the x dimension
Ly = N * np.sqrt(3)/2.0 # Length of the tissue in the y dimension
for row in range(N):
for col in range(N):
lat[idx] = {
"mpos": (row,col), # matrix position
"xpos": col + 0.5 * (row % 2), # alternate rows are interpersed in x-axis
"ypos": row * np.sqrt(3)/2.0, # factor comes from hexagonal packing
"neighbours": [] # Neighbours filled later
}
idx = idx + 1
# looking for neighbours, the implementation compares distances between pairs of cells
# it is not the most efficient but it is very flexible for any kind of lattice
# squared distance that dictates the radius at which consider neighbours are:
dist2geo = {'square':1.1,'hexagonal':1.1,'squarediag':2.1}
for cella in lat: # we will look for neighbour of cella
for cellb in lat: # we will look for all possibilities cellb
distx = abs(lat[cella]["xpos"]-lat[cellb]["xpos"])
disty = abs(lat[cella]["ypos"]-lat[cellb]["ypos"])
if periodic is True: # correct distances if toroidal boundary conditions are considered
distx = min(distx,Lx-distx)
disty = min(disty,Ly-disty)
dist2 = distx*distx + disty*disty # total Euclidean distance
if ((dist2 < dist2geo[geometry]) and (cella != cellb)):
lat[cella]["neighbours"].append(cellb) # add to the list of neighbours
print("Done!")
return lat
def lattice_construction(N=10, geometry = "square", periodic = False, Ny = None):
'''
Construction of the lattice by assigning the neighbours at the same time
that the network is created. This requires knowledge of the cell distribution
at creation time (true for regular lattices)
'''
print("Creating lattice..."),
print(geometry)
lat = {}
idx = 0
if geometry == 'square':
Nx = N
Lx = Nx # Length of the tissue in the x dimension
if Ny == None:
Ny = N
Ly = Ny # Length of the tissue in the y dimension
for row in range(Ny):
for col in range(Nx):
lat[idx] = {
"mpos": (row,col), # matrix position
"xpos": 1.0*col,
"ypos": 1.0*row,
"neighbours": []
}
if (idx%Nx) != Nx-1: # If it is not the last cell in the row
lat[idx]["neighbours"].append(idx+1) # Add neighbour to the right
elif periodic is True:
lat[idx]["neighbours"].append(idx+1-Nx) # Add neighbour to the right (cyclic)
if (idx%Nx) != 0: # If it is not the first cell in the row
lat[idx]["neighbours"].append(idx-1) # Add neighbour to the left
elif periodic is True:
lat[idx]["neighbours"].append(idx-1+Nx) # Add neighbour to the left (cyclic)
if (idx//Nx) != Ny-1: # It it is not the last row
lat[idx]["neighbours"].append(idx+Nx) # Add neighbour at the top
elif periodic is True:
lat[idx]["neighbours"].append(idx%Nx) # Add neighbour at the top (cyclic)
if (idx//Nx) != 0: # It it is not the first row
lat[idx]["neighbours"].append(idx-Nx) # Add neighbour at the bottom
elif periodic is True:
lat[idx]["neighbours"].append(Nx*(Ny-1)+idx) # Add neighbour at the bottm (cyclic)
idx = idx + 1 # Next cell
elif geometry == 'squaredig':
print("Geometry squaredig still does not accept lattice_construction method")
elif geometry == 'hexagonal':
print("Number of cells:"+str(N)+'x'+str(Ny))
Lx = N # Length of the tissue in the x dimension
if Ny:
Ly = Ny * np.sqrt(3)/2.0 # Length of the tissue in the y dimension
else:
Ly = N
Ny = N
for row in range(Ny):
for col in range(N):
lat[idx] = {
"mpos": (row,col), # matrix position
"xpos": col + 0.5 * (row % 2), # alternate rows are interpersed in x-axis
"ypos": row * np.sqrt(3)/2.0, # factor comes from hexagonal packing
"neighbours": [] # Neighbours filled later
}
# Computing of neighbours, it is not the most elegant, but is effective
# another way could be done by defining periodicity on an array and call that array
if (idx%N) != N-1: # If it is not the last cell in the row
lat[idx]["neighbours"].append(idx+1) # Add neighbour to the right
elif periodic is True:
lat[idx]["neighbours"].append(idx+1-N) # Add neighbour to the right (ciclic)
if (idx%N) != 0: # If it is not the first cell in the row
lat[idx]["neighbours"].append(idx-1) # Add neighbour to the left
elif periodic is True:
lat[idx]["neighbours"].append(idx-1+N) # Add neighbour to the left (ciclic)
if ((idx//N) % 2) == 0 : # It it is an even row
# Adding top neighbours for even rows
lat[idx]["neighbours"].append(idx+N) # Add neighbour to top right
if (idx%N) != 0: # If it is not the first cell in the row
lat[idx]["neighbours"].append(idx+N-1) # Add neighbour to the top left
elif periodic is True:
lat[idx]["neighbours"].append(idx+2*N-1) # Add neighbour to the top left
# Adding bottom nieghbours to even rows
if (idx//N) != 0 : # If it is not the first row
lat[idx]["neighbours"].append(idx-N) # Add neighbour to bottom right
if (idx%N) != 0: # If it is not the first cell in the row
lat[idx]["neighbours"].append(idx-N-1) # Add neighbour to the bottom left
elif periodic is True:
lat[idx]["neighbours"].append(idx-1) # Add neighbour to the bottom left (cyclic)
elif periodic is True:
if (idx%N) != 0 : # If it is not the first element on the first row
lat[idx]["neighbours"].append(Ny*(N-1)+idx) # Add neighbour to the bottom right (cyclic)
lat[idx]["neighbours"].append(Ny*(N-1)+idx-1) # Add neighbour to the bottom left (cyclic)
else: # If it is the first element of the first row
lat[idx]["neighbours"].append(Ny*(N-1)) # Add neighbour to the bottom right (cyclic)
lat[idx]["neighbours"].append(Ny*N-1) # Add neighbour to the bottom left (cyclic)
else: # It is an odd row
# Adding bottom nieghbours to even rows
lat[idx]["neighbours"].append(idx-N) # Add neighbour to bottom left
if (idx%N) != N-1: # If it is not the last cell in the row
lat[idx]["neighbours"].append(idx-N+1) # Add neighbour to the bottom right
elif periodic is True:
lat[idx]["neighbours"].append(idx-2*N+1) # Add neighbour to the bottom left (cyclic)
# Adding top neighbours for odd rows
if (idx//N) != N-1 : # If it is not the last row
lat[idx]["neighbours"].append(idx+N) # Add neighbour to top left
if (idx%N) != N-1: # If it is not the last cell in the row
lat[idx]["neighbours"].append(idx+N+1) # Add neighbour to the top right
elif periodic is True:
lat[idx]["neighbours"].append(idx+1) # Add neighbour to the top left
if periodic is True:
if (idx%N) != N-1: # If it is the last row but not the last element of the row
lat[idx]["neighbours"].append(idx%N) # Add neighbour to the top left (cyclic)
lat[idx]["neighbours"].append(idx%N + 1) # Add neighbour to the top right (cyclic)
else: # If it is the last element of the last row
lat[idx]["neighbours"].append(N-1) # Add neighbour to the top left
lat[idx]["neighbours"].append(0) # Add neighbour to the top left
idx = idx + 1 # Next cell
print("Done!")
return lat
def diffuse(lat, M, D, deg, dt, neighbourdist=1):
''' Diffusion of a spatial concentration M along a lattice lat.
Using a finite differences algorithm.
Note that this is not exactly the same as an extracellular diffusion
M --- vector with the values of the Diffusive substance
lat --- lattice to use for the diffusion (neighbour and position info)
D --- diffusion coefficient
dt --- integration timestep
deg --- the degradation rate
neighbourdist --- is the distance between neighbours
it can be set to "check" to look at the distance information in the the lattice
'''
N = np.zeros_like(M)
if neighbourdist != "check": # This will be the typical scenario
for idx in range(len(M)):
N[idx] = (sum(M[lat[idx]["neighbours"]])-len(lat[idx]["neighbours"])*M[idx])/(neighbourdist*neighbourdist)
elif neighbourdist == "check":
for idx in M:
for neighbour in lat[idx]["neighbours"]:
distx = abs(lat[cella]["xpos"]-lat[cellb]["xpos"])
disty = abs(lat[cella]["ypos"]-lat[cellb]["ypos"])
if periodic is True: # correct distances if toroidal boundary conditions are considered
distx = min(distx,Lx-distx)
disty = min(disty,Ly-disty)
dist2 = distx*distx + disty*disty # total Euclidean distance
N[idx] = (M[neighbour]-M[idx])/dist2
else:
print("Wrong argument for neighbourdist in diffuse")
return M + N * D * dt - deg * M * dt
def setleft(lat, M, value):
'''
Set all the values of cocentration matrix M at the left boundary to a certain value.
Useful to keep concentration constant for sinks and sources.
'''
for cell in lat:
if lat[cell]["mpos"][1] == 0:
M[cell] = value
return M
def setright(lat, M, value, lastcol = 'auto'):
''' identical to setleft but at the right column of the array'''
# set all the values of M at the left boundary to a certain value. Useful to keep concentration constant.
if lastcol == 'auto': # find automatically the right boundary
cols = [cell["mpos"][1] for cell in lat]
lastcol = max(cols)
for cell in lat:
if lat[cell]["mpos"][1] == lastcol:
M[cell] = value
return M
###############################################
############### PLOTTING FUNCTIONS
##############################################
def printlattice(lattice, M=[], geometry = "square", save = False, limcolor=[0,1], title = "None", titleoffset = 0, show = True, cmap = 'viridis'):
'''' plot a concentration matrix M on a lattice '''
positions = [(lattice[idx]["xpos"],lattice[idx]["ypos"]) for idx in lattice] # positions of the cells
Nsides = {"square": 4, "squarediag": 4, "hexagonal": 6} # number of sides of each cell
orientation = {"square": np.pi/4, "squarediag": np.pi/4, "hexagonal": 0} # rotation of each cell
fig, ax = plt.subplots(1) # creation of blank figure
sns.set_style("ticks") # seaborn styling (just for the look)
sns.set_context("talk")
sns.despine() # no mirror axis
ax.set_aspect('equal') # aspect ratio of the figure to keep proportions of polygons
newblack = sns.xkcd_rgb["charcoal"] # I like this black insetad of pure black
patch_list = [] # this list will contain all the polygonal shapes
for idx in lattice:
patch_list.append(
mpatches.RegularPolygon( # add a regular polygon
xy=positions[idx], # at a certain position
numVertices=Nsides[geometry], # with certain number of sides
radius=0.5/np.cos(np.pi/Nsides[geometry]), # with certain radius
orientation=orientation[geometry], # and a certain rotation
edgecolor=newblack, # and borders of color
)
)
pc = collections.PatchCollection(patch_list, match_original=True) # create a collection with the list
pc.set_clim(limcolor) # set the min and max values for the color scale
pc.set(array=M, cmap=cmap) # set a color for each polygon based on the given array M
ax.add_collection(pc) # add the collection to the plotting axis
if title != "None":
ax.text(np.sqrt(len(lattice))/2.0,np.sqrt(len(lattice))+titleoffset-1,title)
#print np.sqrt(len(lattice))/2.0,np.sqrt(len(lattice))
maxx = max([lattice[idx]["xpos"] for idx in lattice]) # maximum x position of the polygons
maxy = max([lattice[idx]["ypos"] for idx in lattice]) # maximum y position of the polygons
ax.axis([-1, maxx+1, -1, maxy+1]) # set axis range for the plot
cbb=fig.colorbar(pc) # create colorbar legend
if save is not False: # if the argument save is set to a string e.g. "figure.pdf"
plt.savefig(save) # it creates an output file
if show:
plt.show()
else:
plt.close(fig)
return ax
def printlattices(lattice, M=[], geometry = "square", save = False, limcolors=[[0,1]], title = "None", titleoffset = 0, show = True,
cmaps = ['viridis'],axisline=True, labels=None, cols = 1, timestamp = None):
'''
Plot an array of lattices for a list of concentration matrices M
'''
# cols is the number of columns to organize the plots
positions = [(lattice[idx]["xpos"],lattice[idx]["ypos"]) for idx in lattice] # positions of the cells
Nsides = {"square": 4, "squarediag": 4, "hexagonal": 6} # number of sides of each cell
orientation = {"square": np.pi/4, "squarediag": np.pi/4, "hexagonal": 0} # rotation of each cell
figxlen = 10
figylen = 6
fig = plt.figure(figsize = (figxlen,figylen)) # creation of figure
gs1 = gridspec.GridSpec((len(M)-1)//cols+1,cols, # gridspec for the matrices of diffusion
width_ratios=[1]*cols)
gs1.update(left = 0.05, right = figylen/figxlen-0.05, top = 0.95, bottom = 0.05, # location of the gridspec in the figure
wspace = 0.01)
axes = [plt.subplot(gs1[i//cols,i%cols]) for i in range(len(M))]
gs2 = gridspec.GridSpec(1,len(M), # gridspec for the colorbars
width_ratios=[1]*len(M))
gs2.update(left = figylen/figxlen, right = 0.90, top = 0.85, bottom = 0.25,
wspace = 3.0) # location of the gridspec in the figure
caxes = [plt.subplot(gs2[0,i]) for i in range(len(M))]
sns.set_style("ticks") # seaborn styling (just for the look)
sns.set_context("talk")
sns.despine() # no mirror axis
#ax.set_aspect('equal') # aspect ratio of the figure to keep proportions of polygons
newblack = sns.xkcd_rgb["almost black"] # I like this black insetad of pure black
for iax, ax in enumerate(axes):
if (axisline is False):
axes[iax].set_frame_on(False)
ax.set_aspect('equal') # aspect ratio of the axis to keep proportions of polygons
patch_list = [] # list will contain all the polygonal shapes
for idx in lattice:
patch_list.append(
mpatches.RegularPolygon( # add a regular polygon
xy = positions[idx], # at a certain position
numVertices = Nsides[geometry], # with certain number of sides
radius = 0.5/np.cos(np.pi/Nsides[geometry]), # with certain radius
orientation = orientation[geometry], # and a certain rotation
edgecolor = newblack, # and borders of color
linewidth = 2.0
)
)
pc = collections.PatchCollection(patch_list, match_original=True) # create a collection with the list
if len(cmaps)>1:
cmap = cmaps[iax]
else:
cmap = cmaps[0]
pc.set(array=M[iax], cmap=cmap) # set a color for each polygon based on the given array M
pc.set_clim(limcolors[iax]) # set the min and max values for the color scale
ax.add_collection(pc) # add the collection to the plotting axis
if (title != "None" and iax==0):
ax.text(np.sqrt(len(lattice))/2.0,np.sqrt(len(lattice))/4.0+titleoffset-1,title)
#print np.sqrt(len(lattice))/2.0,np.sqrt(len(lattice))
# if iax == 0:
ax.set_title(labels[iax])
ax.get_yaxis().set_visible(False)
maxx = max([lattice[idx]["xpos"] for idx in lattice]) # maximum x position of the polygons
maxy = max([lattice[idx]["ypos"] for idx in lattice]) # maximum y position of the polygons
ax.axis([-1, maxx+1, -1, maxy+1]) # set axis range for the plot
ax.yaxis.set_major_formatter(plt.NullFormatter())
ax.spines['left'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.xaxis.set_ticks([])
#colorbarticks = range(int(np.floor(limcolors[iax][0])),int(np.ceil(limcolors[iax][1])+1))
#colorlabelticks = ['$10^{{ {} }}$'.format(t) for t in colorbarticks]
cbb = fig.colorbar(pc, cax = caxes[iax],aspect = 100) # create colorbar legend
#cbb.set_ticks(colorbarticks)
#cbb.set_ticklabels(colorlabelticks)
#cbb.outline.set_visible(False)
if labels:
caxes[iax].text(0,-0.1,labels[iax], transform=caxes[iax].transAxes, size =15)
if timestamp:
caxes[1].text(0,-0.25,'time = {0:.2f} h'.format(float(timestamp)),transform=caxes[1].transAxes)
plt.tight_layout()
if save is not False: # if the argument save is set to a string e.g. "figure.pdf"
plt.savefig(save,dpi=200) # it creates an output file
if show:
plt.show()
else:
plt.close(fig)
return ax
def printlattices_comp(lattice, M=[], geometry = "square", save = False, limcolors=[[0,1]], title = "None", titleoffset = 0, show = True,
cmaps = ['viridis'],axisline=True, labels=None, cols = 1, timestamp = None):
# cols is the number of columns to organize the plots
positions = [(lattice[idx]["xpos"],lattice[idx]["ypos"]) for idx in lattice] # positions of the cells
Nsides = {"square": 4, "squarediag": 4, "hexagonal": 6} # number of sides of each cell
orientation = {"square": np.pi/4, "squarediag": np.pi/4, "hexagonal": 0} # rotation of each cell
# N_cbars is the number of colorbars
# N_cbars = [icmap for icmap,x in enumerate(cmaps) if x!='custom']
figxlen = 12
figylen = 5
fig = plt.figure(figsize = (figxlen,figylen)) # creation of figure
gs1 = gridspec.GridSpec((len(M)-1)//cols,cols, # gridspec for the matrices of diffusion
width_ratios=[1]*cols)
gs1.update(left = 0.05, right = figylen/figxlen-0.05, top = 0.95, bottom = 0.05, # location of the gridspec in the figure
wspace = 0.01)
axes = [plt.subplot(gs1[i//cols,i%cols]) for i in range(len(M)-1)]
# print('axes',axes)
gs2 = gridspec.GridSpec(1,1, # gridspec for the matrices of diffusion
width_ratios=[1])
gs2.update(left = figylen/figxlen-0.04, right = 2*figylen/figxlen, top = 0.95, bottom = 0.05, # location of the gridspec in the figure
wspace = 0.01)
mixaxes = plt.subplot(gs2[0,0])
# print('mixaxes',mixaxes)
diffaxes = axes
diffaxes.append(mixaxes) # this is a list containing all the axes with a diffusion array
# print('diffaxes',diffaxes)
gs3 = gridspec.GridSpec(1,2, # gridspec for the colorbars
width_ratios=[1]*2)
gs3.update(left = 2*figylen/figxlen, right = 0.92, top = 0.85, bottom = 0.25,
wspace = 4.0) # location of the gridspec in the figure
caxes = [plt.subplot(gs3[0,i]) for i in range(2)] # axes for the colorbars
sns.set_style("ticks") # seaborn styling (just for the look)
sns.set_context("talk")
sns.despine() # no mirror axis
#ax.set_aspect('equal') # aspect ratio of the figure to keep proportions of polygons
newblack = sns.xkcd_rgb["almost black"] # I like this black insetad of pure black
for iax, ax in enumerate(diffaxes):
if (axisline is False):
axes[iax].set_frame_on(False)
ax.set_aspect(1.0) # aspect ratio of the figure to keep proportions of polygons
patch_list = [] # list will contain all the polygonal shapes
if iax==(len(M)-1): # bigger plot, bigger lines
customlinewidth = 3.5
else:
customlinewidth = 2.5
for idx in lattice:
patch_list.append(
mpatches.RegularPolygon( # add a regular polygon
xy = positions[idx], # at a certain position
numVertices = Nsides[geometry], # with certain number of sides
radius = 0.5/np.cos(np.pi/Nsides[geometry]), # with certain radius
orientation = orientation[geometry], # and a certain rotation
edgecolor = newblack, # and borders of color
linewidth = customlinewidth
)
)
pc = collections.PatchCollection(patch_list, match_original=True) # create a collection with the list
if len(cmaps)>1:
cmap = cmaps[iax]
else:
cmap = cmaps[0]
if cmap == 'custom': # if 'custom' then the array M contains the RGBA tuples, otherwhise is a cmap coordinate
pc.set_facecolor(M[iax]) # set a color for each polygon based on the given array M
else:
pc.set(array=M[iax], cmap=cmap) # set a color for each polygon based on the given array M
pc.set_clim(limcolors[iax]) # set the min and max values for the color scale
ax.add_collection(pc) # add the collection to the plotting axis
if (title != "None" and iax==0):
ax.text(np.sqrt(len(lattice))/2.0,np.sqrt(len(lattice))/4.0+titleoffset-1,title)
#print np.sqrt(len(lattice))/2.0,np.sqrt(len(lattice))
# if iax == 0:
ax.set_title(labels[iax])
ax.get_yaxis().set_visible(False)
maxx = max([lattice[idx]["xpos"] for idx in lattice]) # maximum x position of the polygons
maxy = max([lattice[idx]["ypos"] for idx in lattice]) # maximum y position of the polygons
ax.axis([-1, maxx+1, -1, maxy+1]) # set axis range for the plot
ax.yaxis.set_major_formatter(plt.NullFormatter())
ax.spines['left'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.xaxis.set_ticks([])
#colorbarticks = range(int(np.floor(limcolors[iax][0])),int(np.ceil(limcolors[iax][1])+1))
#colorlabelticks = ['$10^{{ {} }}$'.format(t) for t in colorbarticks]
if cmap!= 'custom':
cbb = fig.colorbar(pc, cax = caxes[iax]) # create colorbar legend
#cbb.set_ticks(colorbarticks)
#cbb.set_ticklabels(colorlabelticks)
#cbb.outline.set_visible(False)
if labels:
caxes[iax].text(0,-0.1,labels[iax], transform=caxes[iax].transAxes, size =15)
if timestamp:
caxes[0].text(0,-0.25,'time = {0:.2f} h'.format(float(timestamp)),transform=caxes[0].transAxes)
plt.tight_layout()
if save is not False: # if the argument save is set to a string e.g. "figure.pdf"
plt.savefig(save,dpi=200) # it creates an output file
if show:
plt.show()
else:
plt.close(fig)
return ax
##################################################
############################ MOVIE OF LATTICES
###################################################
def initlatticemovie(lattice):
global figg, axg, caxg, newblack, movieframes
figg = plt.figure() # creation of blank figure
axg = figg.add_subplot(121) # main axes
caxg = figg.add_subplot(121) # colorbar axes
sns.set_style("ticks") # seaborn styling (just for the look)
sns.set_context("talk")
sns.despine() # no mirror axis
axg.set_aspect('equal') # aspect ratio of the figure to keep proportions of polygons
newblack = sns.xkcd_rgb["charcoal"] # I like this black insetad of pure black
maxx = max([lattice[idx]["xpos"] for idx in lattice]) # maximum x position of the polygons
maxy = max([lattice[idx]["ypos"] for idx in lattice]) # maximum y position of the polygons
axg.axis([-1, maxx+1, -1, maxy+1]) # set axis range for the plot
movieframes = [] # this list will contain the info of every frame
def addlatticeframe(lattice, M=[], geometry = "square", save = False, limcolor=[0,1], cmap = 'viridis'):
global pc
positions = [(lattice[idx]["xpos"],lattice[idx]["ypos"]) for idx in lattice] # positions of the cells
Nsides = {"square": 4, "squarediag": 4, "hexagonal": 6} # number of sides of each cell
orientation = {"square": np.pi/4, "squarediag": np.pi/4, "hexagonal": 0} # rotation of each cell
patch_list = [] # this list will contain all the polygonal shapes
for idx in lattice:
patch_list.append(
mpatches.RegularPolygon( # add a regular polygon
xy=positions[idx], # at a certain position
numVertices=Nsides[geometry], # with certain number of sides
radius=0.5/np.cos(np.pi/Nsides[geometry]), # with certain radius
orientation=orientation[geometry], # and a certain rotation
edgecolor=newblack # and borders of color
)
)
pc = collections.PatchCollection(patch_list, match_original=True) # create a collection with the list
pc.set(array=M, cmap=cmap) # set a color for each polygon based on the given array M
pc.set_clim(limcolor) # set the min and max values for the color scale
frame = axg.add_collection(pc) # add the collection to the plotting axis and save the artist in frame
movieframes.append((frame,))
print("frames: ", len(movieframes))
if save is not False: # if the argument save is set to a string e.g. "figure.pdf"
plt.savefig(save) # it creates an output file
return frame
def makelatticemovie():
global pc
cbb=figg.colorbar(pc) # create colorbar legend
animation.ArtistAnimation(figg, movieframes, interval=1, blit=False, repeat_delay=30)
anim.save('latticemoving.mp4')
# plt.show()
|
def ascii_encrypt(pt):
r=""
for i in range(len(pt)): r+=chr(ord(pt[i])+i)
return r
def ascii_decrypt(pt):
r=""
for i in range(len(pt)): r+=chr(ord(pt[i])-i)
return r |
import warnings
from datetime import datetime
from decimal import Decimal
from ipaddress import IPv4Address, IPv6Address
from typing import cast, TypeVar, Generic, Optional
from uuid import UUID
from dateutil.parser import parse
from .type_defs import JsonEncodable, JsonDict
T = TypeVar('T')
OutType = TypeVar('OutType', bound=JsonEncodable)
class FieldEncoder(Generic[T, OutType]):
"""Base class for encoding fields to and from JSON encodable values"""
def to_wire(self, value: T) -> OutType:
return cast(OutType, value)
def to_python(self, value: OutType) -> T:
return cast(T, value)
@property
def json_schema(self) -> JsonDict:
raise NotImplementedError()
class DateTimeFieldEncoder(FieldEncoder[datetime, str]):
"""Encodes datetimes to RFC3339 format"""
def to_wire(self, value: datetime) -> str:
out = value.isoformat()
# Assume UTC if timezone is missing
if value.tzinfo is None:
warnings.warn("Naive datetime used, assuming utc")
return out + "Z"
return out
def to_python(self, value: str) -> datetime:
return value if isinstance(value, datetime) else parse(cast(str, value))
@property
def json_schema(self) -> JsonDict:
return {"type": "string", "format": "date-time"}
# Alias for backwards compat
DateTimeField = DateTimeFieldEncoder
class UuidField(FieldEncoder[UUID, str]):
def to_wire(self, value: UUID) -> str:
return str(value)
def to_python(self, value: str) -> UUID:
return UUID(value)
@property
def json_schema(self):
return {
'type': 'string',
'format': 'uuid',
'pattern': '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
}
class DecimalField(FieldEncoder[Decimal, float]):
def __init__(self, precision: Optional[int] = None):
self.precision = precision
def to_wire(self, value: Decimal) -> float:
return float(value)
def to_python(self, value: float) -> Decimal:
return Decimal(str(value))
@property
def json_schema(self):
schema = {'type': 'number'}
if self.precision is not None and self.precision > 0:
schema['multipleOf'] = float('0.' + '0' * (self.precision - 1) + '1')
return schema
class IPv4AddressField(FieldEncoder[IPv4Address, str]):
def to_wire(self, value: IPv4Address) -> str:
return str(value)
def to_python(self, value: str) -> IPv4Address:
return IPv4Address(value)
@property
def json_schema(self):
return {'type': 'string', 'format': 'ipv4'}
class IPv6AddressField(FieldEncoder[IPv6Address, str]):
def to_wire(self, value: IPv6Address) -> str:
return str(value)
def to_python(self, value: str) -> IPv6Address:
return IPv6Address(value)
@property
def json_schema(self):
return {'type': 'string', 'format': 'ipv6'}
|
def start(job):
gateway = job.service.parent.consumers['gateway'][0]
gwdata = gateway.model.data.to_dict()
cloudinit = config_cloud_init(job, gwdata.get("nics", []))
if not cloudinit.is_running():
cloudinit.start()
def config_cloud_init(job, nics=None):
import yaml
import json
from zeroos.orchestrator.sal.gateway.cloudinit import CloudInit
from zeroos.orchestrator.sal.Container import Container
from zeroos.orchestrator.configuration import get_jwt_token
service = job.service
job.context['token'] = get_jwt_token(service.aysrepo)
container = Container.from_ays(job.service.parent, job.context['token'], logger=job.service.logger)
nics = nics or []
config = {}
for nic in nics:
if not nic.get("dhcpserver"):
continue
for host in nic["dhcpserver"].get("hosts", []):
if host.get("cloudinit"):
if host["cloudinit"]["userdata"] and host["cloudinit"]["metadata"]:
userdata = yaml.load(host["cloudinit"]["userdata"])
metadata = yaml.load(host["cloudinit"]["metadata"])
config[host['macaddress'].lower()] = json.dumps({
"meta-data": metadata,
"user-data": userdata,
})
cloudinit = CloudInit(container, config)
if config != {}:
cloudinit.apply_config()
return cloudinit
def update(job):
config_cloud_init(job, job.model.args["nics"])
def watchdog_handler(job):
import asyncio
from zeroos.orchestrator.configuration import get_jwt_token
service = job.service
job.context['token'] = get_jwt_token(service.aysrepo)
loop = j.atyourservice.server.loop
gateway = job.service.parent.consumers['gateway'][0]
if gateway.model.data.status == 'running':
asyncio.ensure_future(job.service.asyncExecuteAction('start', context=job.context), loop=loop)
|
import random, sys
sys.setrecursionlimit(2000)
grille = [[0] * 20 for i in range(20)]
pos = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
revele = [[0] * 20 for i in range(20)]
# functions
def output(g):
for col in g: print(" ".join(map(str, col)))
def bombe():
x = random.randint(0, 19)
y = random.randint(0, 19)
grille[y][x] = "*"
number(x, y)
def number(x, y):
for c in pos:
try:
if grille[y + c[0]][x + c[1]] != "*":
grille[y + c[0]][x + c[1]] += 1
except:
pass
def onclick(x, y):
try:
if grille[y][x] == "*":
output()
print("perdu")
return 0
if grille[y][x] != 0:
revele[y][x] = 1
return 1
grille[y][x] = "@"
revele[y][x] = 1
for c in pos:
onclick(x + c[0], y + c[1])
except:
pass
def main():
for loop in range(int(20 * 20 * 0.15)):
bombe()
output(grille)
print()
m = onclick(14, 13)
if m or m==None:
output(revele)
|
# Copyright 2016 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Classes to enumerate basic network data from WMI.
Unlike some system elements (eg hardware), network state is prone to changing
regularly and dynamically. There are also associations between much of the
data: for example, each IP address and MAC are associated with a single NIC. It
would be chaotic to return the MAC address from one NIC with the IP address
from another.
To resolve these concerns, the network state is polled in batch via a call to
Poll(). This represents a "snapshot" of the current network state. This avoids
the possibility that multiple consecutive WMI queries will return the interfaces
in different orders, thereby confusing the variable associations.
"""
import logging
import re
import socket
import subprocess
from gwinpy.wmi import wmi_query
class NetInterface(object):
"""Stores all settings for a single interface."""
def __init__(self,
default_gateway=None,
description=None,
dhcp_server=None,
dns_domain=None,
ip_address=None,
mac_address=None):
self.default_gateway = default_gateway
self.description = description
self.dhcp_server = dhcp_server
self.dns_domain = dns_domain
self.ip_address = ip_address
self.mac_address = mac_address
class NetInfo(object):
"""Query basic network data in WMI."""
def __init__(self, active_only=True, poll=True):
self._wmi = wmi_query.WMIQuery()
self._interfaces = []
if poll:
self.Poll(active_only)
def _CheckIfIpv4Address(self, ip_address):
"""Checks if an input string is an IPv4 address.
Args:
ip_address: The input string to check.
Returns:
True if the input is an IPv4 address, else False.
"""
try:
socket.inet_aton(ip_address) # pylint:disable=g-socket-inet-aton
except socket.error:
return False
# socket.inet_aton will pad zeroes onto a string like '192.168' when
# validating, so check to make sure there are four parts in the address
if len(ip_address.split('.')) == 4:
return True
return False
def DefaultGateways(self, v4_only=False):
"""Get all default gateways from Win32_NetworkAdapterConfiguration.
Args:
v4_only: Only store gateways which appear to be valid IPv4 addresses.
Returns:
A list of default gateways.
"""
default_gateways = []
for interface in self._interfaces:
if interface.default_gateway:
gateway = interface.default_gateway
if v4_only and not self._CheckIfIpv4Address(str(gateway)):
continue
default_gateways.append(gateway)
return default_gateways
def Descriptions(self):
"""Get all interface descriptions from Win32_NetworkAdapterConfiguration.
Returns:
A list of interface descriptions.
"""
descriptions = []
for interface in self._interfaces:
if interface.description:
descriptions.append(interface.description)
return descriptions
def DhcpServers(self):
"""Get all DHCP servers from Win32_NetworkAdapterConfiguration.
Returns:
A list of DHCP servers.
"""
dhcp_servers = []
for interface in self._interfaces:
if interface.dhcp_server:
dhcp_servers.append(interface.dhcp_server)
return dhcp_servers
def DnsDomains(self):
"""Get all dns domains from Win32_NetworkAdapterConfiguration.
Returns:
A list of dns domains.
"""
dns_domains = []
for interface in self._interfaces:
if interface.dns_domain:
dns_domains.append(interface.dns_domain)
return dns_domains
def _GetNetConfigs(self, active_only=True):
"""Retrieves the network adapter configuration from local NICs.
Active NICs are defined as interfaces where the nic is enabled, dhcp is
enabled, and the DNS domain is not null.
Args:
active_only: only retrieve configuration from "active" NICs
"""
query = 'Select * from Win32_NetworkAdapterConfiguration'
if active_only:
query += (' where IPEnabled=true and DHCPEnabled=true and'
' DNSDomain is not null')
results = self._wmi.Query(query)
if results:
for interface in results:
found_int = NetInterface()
if (hasattr(interface, 'DefaultIPGateway') and
interface.DefaultIPGateway):
found_int.default_gateway = interface.DefaultIPGateway
if hasattr(interface, 'Description') and interface.Description:
found_int.description = interface.Description
if hasattr(interface, 'DHCPServer') and interface.DHCPServer:
found_int.dhcp_server = interface.DHCPServer
if hasattr(interface, 'DNSDomain') and interface.DNSDomain:
found_int.dns_domain = interface.DNSDomain
if hasattr(interface, 'IPAddress') and interface.IPAddress:
found_int.ip_address = interface.IPAddress[0]
if hasattr(interface, 'MACAddress') and interface.MACAddress:
found_int.mac_address = interface.MACAddress
self._interfaces.append(found_int)
else:
logging.warning('No results for %s.', query)
def _GetPtrRecord(self, ip_address, domain='.com'):
"""Gets the DNS PTR record for an IPv4 address.
Args:
ip_address: The IP address string to check the PTR record for.
domain: The parent domain of expected pointer records.
Returns:
A string containing the FQDN of the IP address, or None if not found.
"""
logging.debug('Checking PTR record for %s.', ip_address)
subproc = subprocess.Popen(
'nslookup -type=PTR %s' % ip_address,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
output, unused_error = subproc.communicate()
hostname = '([a-zA-Z0-9.-]+%s)' % domain.replace('.', r'\.')
result = re.search(r'name = %s' % hostname, output)
if result:
return result.group(1)
return None
def Interfaces(self):
"""Get all interfaces.
Returns:
All interfaces as a list of NetInterface objects
"""
return self._interfaces
def IpAddresses(self):
"""Get all IP Addresses from Win32_NetworkAdapterConfiguration.
Returns:
A list of local IP Addresses.
"""
ip_addresses = []
for interface in self._interfaces:
if interface.ip_address:
ip_addresses.append(interface.ip_address)
return ip_addresses
def MacAddresses(self):
"""Get all mac addresses from Win32_NetworkAdapterConfiguration.
Active NICs are defined as interfaces where the nic is enabled, dhcp is
enabled, and the DNS domain is not null.
Returns:
A list of mac addresses.
"""
mac_addresses = []
for interface in self._interfaces:
if interface.mac_address:
mac_addresses.append(interface.mac_address)
return mac_addresses
def Poll(self, active_only=True):
"""Poll all network interfaces for current state.
Active NICs are defined as interfaces where the nic is enabled, dhcp is
enabled, and the DNS domain is not null.
Args:
active_only: only retrieve configuration from "active" NICs
"""
self._interfaces = []
self._GetNetConfigs(active_only=active_only)
|
from sys import maxsize
class Contact:
def __init__(self, F_name=None, L_name=None, C_address=None, all_phones_from_home_page=None,
H_phone=None, W_phone=None, M_phone=None, S_phone=None, C_email=None, C_email2=None, C_email3=None, all_emails_from_home_page=None, id=None):
self.fn = F_name
self.ln = L_name
self.c_add = C_address
self.all_phones_from_home_page = all_phones_from_home_page
self.h_phone = H_phone
self.w_phone = W_phone
self.m_phone = M_phone
self.s_phone = S_phone
self.c_email = C_email
self.c_email2 = C_email2
self.c_email3 = C_email3
self.all_emails_from_home_page = all_emails_from_home_page
self.id = id
# representation. стандартная функция, позволяющая определить как выглядит объект при выводе на консоль. для того, чтобы было понятно что в ошибках сравнения.
def __repr__(self):
return "%s, %s, %s" % (self.id, self.fn, self.ln)
# equals. стандартная функция, которая принимает в качестве второго параметра объект, с которым нужно сравнить объект self. Чтобы сравнивались объекты без учета того где они лежат в памяти.
def __eq__(self, other):
return (self.id is None or other.id is None or self.id == other.id) and self.ln == other.ln and self.fn == other.fn
# вычисляет айди контакта по контакту. если айди есть - возвращает айди, если айди нет - возвращает максимальное целое число.
def id_or_max(self):
if self.id:
return int(self.id)
else:
return maxsize
|
from .codec import Codec, codecs_available, codec_descriptor
from .context import CodecContext, HWDeviceContext, HWFramesContext
|
db = [
{}
]
companyTools = [
{
"name" : "LittleBrother",
"commandLine" : "littleBrother $1",
"args" : [["phone", "email", "name", "address", "username"], ]
},
{}
]
class OSINTAttacker():
def __init__(self):
pass
def act(self, gameState):
pass
class OSINTGameSettings:
def __init__(self):
self.unitPunition = 1
self.tools = companyTools
class OSINTGame:
def __init__(self, attacker, database, settings=OSINTGameSettings()):
self.attacker = attacker
self.database = database
self.stepHooks = []
self.endHooks = []
self.settings = settings
self.state = OSINTGameState(self)
def getAttackState(self):
return AttackerGameState(self)
def gameEnd(self):
self.defender.score -= self.settings.defUnitPunition * self.state.elapsedTime
self.state.gameOverRecorded = True
for hook in self.endHooks:
hook()
def isGameOver(self):
#print(self.network.totalPwnValue(), self.network.totalValue(), self.settings.nodePwnThreshold, self.state.attackDetected)
return \
self.network.totalPwnValue() / self.network.totalValue() \
>= \
self.settings.nodePwnThreshold \
or \
self.state.attackDetected == True
def defenseStep(self):
action = self.defender.act(self.getDefenseState())
self.registerDefense(action)
if random.randrange(100) < self.settings.inspectGameFrequencyDef:
self.network.display()
print(self.network.isPlayable())
def attackStep(self):
action = self.attacker.act(self.getAttackState())
self.registerAttack(action)
self.state.elapsedTime += 1
if random.randrange(100) < self.settings.inspectGameFrequencyAtq:
self.network.display()
def addStepHook(self, hook):
self.stepHooks.append(hook)
def addEndHook(self, hook):
self.endHooks.append(hook)
def run(self):
while not self.state.defenderIsDone:
self.defenseStep()
print("Defender is done, score : ", self.defender.score)
#self.network.display()
#print("Is game already over", self.isGameOver())
while not self.isGameOver() :
self.attackStep()
for hook in self.stepHooks:
hook(self.state)
print("Attacker is done, score : ", self.attacker.score)
self.gameEnd()
return self.state
def registerAttack(self, action):
if action["type"] == "attack":
attackedNode = self.network.findNodeFromAttacker(action["target"])
if attackedNode.defense[action["vector"]] > attackedNode.atqVectors[action["vector"]]:
attackedNode.isPwned = True
if random.randrange(100) < attackedNode.defense[action["vector"]]:
self.state.attackDetected = True
self.attacker.score -= self.settings.attackerDetectedPunition
self.defender.score += self.settings.attackerDetectedReward
else:
attackedNode.atqVectors[action["vector"]] += random.randint(0, self.settings.maxAtqPower)
self.attacker.score -= self.settings.attackCost
else:
raise RuntimeError("No such action " + action["type"] + " !")
class OSINTGameState:
def __init__(self, game):
self.elapsedTime = 0
self.gameOverRecorded = False
self.network = game.network
self.attackDetected = False
self.defenderIsDone = False
class AttackerGameState():
def __init__(self, game):
pass
def attack(self, node, vector):
return {"type": "attack", "target": node, "vector": vector} |
#!/bin/env python3
# -*- coding: utf-8 -*-
import unittest
import os
from conftl.render_fn import render
from conftl._compat import PY2
import codecs
TMP = '/tmp'
class TestRenderFunction(unittest.TestCase):
def testContent(self):
content = "X"
self.assertEqual(render(content=content), "X")
def testContext(self):
content = "{{=i}}"
context = dict(i=300)
self.assertEqual(render(content=content, context=context), "300")
def testDelimiters(self):
content = "[[True]]"
self.assertEqual(render(content=content, delimiters="[[ ]]"), "")
def testInfile(self):
tmpl = "X"
expected_output = "X"
infile = os.path.join(TMP, 'infile_%s.tmpl' % (os.getpid()))
with open(infile, 'w') as f:
f.write(tmpl)
output = render(infile)
os.remove(infile)
self.assertEqual(output, expected_output)
def testInfileUnicode(self):
tmpl = "Тодор"
if PY2:
tmpl = tmpl.decode('utf-8')
expected_output = tmpl
infile = os.path.join(TMP, 'infileunicode_%s.tmpl' % (os.getpid()))
with codecs.open(infile, 'w', 'utf-8') as f:
f.write(tmpl)
output = render(infile)
os.remove(infile)
self.assertEqual(output, expected_output)
def testPath(self):
tmpl = "X"
expected_output = "X"
infile = os.path.join(TMP, 'infile_%s.tmpl' % (os.getpid()))
with open(infile, 'w') as f:
f.write(tmpl)
output = render(infile, path=[TMP])
os.remove(infile)
self.assertEqual(output, expected_output)
def testOutfile(self):
tmpl = "X"
expected_output = "X"
outfile = os.path.join(TMP, 'outfile_%s.tmpl' % (os.getpid()))
render(content=tmpl, outfile=outfile)
with open(outfile, 'r') as f:
output = f.read()
os.remove(outfile)
self.assertEqual(output, expected_output)
def testOutfileUnicode(self):
tmpl = "Тодор"
expected_output = "Тодор"
outfile = os.path.join(TMP, 'outfile_%s.tmpl' % (os.getpid()))
render(content=tmpl, outfile=outfile)
with open(outfile, 'r') as f:
output = f.read()
os.remove(outfile)
self.assertEqual(output, expected_output)
def testEmptyInput(self):
with self.assertRaises(RuntimeError):
render()
if __name__ == '__main__':
unittest.main()
|
"""
A set of standard EA problems that rely on a binary-representation
"""
import numpy as np
from PIL import Image, ImageOps
from leap_ec.problem import ScalarProblem
##############################
# Class MaxOnes
##############################
class MaxOnes(ScalarProblem):
"""
Implementation of MAX ONES problem where the individuals are represented
by a bit vector
We don't need an encoder since the raw genome is *already* in the
phenotypic space.
"""
def __init__(self, maximize=True):
"""
Create a MAX ONES problem with individuals that have bit vectors of
size `length`
"""
super().__init__(maximize)
def evaluate(self, phenome):
"""
>>> from leap_ec.individual import Individual
>>> from leap_ec.decoder import IdentityDecoder
>>> p = MaxOnes()
>>> ind = Individual([0, 0, 1, 1, 0, 1, 0, 1, 1],
... decoder=IdentityDecoder(),
... problem=p)
>>> p.evaluate(ind.decode())
5
"""
return phenome.count(1)
##############################
# Class ImageProblem
##############################
class ImageProblem(ScalarProblem):
"""A variation on `max_ones` that uses an external image file to define a
binary target pattern. """
def __init__(self, path, maximize=True, size=(100, 100)):
super().__init__(maximize)
self.size = size
self.img = ImageProblem._process_image(path, size)
self.flat_img = np.ndarray.flatten(np.array(self.img))
@staticmethod
def _process_image(path, size):
"""Load an image and convert it to black-and-white."""
x = Image.open(path)
x = ImageOps.fit(x, size)
return x.convert('1')
def evaluate(self, phenome):
assert (len(phenome) == len(self.flat_img)
), f"Bad genome length: got {len(phenome)}, expected " \
f"{len(self.flat_img)} "
diff = np.logical_not(phenome ^ self.flat_img)
return sum(diff)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.