def __init__(self, name, tables):
"""init Chains object"""
UserDict.__init__(self)
self.name = name
self.tables = tables
self.predef = tables
self.reset() # name, tables)
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<4f3f'
self.__size__ = struct.calcsize(self.__format__)
self['quat'] = [None, None, None, None]
self['position'] = [None, None, None]
def __init__(self,
taskmanager_id,
state="NEW",
generation_id=None,
generation_time=None,
missed_update_count=0):
"""
Initialize Metadata object
:type taskmanager_id: :obj:`string`
:type state: :obj:`string`
:type generation_id: :obj:`int`
:type generation_time: :obj:`float`
:type missed_update_count: :obj:`int`
"""
UserDict.__init__(self)
if state not in Metadata.valid_states:
structlog.getLogger(LOGGERNAME).exception(
f"Invalid Metadata state: {state}")
raise InvalidMetadataError()
if not generation_time:
generation_time = time.time()
self.data = {
"taskmanager_id": taskmanager_id,
"state": state,
"generation_id": generation_id,
"generation_time": int(generation_time),
"missed_update_count": missed_update_count,
}
def __init__(self, cellbase_dict):
"""Initialise a ClinVar record object from JSON data. See /clinvar-variant-types/README.md for the in-depth
explanation of ClinVar data model. See also issue https://github.com/EBIvariation/eva-opentargets/issues/127
for the most recent discussions on changing support of different ClinVar record types.
"""
UserDict.__init__(self, cellbase_dict)
if 'measureSet' in self.data['referenceClinVarAssertion']:
# MeasureSet provides information on a variant or a set of variants located on the same chromosomal copy.
if self.data['referenceClinVarAssertion']['measureSet'][
'type'] == 'Variant':
# The measure "list" actually only contains a single variant. This is the only case we are currently
# supporting. As of July 2020, it accounts for >99.7% of all ClinVar records.
measure_list = self.data['referenceClinVarAssertion'][
'measureSet']['measure']
else:
# Uncommon record types, such as "Haplotype", "Phase unknown", or "Distinct chromosomes".
# Not currently supported.
measure_list = []
elif 'measureSet' in self.data['referenceClinVarAssertion'][
'genotypeSet']:
# The record contains a GenotypeSet, a rare subtype which contains an assertion about a group of variants
# from several chromosome copies. This could be either a CompoundHeterozygote or a Diplotype, and those
# types are currently not processed.
measure_list = []
else:
raise KeyError(
'ClinVar record contains neither a MeasureSet, nor a GenotypeSet'
)
self.measures = [
ClinvarRecordMeasure(measure_dict, self)
for measure_dict in measure_list
]
def __init__(self, model, query_parameters, *args, **kwargs):
self._model = model
# Core options, not modifiable by client updates
if 'columns' not in kwargs:
model_fields = model._meta.local_fields
kwargs['columns'] = list(map(lambda f: (six.text_type(f.verbose_name), f.name), model_fields))
if 'hidden_columns' not in kwargs or kwargs['hidden_columns'] is None:
kwargs['hidden_columns'] = []
if 'search_fields' not in kwargs or kwargs['search_fields'] is None:
kwargs['search_fields'] = []
if 'unsortable_columns' not in kwargs or kwargs['unsortable_columns'] is None:
kwargs['unsortable_columns'] = []
# Absorb query GET params
kwargs = self._normalize_options(query_parameters, kwargs)
UserDict.__init__(self, DEFAULT_OPTIONS, *args, **kwargs)
self._flat_column_names = []
for column in self['columns']:
column = get_field_definition(column)
flat_name = column.pretty_name
if column.fields:
flat_name = column.fields[0]
self._flat_column_names.append(flat_name)
def __init__(self, model, query_parameters, *args, **kwargs):
self._model = model
# Core options, not modifiable by client updates
if 'columns' not in kwargs:
model_fields = model._meta.local_fields
kwargs['columns'] = list(
map(lambda f: (six.text_type(f.verbose_name), f.name),
model_fields))
if 'hidden_columns' not in kwargs or kwargs['hidden_columns'] is None:
kwargs['hidden_columns'] = []
if 'search_fields' not in kwargs or kwargs['search_fields'] is None:
kwargs['search_fields'] = []
if 'unsortable_columns' not in kwargs or kwargs[
'unsortable_columns'] is None:
kwargs['unsortable_columns'] = []
# Absorb query GET params
kwargs = self._normalize_options(query_parameters, kwargs)
UserDict.__init__(self, DEFAULT_OPTIONS, *args, **kwargs)
self._flat_column_names = []
for column in self['columns']:
column = get_field_definition(column)
flat_name = column.pretty_name
if column.fields:
flat_name = column.fields[0]
self._flat_column_names.append(flat_name)
def __init__(self):
UserDict.__init__(self)
self.update({
"order": 8,
"sigma": 2,
"adaptLengthInRegime": True,
"meanThresholdMethod": thresholdOtsu,
"meanThreshold": None,
"mask": None,
"nlmsMask": None,
"nlmsThreshold": None,
"useParallelPool": True,
"maskDilationDiskRadius": 3,
"maskFillHoles": False,
"diagnosticMode": False,
"K_sampling_delta": 0.1,
"responseOrder": 3,
"bridgingLevels": 2,
"suppressionValue": 0,
"filter": False, #OrientationSpaceFilter(),
"response": False, #OrientationSpaceResponse(),
"maxima_highest": np.empty(0),
"K_highest": np.empty(0),
"bridging": np.empty(0),
"nlms_highest": np.empty(0),
"nlms_single": np.empty(0),
})
def __init__(self, turn, data):
UserDict.__init__(self, data)
self._turn = turn
self._fmt_str = None
if 'ownerid' in self.data:
self.data['owner'] = self._turn.find_component(
'players', self.data['ownerid'])
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<32si'
self.__size__ = struct.calcsize(self.__format__)
self['boneName'] = None
self['boneType'] = None
def __init__(self,schema,dn,entry):
self._keytuple2attrtype = {}
self._attrtype2keytuple = {}
self._s = schema
self.dn = dn
UserDict.__init__(self,{})
self.update(entry)
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<4f3f'
self.__size__ = struct.calcsize(self.__format__)
self['quat'] = [None, None, None, None]
self['position'] = [None, None, None]
def __init__(self,
taskmanager_id,
create_time=None,
expiration_time=None,
scheduled_create_time=None,
creator='module',
schema_id=None):
"""
Initialize Header object
:type taskmanager_id: :obj:`string`
:type create_time: :obj:`float`
:type expiration_time: :obj:`float`
:type scheduled_create_time: :obj:`float`
:type creator: :obj:`string`
:type schema_id: :obj:`int`
"""
UserDict.__init__(self)
if not create_time:
create_time = time.time()
if not expiration_time:
expiration_time = create_time + Header.default_data_lifetime
if not scheduled_create_time:
scheduled_create_time = time.time()
self.data = {
'taskmanager_id': taskmanager_id,
'create_time': int(create_time),
'expiration_time': int(expiration_time),
'scheduled_create_time': int(scheduled_create_time),
'creator': creator,
'schema_id': schema_id
}
def __init__(self, filepath):
try:
if os.path.exists(filepath):
UserDict.__init__(self)
st = os.stat(filepath)
self['id'] = id(self)
self['full_name'] = filepath
self['size'] = st.st_size
self['sizeh'] = approximate_size(st.st_size,a_kilobyte_is_1024_bytes=False)
self['user_id'] = st.st_uid
self['group_id'] = st.st_gid
self['is_directory'] = False
self['is_file'] = False
self['is_link'] = False
self['extension'] = ''
if (os.path.isdir((self['full_name']))):
self['is_directory'] = True
if (os.path.isfile((self['full_name']))):
self['is_file'] = True
if (os.path.isdir((self['full_name']))):
self['is_link'] = True
if self['is_file']:
self['extension'] = filepath.split(os.extsep)[len(filepath.split(os.extsep))-1]
else:
raise IOError
except IOError:
log.error("File {0} doesn't exist.".format(filepath))
sys.exit(1)
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<i2h'
self.__size__ = struct.calcsize(self.__format__)
self['magic'] = None
self['numMaterials'] = None
self['numObjects'] = None
def __init__(self, name, tables):
"""init Chains object"""
UserDict.__init__(self)
self.name = name
self.tables = tables
self.predef = tables
self.reset() # name, tables)
def __init__(self, isisdict):
UserDict.__init__(self)
if isisdict is not None:
UserDict.__init__(self, isisdict)
self["LatitudeType"] = "Planetographic"
self["LongitudeDirection"] = "PositiveEast"
self["LongitudeDomain"] = "180"
def __init__(self, schema, dn, entry):
self._keytuple2attrtype = {}
self._attrtype2keytuple = {}
self._s = schema
self.dn = dn
UserDict.__init__(self, {})
self.update(entry)
def __init__(self,
taskmanager_id,
state='NEW',
generation_id=None,
generation_time=None,
missed_update_count=0):
"""
Initialize Metadata object
:type taskmanager_id: :obj:`string`
:type state: :obj:`string`
:type generation_id: :obj:`int`
:type generation_time: :obj:`float`
:type missed_update_count: :obj:`int`
"""
UserDict.__init__(self)
if state not in Metadata.valid_states:
logging.getLogger().exception(f'Invalid Metadata state: {state}')
raise InvalidMetadataError()
if not generation_time:
generation_time = time.time()
self.data = {
'taskmanager_id': taskmanager_id,
'state': state,
'generation_id': generation_id,
'generation_time': int(generation_time),
'missed_update_count': missed_update_count
}
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<32si'
self.__size__ = struct.calcsize(self.__format__)
self['boneName'] = None
self['boneType'] = None
def __init__(
self,
keyfile=None,
certfile=None,
ssl_version="PROTOCOL_SSLv23",
ca_certs=None,
do_handshake_on_connect=True,
cert_reqs=CERT_NONE,
suppress_ragged_eofs=True,
ciphers=None,
**kwargs,
):
"""settings of SSL
:param keyfile: SSL key file path usally end with ".key"
:param certfile: SSL cert file path usally end with ".crt"
"""
UserDict.__init__(self)
self.data.update(
dict(
keyfile=keyfile,
certfile=certfile,
server_side=True,
ssl_version=getattr(ssl, ssl_version, ssl.PROTOCOL_SSLv23),
ca_certs=ca_certs,
do_handshake_on_connect=do_handshake_on_connect,
cert_reqs=cert_reqs,
suppress_ragged_eofs=suppress_ragged_eofs,
ciphers=ciphers,
))
def __init__(self, model, query_parameters, *args, **kwargs):
self._model = model
# Core options, not modifiable by client updates
if 'columns' not in kwargs:
model_fields = model._meta.local_fields
kwargs['columns'] = map(lambda f: f.verbose_name.capitalize(),
model_fields)
if 'hidden_columns' not in kwargs or kwargs['hidden_columns'] is None:
kwargs['hidden_columns'] = []
if 'search_fields' not in kwargs or kwargs['search_fields'] is None:
kwargs['search_fields'] = []
# Absorb query GET params
kwargs = self._normalize_options(query_parameters, kwargs)
UserDict.__init__(self, DEFAULT_OPTIONS, *args, **kwargs)
self._flat_column_names = []
for field_name in self.columns:
if isinstance(field_name, (tuple, list)):
pretty_name, field_name = field_name[:2]
if not field_name or isinstance(field_name, (tuple, list)):
field_name = pretty_name
self._flat_column_names.append(field_name)
def __init__(self, sid=None, expire=3600):
UserDict.__init__(self)
self.sid = sid
if sid:
self._load()
else:
self._create_sid()
def __init__(self, d=None, path=None):
if not path:
path = os.path.join(os.getcwd(), 'project.pbxproj')
self.pbxproj_path = os.path.abspath(path)
self.source_root = os.path.abspath(os.path.join(os.path.split(path)[0], '..'))
UserDict.__init__(self, d)
self.data = PBXDict(self.data)
self.objects = self.get('objects')
self.modified = False
root_id = self.get('rootObject')
if root_id:
self.root_object = self.objects[root_id]
root_group_id = self.root_object.get('mainGroup')
self.root_group = self.objects[root_group_id]
else:
print("error: project has no root object")
self.root_object = None
self.root_group = None
for k, v in self.objects.items():
v.id = k
def __init__(self):
"""
:param data_filename:
"""
self.data_filename = os.path.dirname(__file__) + '/unicode.dat'
self.str = [None, ] * 65536
lines = open(self.data_filename).readlines()
UserDict.__init__(self)
for line in lines:
fields = line.split()
for i, field in enumerate(fields):
if field.startswith('"') and field.endswith('"'):
fields[i] = field[1:-1]
if len(fields) > 3:
try:
code = int(fields[0].split(':')[0].split(';')[0])
entity = fields[1]
self[entity] = UnicodeChar(fields) # keep entity table
if len(fields) > 4: # keep code table
if not self.str[code]:
self.str[code] = self[entity]
else:
pass
except ValueError:
pass
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<8s3i'
self.__size__ = struct.calcsize(self.__format__)
self['fileType'] = None
self['numObjects'] = None
self['skeletonHash'] = None
self['numElements'] = None
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<32sif12f'
self.__size__ = struct.calcsize(self.__format__)
self['name'] = None
self['parent'] = None
self['scale'] = None
self['matrix'] = [[],[],[]]
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<8s3i'
self.__size__ = struct.calcsize(self.__format__)
self['fileType'] = None
self['numObjects'] = None
self['skeletonHash'] = None
self['numElements'] = None
def __init__(self, keys=None):
"""Initialize from a ParameterSet to create an empty mapping of
parameters.
:param keys: iterable of parameter names
"""
UserDict.__init__(self)
self._keys = keys if keys is not None else ParameterSet()
def __init__(self, file_path = None):
UserDict.__init__(self)
if not os.path.exists(file_path):
os.makedirs(file_path)
self["path"] = file_path
self["file"] = []
self["directory"] = []
self.__parse(self["path"])
def __init__(self, owner_player, data):
UserDict.__init__(self, data)
self.owner = owner_player
self.obj_map = {'planets': baseobjects.Planet,
'starbases': baseobjects.Starbase,
'ships': baseobjects.Ship,
'engines': baseobjects.Engine,
'torpedos': baseobjects.Launcher}
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<32sif12f'
self.__size__ = struct.calcsize(self.__format__)
self['name'] = None
self['parent'] = None
self['scale'] = None
self['matrix'] = [[], [], []]
def __init__(self, data={}, **kwds):
"""Create a new profile based on the class defaults, which are
overlaid with items from the `data` dict and keyword arguments."""
UserDict.__init__(self)
initdata = self.defaults.copy()
initdata.update(data)
initdata.update(**kwds)
self.data.update(initdata)
def __init__(self, save_target):
UserDict.__init__(self)
self.path = None if isinstance(save_target, FileIdMap) else Path(save_target)
self.parent = save_target if isinstance(save_target, FileIdMap) else None
if self.path is None and self.parent is None:
raise ValueError("Bad stuff in " + repr(save_target))
self._initialized = False
self._initialize_dict()
self.save()
def __init__(self, *args, **kwargs):
""" Create a Message object
@type: string denoting the message type. Standardization efforts are in progress.
@id: identifier for message. Usually a nonce or a DID. This combined with the type
tell us how to interpret the message.
other things: ambiguous data. Interpretation defined by type and id.
"""
UserDict.__init__(self,*args, **kwargs)
self.context = {}
def __init__(self, bot):
UserDict.__init__(self)
self.bot = bot
self.streamer = bot.streamer
self.db_session = DBManager.create_session()
self.custom_data = []
self.bttv_emote_manager = BTTVEmoteManager(self)
self.bot.execute_every(60 * 60 * 2, self.bot.action_queue.add, (self.bttv_emote_manager.update_emotes, ))
def __init__(self, initial=None):
handlers = initial or {
'application/json': JSONHandler(),
'application/json; charset=UTF-8': JSONHandler(),
}
# NOTE(jmvrbanac): Directly calling UserDict as it's not inheritable.
# Also, this results in self.update(...) being called.
UserDict.__init__(self, handlers)
def __init__(self, sid=None, expire=3600, refresh_time=300):
UserDict.__init__(self)
self.sid = sid
self._changed = False
self._refresh_time = refresh_time
if sid:
self._load()
else:
self._create_sid()
def __init__(self, url, local_file, download_time=None):
UserDict.__init__(self)
if download_time is None:
download_time = datetime.datetime.fromtimestamp(time.time())
timestr = download_time.isoformat()
self["url"] = url
self["local_file"] = local_file
self["time"] = timestr
def __init__(self):
UserDict.__init__(self)
self.data = dict() # self.data[elementid] = list of vendors with prices
self._vendormap = VendorMap()
self.bricklink_initialized = False
self.vendor_initialized = False
self.averageprices = dict()
self.webreader = None
def __init__(self, url, local_file, download_time=None):
UserDict.__init__(self)
if download_time is None:
download_time = datetime.datetime.fromtimestamp(time.time())
timestr = download_time.isoformat()
self['url'] = url
self['local_file'] = local_file
self['time'] = timestr
def __init__(self, **kw):
"""usage: Object(id="human", objtype="class", parents=["living"])
acts like normal python class and dictionary at the same time
in addition looks for atributes from parent objects
"""
if "from_" in kw:
kw["from"] = kw["from_"]
del kw["from_"]
UserDict.__init__(self, kw)
def __init__(self, bundleID, bundlePath=None, defaultsPlistName='Defaults'):
"""
bundleId: the application bundle identifier
bundlePath: the full bundle path (useful to test a Debug build)
defaultsPlistName: the name of the plist that contains default values
"""
self.__bundleID = bundleID
self.__bundlePath = bundlePath
UserDict.__init__(self)
self.__setup(defaultsPlistName)
def __init__(self,prefix=""):
UserDict.__init__(self)
self.reset()
self.nextlabel = 0
self.nextTemp = 0
self.nextEnum = 0
self.nextParamSlot = 0
self.var_params = []
self.prefix = prefix
self.temp_prefix = "t__%s" % prefix
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<8s5i'
self.__size__ = struct.calcsize(self.__format__)
self['filetype'] = None
self['three'] = None
self['magic'] = None
self['numBones'] = None
self['numFrames'] = None
self['fps'] = None
def __init__(self):
UserDict.__init__(self)
self.__format__ = '<i64s4i'
self.__size__ = struct.calcsize(self.__format__)
self['matIndex'] = None
self['name'] = None
self['startVertex'] = None
self['numVertices'] = None
self['startIndex'] = None
self['numIndices'] = None
def __init__(self, initial={}, namespace=None):
self._init = False
UserDict.__init__(self, initial)
if namespace and isclass(namespace):
self.names = {x:getattr(namespace, x)for x in dir(namespace) if not x.startswith("_")}
self.variables = {x:self.names[x] for x in self.names if x.startswith("var")}
self.flags = {x:self.names[x] for x in self.names if x.startswith("flag")}
if("levelName" in self.names):
self.levelName = self.names["levelName"]
else:
self.levelName = None
self._init = True
def __init__(self, initial=None, ignore=(), caseless=True, spaceless=True):
"""Initializes with possible initial value and normalizing spec.
Initial values can be either a dictionary or an iterable of name/value
pairs. In the latter case items are added in the given order.
Normalizing spec has exact same semantics as with `normalize` method.
"""
UserDict.__init__(self)
self._keys = {}
self._normalize = lambda s: normalize(s, ignore, caseless, spaceless)
if initial:
self._add_initial(initial)
def __init__(self, cellbase_dict):
UserDict.__init__(self, cellbase_dict)
if "measureSet" in self.data['referenceClinVarAssertion']:
measure_list = self.data['referenceClinVarAssertion']["measureSet"]["measure"]
elif "measureSet" in self.data['referenceClinVarAssertion']["genotypeSet"]:
measure_list = []
for measure_set in self.data['referenceClinVarAssertion']["genotypeSet"]["measureSet"]:
for measure in measure_set["measure"]:
measure_list.append(measure)
else:
raise KeyError()
self.measures = [ClinvarRecordMeasure(measure_dict, self) for measure_dict in measure_list]
def __init__(self, initdict=None, hook_when_init=True):
"""
:param initdict: initialized from
:param hook_when_init: run hook points when it is True
"""
UserDict.__init__(self)
if initdict:
if hook_when_init:
self.update(initdict)
else:
self.data.update(initdict)
def __init__(self, bot):
UserDict.__init__(self)
self.bot = bot
self.streamer = bot.streamer
self.db_session = DBManager.create_session()
self.custom_data = []
self.bttv_emote_manager = BTTVEmoteManager(self)
self.bot.execute_delayed(5, self.bot.action_queue.add, (self.bttv_emote_manager.update_emotes, ))
self.bot.execute_every(60 * 60 * 2, self.bot.action_queue.add, (self.bttv_emote_manager.update_emotes, ))
# Used as caching to store emotes
self.global_emotes = []
def __init__(self, url, local_file, description,
download_time=None, raw=None, is_accompany=False, market=''):
UserDict.__init__(self)
if download_time is None:
download_time = datetime.datetime.utcnow()
timestr = download_time.isoformat()
self['url'] = url
self['local_file'] = local_file
self['description'] = description
self['time'] = timestr
self['raw'] = raw
self['is_accompany'] = is_accompany
self['market'] = market
def __init__(self, overrides={}):
UserDict.__init__(self)
self.db_session = DBManager.create_session()
self.default_settings = {
'broadcaster': 'test_broadcaster',
'ban_ascii': True,
'ban_msg_length': True,
'motd_interval_offline': 60,
'motd_interval_online': 5,
'max_msg_length': 350,
'lines_offline': True,
'parse_pyramids': False,
'check_links': True,
}
self.default_settings.update(overrides)
def __init__(self,
destfile,
sourcefile="reference-one",
sloppy=False,
ipversion=4
):
"""init Tables Object is easy going"""
UserDict.__init__(self)
self.destfile = destfile
self.sourcefile = sourcefile
self.sloppy = sloppy
self.linecounter = 0
self.tblctr = 0
self.patterns = ""
self.reset(sourcefile, ipversion)
def __init__(self, socket_manager=None, module_manager=None, bot=None):
UserDict.__init__(self)
self.db_session = DBManager.create_session()
self.internal_commands = {}
self.db_commands = {}
self.module_commands = {}
self.bot = bot
self.module_manager = module_manager
if socket_manager:
socket_manager.add_handler('module.update', self.on_module_reload)
socket_manager.add_handler('command.update', self.on_command_update)
socket_manager.add_handler('command.remove', self.on_command_remove)
def __init__(self, overrides={}):
UserDict.__init__(self)
self.db_session = DBManager.create_session()
self.default_settings = {
"broadcaster": "test_broadcaster",
"ban_ascii": True,
"ban_msg_length": True,
"motd_interval_offline": 60,
"motd_interval_online": 5,
"max_msg_length": 350,
"lines_offline": True,
"parse_pyramids": False,
"parse_emote_combo": False,
"check_links": True,
}
self.default_settings.update(overrides)
