def __init__(self, element: ElementTree):
# Set members using attributes of <location> tag
self.start: int = element.get('start')
self.end: int = element.get('end')
self.ali_start: int = element.get('ali_start')
self.ali_end: int = element.get('ali_end')
self.hmm_start: int = element.get('hmm_start')
self.hmm_end: int = element.get('hmm_end')
self.bitscore: float = element.get('bitscore')
self.evalue: float = element.get('evalue')
self.evidence: str = element.get('evidence')
self.significant: str = element.get('significant')
self.hmm: str = None
self.match_string: str = None
self.pp: str = None
self.seq: str = None
self.raw: str = None
# Process child nodes
for el in element:
# Set an attribute of this object using the text content of the element as value
setattr(self, el.tag, el.text)
def __init__(self, element: ElementTree):
# Attributes of the <hmm_details> tag
self.hmmer_version: str = element.get('hmmer_version')
self.model_version: str = element.get('model_version')
self.model_length: int = element.get('model_length')
# Other propperties fetched form the child nodes
self.build_commands: str = None
self.search_commands: str = None
self.cutoffs: dict = {}
# Process child nodes
for el in element:
# A special parsing for <cutoffs> tag
if el.tag == 'cutoffs':
for cutoff in el:
self.cutoffs[cutoff.tag] = PfamCutoff(
cutoff.find('sequence').text,
cutoff.find('domain').text)
# Set an attribute of this object using the text content of the element as value
else:
setattr(self, el.tag, el.text)
def __init__(self, release_version: str, release_date: datetime,
entry: ElementTree):
# The release version of the pfam database
self.pfam_release_version: str = release_version
self.pfam_release_date: datetime = release_date
# Text of the family
self.description: str = None
self.comment: str = None
# Members
self.families = []
# Process child nodes
for el in entry:
# Trasform the element curation_details in a object
if el.tag == 'members':
for member in el:
self.families.append(PfamClanMember(member))
# Set an attribute of this object using the text content of the element as value
else:
setattr(self, el.tag, el.text)
# Entry of this clan
self.entry: PfamEntry = PfamEntry(entry.get('entry_type'),
entry.get('id'),
entry.get('accession'),
self.description)
def map_programme(el: ElementTree, channels_dict):
category = el.find("category")
return Programme(
el.find("title").text, "" if category is None else category.text,
channels_dict[el.get("channel")],
datetime.strptime(el.get("start"), time_format),
datetime.strptime(el.get("stop"), time_format))
def _parse_data(self, data_child: ElementTree) -> DataObject:
id = data_child.get('id')
type = data_child.get('type')
if type == DATA_TYPES['form']:
name, fields = self._parse_form(data_child)
return Form(id, name, fields)
else:
raise ValueError('Data type %s not supported.' % type)
def __init__(self, release_version: str, release_date: datetime,
entry: ElementTree):
# The release version of the pfam database
self.pfam_release_version: str = release_version
self.pfam_release_date: datetime = release_date
# Text of the family
self.description: str = None
self.comment: str = None
# Process child nodes
for el in entry:
# Trasform the element curation_details in a object
if el.tag == 'curation_details':
self.curation_details: PfamCurationDetails = PfamCurationDetails(
el)
# Trasform the element hmm_details in a object
elif el.tag == 'hmm_details':
self.hmm_details: PfamHmmDetails = PfamHmmDetails(el)
elif el.tag == 'clan_membership':
self.clan_entry: PfamEntry = PfamEntry('Clan',
el.get('clan_id'),
el.get('clan_acc'),
None)
# Parse GO terms in a list of dicts
elif el.tag == 'go_terms':
self.go_terms: [PfarmGOTerm] = []
# Iterate over categories
for cat in el:
# The category name
category = cat.get('name')
# Insert in the list all the terms
for term in cat:
self.go_terms.append(
PfarmGOTerm(term.get('go_id'), category,
term.text))
# Set an attribute of this object using the text content of the element as value
else:
setattr(self, el.tag, el.text)
# Entry of this family (for consistency)
self.entry: PfamEntry = PfamEntry(entry.get('entry_type'),
entry.get('id'),
entry.get('accession'),
self.description)
def __init__(self, element: ElementTree):
# Attribute data of the tag <matches>
self.entry: PfamEntry = PfamEntry(element.get('type'),
element.get('id'),
element.get('accession'), None)
# List of locations of matches
self.locations: [PfamLocation] = []
# Populate the list of locations
for loc in element:
self.locations.append(PfamLocation(loc))
def sortCode(et):
try:
tag = et.tag
tag = tag.split('}')[-1]
if tag.lower() == 'code':
tag = 'z' + tag
urn = et.get('urn')
value = et.get('value')
key = tag + '.' + value + '.' + str(urn)
return key
except:
urn = ''
value = ''
key = tag + '.' + value + '.' + str(urn)
return key
def __init__(self, release_version: str, release_date: datetime,
entry: ElementTree):
# The release version of the pfam database
self.pfam_release_version: str = release_version
self.pfam_release_date: datetime = release_date
# Attributes of this entry
self.db_name: str = entry.get('db')
self.db_release_version: float = entry.get('db_release')
# Text of the family
self.description: str = None
self.comment: str = None
self.taxonomy_id: str = None
self.species_name: str = None
self.taxonomy: [str] = None
self.sequence: str = None
# List of matches
self.matches: [PfamMatch] = []
# Process child nodes
for el in entry:
if el.tag == 'taxonomy':
self.taxonomy_id: int = el.get('tax_id')
self.species_name: str = el.get('species_name')
self.taxonomy: [str] = el.text.rstrip('.').split('; ')
elif el.tag == 'sequence':
self.sequence_version: int = el.get('version')
self.sequence: str = el.text
elif el.tag == 'matches':
for match in el:
self.matches.append(PfamMatch(match))
# Set an attribute of this object using the text content of the element as value
else:
setattr(self, el.tag, el.text)
# Entry of this protein
self.entry: PfamEntry = PfamEntry(entry.get('entry_type'),
entry.get('id'),
entry.get('accession'),
self.description)
def _parse_gateway(gateway_child: ElementTree) -> Gateway:
id = gateway_child.get('id')
name = gateway_child.find('Name').text
type = gateway_child.find('Type').text.lower()
gates = []
distribution = None
rule = None
if type == GATEWAY_TYPES['choice']:
distribution_child = gateway_child.find('Distribution')
rule_child = gateway_child.find('Rule')
if distribution_child is not None and len(
list(distribution_child)):
distribution = []
for gate in distribution_child:
gates.append(gate.get('id'))
distribution.append(float(gate.text))
elif rule_child is not None and len(list(rule_child)):
for gate in rule_child:
gates.append(gate.get('id'))
rule = id
else:
raise ValueError(
"For choice gateways, either rule or distribution must be present."
)
elif type == GATEWAY_TYPES['parallel'] or type == GATEWAY_TYPES[
'merge']:
gates_child = gateway_child.find('Gates')
for gate in gates_child:
gates.append(gate.get('id'))
return Gateway(id=id,
name=name,
type=type,
gates=gates,
distribution=distribution,
rule=rule)
def __init__(self, currency: ElementTree, date):
self.date = date
self.code = currency.get('Kod')
temp = currency.find('Unit').text
self.unit = int(temp) if temp else None
self.name = currency.find('Isim').text
self.currency_name = currency.find('CurrencyName').text
temp = currency.find('ForexBuying').text
self.forex_buying = float(temp) if temp else None
temp = currency.find('ForexSelling').text
self.forex_selling = float(temp) if temp else None
temp = currency.find('BanknoteBuying').text
self.banknote_buying = float(temp) if temp else None
temp = currency.find('BanknoteSelling').text
self.banknote_selling = float(temp) if temp else None
cross_rate_usd = currency.find('CrossRateUSD').text
self.cross_rate_usd = float(cross_rate_usd) if cross_rate_usd else None
def __init__(self, treein: ElementTree):
"""
Parameters
----------
treein : elementtree
tree contianing pieces which will be portioned out
"""
super(Encounter, self).__init__()
self.name = treein.get("name")
self.numbers = list()
i = int(treein.get("startnumber"))
j = int(treein.get("endnumber"))
while i <= j:
self.numbers.append(i)
i = i + 1
self.description = Description(treein.get("description"))
self.next = treein.get("next").split(",")
def _from_etree(cls, el: ElementTree, base_href: str) -> LessonSectionStep:
html = _build_inner_html(el, base_href)
highlight_s = el.get('data-highlight')
if not highlight_s:
highlight_s = '[]'
try:
highlight = json.loads(highlight_s)
except json.decoder.JSONDecodeError:
raise LessonParseError('data-highlight contains invalid JSON')
test_js = el.get('data-test')
if not test_js:
raise LessonParseError(
'missing data-test attribute, which must be JavaScript')
return cls(html, highlight, test_js)
def parse_groupings(tree: ET) -> {dict: dict}:
'''creates a nested dictionary that contains all the tags and their names while retaining their
structure, used to list out the all the devices'''
if tree.tag == 'device-model':
return {tree.get('name')}
elif tree.tag == 'data':
to_return = defaultdict(dict)
for child in tree:
to_return.update(parse_groupings(child))
return dict(to_return)
else:
to_return = {}
for child in tree:
if (tree.get('name')) in to_return:
to_return[tree.get('name')].update(parse_groupings(child))
else:
to_return[tree.get('name')] = parse_groupings(child)
return to_return
def _parse_transition(self, transition_child: ElementTree) -> Transition:
source = transition_child.get('source')
destination = transition_child.get('destination')
sgate = transition_child.get('source_gate')
dgate = transition_child.get('destination_gate')
duration_child = transition_child.find('Duration')
distribution_child = transition_child.find('Duration/Distribution')
if distribution_child is not None:
distribution = self._parse_distribution(distribution_child)
else:
distribution = int(
duration_child.text) if duration_child is not None else 0
return Transition(source=source,
destination=destination,
sgate=sgate,
dgate=dgate,
distribution=distribution)
def build_device_simple(tree: ET, device_name_n='', override=False):
device_name = tree.get('name')
if override:
device_name = device_name_n.strip()
device_states = {}
for child in tree:
device_states[child.get('name')] = int(child.text)
return (device_name, device_states)
def _from_etree(cls, el: ElementTree, base_href: str) -> LessonSectionStep:
html = _build_inner_html(el, base_href)
highlight_s = el.get("data-highlight")
if not highlight_s:
highlight_s = "[]"
try:
highlight = json.loads(highlight_s)
except json.decoder.JSONDecodeError:
raise LessonParseError("data-highlight contains invalid JSON")
test_js = el.get("data-test")
if not test_js:
raise LessonParseError(
"missing data-test attribute, which must be JavaScript")
test_js = test_js.replace("{{LESSON_FILES_URL}}",
f"{settings.LESSON_FILES_URL}/{base_href}")
return cls(html, highlight, test_js)
def build_device(tree: ET, device_name_n='', override=False):
device_name = tree.get('name')
if override:
device_name = device_name_n.strip()
device_states = {}
for child in tree:
#device_states[child.get('name')] = int(child.text)
device_states[child.get('name')] = float(
child.get('power')) #updated to float
return (device_name, device_states)
def from_ET(et:ET) -> ThingSaveData:
result_data = dict()
for item in ThingSaveData._fields:
value = et.find("./"+item)
result_data[item] = value.text.strip() if value is not None and value.text is not None else None
result_data['parsed_element'] = et
result_data['xsi_type'] = et.get('{http://www.w3.org/2001/XMLSchema-instance}type')
result = ThingSaveData(**result_data)
return result
def parse_member(member: ElementTree, tree: ElementTree) -> CMember:
e_type = member.find('./type')
type_string = (member.text or '') + e_type.text + (e_type.tail or '')
e_name = member.find('./name')
name = e_name.text
array_size: int = None
if e_name.tail and e_name.tail.startswith('['):
match = re.match('\[\s*(\d+)\s*\]', e_name.tail)
if match:
array_size = int(match.group(1))
else:
e_enum = member.find('./enum')
array_size = int(
tree.find(
f'./enums/enum[@name="{e_enum.text}"]').attrib['value'])
type_strings = type_string.split('*')
first_type = type_strings[0].split()
is_const = False
if 'const' in first_type:
first_type.remove('const')
is_const = True
if 'struct' in first_type:
first_type.remove('struct')
c_type = CType(name=' '.join(first_type), const=is_const)
pointers = type_strings[1:]
lengths = member.attrib['len'].split(',') if 'len' in member.attrib else []
optionals = member.attrib['optional'].split(
',') if 'optional' in member.attrib else []
if len(optionals) > len(pointers):
c_type.optional = optionals.pop(-1) == 'true'
lengths = reversed(lengths[:len(pointers)])
optionals = reversed(optionals[:len(pointers)])
for pointer, length, optional in zip_longest(pointers, lengths, optionals):
c_type = CType(pointer_to=c_type,
length=length,
const='const' in pointer,
optional=optional == 'true')
if array_size is not None:
c_type = CType(array_of=c_type, length=array_size)
values_string = member.get('values')
values = values_string.split(',') if values_string else []
return CMember(name, c_type, values)
def parse_enum_value(e_enum: ElementTree, extension_number: int = None) -> str:
if 'offset' in e_enum.attrib:
if 'extnumber' in e_enum.attrib:
extension_number = int(e_enum.attrib['extnumber'])
value = 1000000000 + (extension_number - 1) * 1000 + int(
e_enum.attrib['offset'])
if e_enum.get('dir') == '-':
value *= -1
return str(value)
elif 'bitpos' in e_enum.attrib:
return str(2**int(e_enum.attrib['bitpos']))
else:
return e_enum.attrib['value']
def fromXML(xml, file_name):
if xml.tag != "enumeratedValueSet":
raise BehaviorSpaceXMLError(file_name, "enumeratedValueSet",
xml.tag)
variable = xml.get("variable")
values = []
for value in xml:
if value.tag != "value":
raise BehaviorSpaceXMLError(file_name, "value", value.tag)
values.append(value.get("value"))
return EnumeratedValue(variable, values)
def build_device(tree: ET, device_name_n='', override=False):
device_name = tree.get('name')
if override:
device_name = device_name_n.strip()
device_states = {}
for state in tree:
device_states[state.get('name')] = {}
for key, value in state.items():
if key != 'name' and key != 'type' and key != 'comments':
device_states[state.get('name')][key] = float(value)
return (device_name, device_states)
def _parse_resource(self,
resource_child: ElementTree,
resource_limit=None) -> Resource:
class_type = resource_child.get('type')
id = resource_child.get('id')
if resource_limit is not None and id in resource_limit:
qty = int(resource_limit[id])
else:
qty = int(resource_child.find('Quantity').text)
if class_type == RESOURCE_TYPES['human']:
org = resource_child.find('Organization').text
dept = resource_child.find('Department').text
role = resource_child.find('Role').text
availability = self._parse_calendar(
resource_child.find('Availability'))
res = []
for i in range(qty):
res.append(
HumanResource(id + "_" + str(i), org, dept, role,
availability))
elif class_type == RESOURCE_TYPES['physical']:
type = resource_child.find('Type').text
duration_child = resource_child.find('Duration')
distribution_child = resource_child.find('Duration/Distribution')
if distribution_child is not None:
delay = self._parse_distribution(distribution_child)
else:
delay = int(
duration_child.text) if duration_child is not None else 0
cons = True if resource_child.get(
'consumable').lower() == "true" else False
res = PhysicalResource(id, type, qty, delay, cons)
else:
raise AttributeError("Resource type %s not supported." %
class_type)
return res
def __init__(self, root_element: ElementTree):
self.inputs = []
intent = root_element.get("intent", "")
self.is_blueprint = intent == "blueprint"
if root_element.tag != "command":
print("warning: invalid SDL creator root element detected: %s" %
root_element.tag)
return
for element in root_element:
if element.tag == "input":
self.add_input(SDLInput(element))
def getSignalInfos(self, sSignalName):
#print("Signal Name : %s" % sSignalName)
oXML = self.oXMLroot.find('Signals/Signal[@name="%s"]' % sSignalName)
#print(oXML)
if oXML == None:
#print("Special Button")
oXML = self.oXMLroot.find('SpecialButtons/OR2[@name="%s"]' %
sSignalName)
if oXML == None:
raise ValueError(
"did not found the special button in the xml: %s" %
sSignalName)
index = oXML.get('index')
return int(index)
def from_xml(cls, board_url: URL, el: ElementTree):
file_url = el.get('file_url')
return Post.from_dict(board_url=board_url,
created_at=el.get('created_at'),
file_url=file_url,
file_ext=file_url.split('.')[-1],
id=el.get('id'),
score=el.get('score'),
source=el.get('source'),
tags=el.get('tags'))
def _parse_process_model(self, model_child: ElementTree) -> Process:
id = model_child.get('id')
name = model_child.find('Name').text
arrival_rate = self._parse_calendar(model_child.find('ArrivalRate'))
deadline = model_child.find('Deadline').text
gateways = []
for gateway in model_child.find('Gateways'):
gateways.append(self._parse_gateway(gateway))
transitions = []
activities = dict()
resources = list() # currently unused
data_objects = dict()
for transition in model_child.find('Transitions'):
transition_object = self._parse_transition(transition)
transitions.append(transition_object)
# parse activity from transitions
if transition_object.source not in activities:
source = self._clone_activity(transition_object.source)
if source is not None:
activities[source.id] = source
resources, data_objects = self._parse_from_existing(
source, resources, data_objects)
if transition_object.destination not in activities:
destination = self._clone_activity(
transition_object.destination)
if destination is not None:
activities[destination.id] = destination
resources, data_objects = self._parse_from_existing(
destination, resources, data_objects)
for act in model_child.find('Activities'):
fields = self._parse_activity_fields(act)
activities[fields['id']].update(fields)
return Process(id=id,
name=name,
arrival_rate=arrival_rate,
deadline=deadline,
activities=activities,
gateways=gateways,
transitions=transitions,
data_objects=list(data_objects.values()))
def __changeset_parser(self, tree: ElemTree):
tags = self.__kv_parser(tree.findall('tag'))
cs_prop = {}
for key in tree.keys():
cs_prop[key] = tree.get(key)
com_xml = tree.findall('discussion/comment')
comments = []
for com in com_xml:
comments.append(Comment(com.find('text').text, com.get('uid'), com.get('user'), com.get('date')))
try:
bbox = cs_prop['min_lon'], cs_prop['min_lat'], cs_prop['max_lon'], cs_prop['max_lat']
except KeyError:
bbox = (None, None, None, None)
created = datetime.strptime(cs_prop['created_at'], "%Y-%m-%dT%H:%M:%SZ")
if cs_prop['created_at'] is True:
closed = None
else:
closed = datetime.strptime(cs_prop['closed_at'], "%Y-%m-%dT%H:%M:%SZ")
ch_set = ChangeSet(cs_prop['id'], cs_prop['user'], cs_prop['uid'], created,
cs_prop['open'], bbox, closed, tags, comments)
return ch_set
def __init__(self, config_tree : ElementTree):
self.folder = config_tree.get('directory')
self._load_all_images()