def _get_build_metadata(self, dir_name):
if os.path.exists(os.path.join(dir_name, 'jenkins_build.tar.gz')):
raise Skip('the build has already been archived', dir_name)
# Read the build.xml metadata file that Jenkins generates
build_metadata = os.path.join(dir_name, 'build.xml')
if not os.access(build_metadata, os.R_OK):
self.log.debug("Can't read build file at %s" % (build_metadata))
raise Exception("Can't access build.xml at %s" % (build_metadata))
else:
tree = ElementTree()
tree.parse(build_metadata)
keys = ['result', 'number', 'duration']
kv_pairs = ((k, tree.find(k)) for k in keys)
d = dict([(k, v.text) for k, v in kv_pairs if v is not None])
try:
d['branch'] = tree.find('actions') \
.find('hudson.plugins.git.util.BuildData') \
.find('buildsByBranchName') \
.find('entry') \
.find('hudson.plugins.git.util.Build') \
.find('revision') \
.find('branches') \
.find('hudson.plugins.git.Branch') \
.find('name') \
.text
except Exception:
pass
return d
def _get_article_contrib_authors(tree):
"""
Given an ElementTree, returns article authors in a format suitable for citation.
"""
authors = []
front = ElementTree(tree).find('front')
for contrib in front.iter('contrib'):
if contrib.attrib['contrib-type'] != 'author':
continue
contribTree = ElementTree(contrib)
try:
surname = contribTree.find('name/surname').text
except AttributeError: # author is not a natural person
try:
citation_name = contribTree.find('collab').text
if citation_name is not None:
authors.append(citation_name)
continue
except AttributeError: # name has no immediate text node
continue
try:
given_names = contribTree.find('name/given-names').text
citation_name = ' '.join([surname, given_names[0]])
except AttributeError: # no given names
citation_name = surname
except TypeError: # also no given names
citation_name = surname
if citation_name is not None:
authors.append(citation_name)
return ', '.join(authors)
class SchemeReader:
def __init__(self, file_name):
f = open(file_name);
"""
self.xml = f.read();
self.parse();
"""
self.root = ElementTree(file=f);
self.parse();
f.close();
def parse(self):
"""
bs = BeautifulSoup.BeautifulSoup(self.xml, "xml");
print bs
date_tag = bs.find("Date");
print date_tag
self.date = DateScheme(date_tag);
text_tag = bs.find("Text");
self.text = TextScheme(text_tag);
"""
date_tag = self.root.find("Date");
self.date = DateScheme(date_tag);
text_tag = self.root.find("Text");
self.text = TextScheme(text_tag);
class TreeReader:
"""Reads Decision Tree from XML file"""
def __init__(self, fileName):
self.__xmltree = ElementTree()
self.__xmltree.parse(fileName)
self.__NTrees = int(self.__xmltree.find("Weights").get('NTrees'))
def getNTrees(self):
return (self.__NTrees)
def __getBinaryTree(self, itree):
if self.__NTrees<=itree:
print( "to big number, tree number must be less then %s"%self.__NTrees )
return 0
return self.__xmltree.find("Weights").find("BinaryTree["+str(itree+1)+"]")
def __readTree(self, binaryTree, tree={}, depth=0):
nodes = binaryTree.findall("Node")
if len(nodes)==0:
return
if len(nodes)==1 and nodes[0].get("pos")=="s":
info = {
"IVar": nodes[0].get("IVar"),
"Cut" : nodes[0].get("Cut"),
"purity": nodes[0].get("purity"),
"pos": 0
}
tree["info"] = info
tree["children"] = []
self.__readTree(nodes[0], tree, 1)
return
for node in nodes:
info = {
"IVar": node.get("IVar"),
"Cut" : node.get("Cut"),
"purity": node.get("purity"),
"pos": node.get("pos")
}
tree["children"].append({
"info": info,
"children": []
})
self.__readTree(node, tree["children"][-1], depth+1)
def getTree(self, itree):
binaryTree = self.__getBinaryTree(itree)
if binaryTree==0:
return {}
tree = {}
self.__readTree(binaryTree, tree)
return tree
def getVariables(self):
variables = []
varstree = self.__xmltree.find("Variables").findall("Variable")
variables = [None]*len(varstree)
for v in varstree:
variables[int(v.get('VarIndex'))] = v.get('Expression')
return variables
def getVersion(self):
if os.path.exists(self.options.versionxmlfile):
tree = ElementTree(file=self.options.versionxmlfile)
LastVersionNode = tree.find(".//LastVersion")
if LastVersionNode == None:
print("LastVersion element not found in version XML file!")
exit(1)
lastVersionText = "".join(LastVersionNode.itertext())
self.newversion = lastVersionText
ServerBranchNode = tree.find(".//LocalBranchPath")
if ServerBranchNode == None:
print("Local branch path element not found in version XML file!")
exit(1)
serverBranchText = "".join(ServerBranchNode.itertext())
serverBranchText = serverBranchText.replace("${LastVersion}", lastVersionText)
serverBranchText = serverBranchText.replace("${Year}", str(datetime.date.today().year))
serverBranchText = serverBranchText.replace("${Integration_Root}", self.options.integrationroot)
self.branchPath = serverBranchText
else:
print("Version XML file not found!")
exit(1)
# If a version is passed in, it overrides the version in the version.xml file
if not self.options.version == None:
self.newversion = self.options.version
self.branchPath = None
def get_service_data(self,service,**kwargs):
""""
Makes a call to a webservice endpoint and extracts the relevant fields into
instances of the item type for the collection
"""
#TODO memoization broken, needs to account for args
if not hasattr(self,'_items'):
url_base = "%s/%s" % (METRO_API_URL,service)
params = {'api_key':MetroAPI.api_key}
if len(kwargs):
params.update(kwargs)
qs = urlencode(params)
url = "%s?%s" % (url_base,qs)
print url
response = urlopen(url)
et = ET()
et.parse(response)
count = et.find('metadata').find('records_found')
results = []
if int(count.text) > 0:
items = et.find(self.list_elem)
for item in items.findall('item'):
item_args = {}
for field in self.fields:
item_args.update({field:item.find(field).text})
results.append(self.item_type(**item_args))
setattr(self,'_items',results)
return self._items
def test_service_validate_view_success(self):
"""
When called with correct parameters, a ``GET`` request to the
view should return a validation success and the
``ServiceTicket`` should be consumed and invalid for future
validation attempts.
"""
query_str = "?service=%s&ticket=%s" % (self.service_url,
self.st.ticket)
response = self.client.get(reverse('cas_service_validate') + query_str)
tree = ElementTree(fromstring(response.content))
elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'user')
self.assertIsNotNone(elem)
self.assertEqual(elem.text, 'ellen')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-Type'), 'text/xml')
# This should fail as the ticket was consumed in the preceeding test
response = self.client.get(reverse('cas_service_validate') + query_str)
tree = ElementTree(fromstring(response.content))
elem = tree.find(XMLNS + 'authenticationFailure')
self.assertIsNotNone(elem)
self.assertEqual(elem.get('code'), 'INVALID_TICKET')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-Type'), 'text/xml')
def test_proxy_validate_view_pgturl(self):
"""
When called with correct parameters and a ``pgtUrl`` parameter,
a ``GET`` request to the view should return a validation
success and also attempt to create a ``ProxyGrantingTicket``.
NOTE: this test will fail unless ``pgt_url`` is configured with
a valid proxy callback URL.
"""
if self.pgt_url == 'https://www.example.com/':
raise ImproperlyConfigured("Set pgt_url to a valid HTTPS URL "
"to successfully run this test")
query_str = "?service=%s&ticket=%s&pgtUrl=%s" % (self.service_url,
self.pt.ticket,
self.pgt_url)
response = self.client.get(reverse('cas_proxy_validate') + query_str)
tree = ElementTree(fromstring(response.content))
elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'user')
self.assertIsNotNone(elem)
self.assertEqual(elem.text, 'ellen')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-Type'), 'text/xml')
elem = tree.find(XMLNS + 'authenticationSuccess/' +
XMLNS + 'proxyGrantingTicket')
self.assertIsNotNone(elem)
def test_proxy_validate_view_proxies(self):
"""
When a successful ``ProxyTicket`` validation occurs, the
response should include a ``proxies`` block containing all of
the proxies involved. When authentication has proceeded through
multiple proxies, they must be listed in reverse order of being
accessed.
"""
pgt2 = ProxyGrantingTicket.objects.create_ticket(self.service_url,
validate=False,
user=self.user,
granted_by_pt=self.pt)
ticket_info2 = {'service': 'http://ww2.example.com/',
'user': self.user}
pt2 = ProxyTicket.objects.create_ticket(granted_by_pgt=pgt2,
**ticket_info2)
query_str = "?service=%s&ticket=%s" % ('http://ww2.example.com/', pt2)
response = self.client.get(reverse('cas_proxy_validate') + query_str)
tree = ElementTree(fromstring(response.content))
elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'user')
self.assertIsNotNone(elem)
self.assertEqual(elem.text, 'ellen')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-Type'), 'text/xml')
elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'proxies')
proxy = list(elem.getiterator(XMLNS + 'proxy'))
self.assertEqual(len(proxy), 2)
self.assertEqual(proxy[0].text, 'http://ww2.example.com')
self.assertEqual(proxy[1].text, 'http://www.example.com')
def test_proxy_validate_view_pt_success(self):
"""
When called with a valid ``ProxyTicket``, a ``GET`` request to
the view should return a validation success and the
``ProxyTicket`` should be consumed and invalid for future
validation attempts.
"""
query_str = "?service=%s&ticket=%s" % (self.service_url,
self.pt.ticket)
response = self.client.get(reverse('cas_proxy_validate') + query_str)
tree = ElementTree(fromstring(response.content))
elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'user')
self.assertIsNotNone(elem)
self.assertEqual(elem.text, 'ellen')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-Type'), 'text/xml')
elem = tree.find(XMLNS + 'authenticationSuccess/' + XMLNS + 'proxies')
proxy = list(elem.getiterator(XMLNS + 'proxy'))
self.assertEqual(len(proxy), 1)
self.assertEqual(proxy[0].text, 'http://www.example.com')
# This second validation request attempt should fail as the
# ticket was consumed in the preceeding test
response = self.client.get(reverse('cas_proxy_validate') + query_str)
tree = ElementTree(fromstring(response.content))
elem = tree.find(XMLNS + 'authenticationFailure')
self.assertIsNotNone(elem)
self.assertEqual(elem.get('code'), 'INVALID_TICKET')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-Type'), 'text/xml')
def set_initial_fields(process, run_dir, run_id):
process.udf['Operator'] = process.technician.username
for ide, name in INSTRUMENT_NAME_MAP.items():
if re.match("\\d{6}_%s_.*" % (ide), run_id):
process.udf['Instrument Name'] = name
break
else:
print "The run ID", run_id, "did not match any of the known instruments, Instrument Name not set."
if process.type_name.startswith("MiSeq Run"):
rp_tree = ElementTree()
try:
rp_tree.parse(os.path.join(run_dir, "RunParameters.xml"))
except IOError: # Fallback to previous version MiSeq software
rp_tree.parse(os.path.join(run_dir, "runParameters.xml"))
process.udf['Chemistry Version'] = rp_tree.find(
"ReagentKitVersion").text.replace("Version", "")
ri_tree = ElementTree()
ri_tree.parse(os.path.join(run_dir, "RunInfo.xml"))
num_tiles = ri_tree.find("Run/FlowcellLayout").attrib['TileCount']
if num_tiles == "4": typ = "v2 Micro"
elif num_tiles == "2": typ = "v2 Nano"
elif num_tiles == "14": typ = "v2"
elif num_tiles == "19": typ = "v3"
else: typ = "Unknown ({})".format(num_tiles)
process.udf['Reagent Kit Type'] = typ
process.udf['Run started'] = datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M")
process.put()
def parse_format(xml_file):
"""Parse the xml file to create types, scaling factor types, and scales.
"""
tree = ElementTree()
tree.parse(xml_file)
for param in tree.find("parameters").getchildren():
VARIABLES[param.get("name")] = param.get("value")
types_scales = {}
for prod in tree.find("product"):
ascii = prod.tag in ["mphr", "sphr"]
res = []
for i in prod:
lres = CASES[i.tag](i, ascii)
if lres is not None:
res.append(lres)
types_scales[(prod.tag, int(prod.get("subclass")))] = res
types = {}
stypes = {}
scales = {}
for key, val in types_scales.items():
types[key] = to_dtype(val)
stypes[key] = to_scaled_dtype(val)
scales[key] = to_scales(val)
return types, stypes, scales
def get_package_from_spec(pom_file) -> Package:
"""Create MavenPackage object from pom.xml file."""
tree = ElementTree(file=pom_file)
root = tree.getroot()
# get xml namespace
namespace = re.search(r"({.*})(.*)", root.tag)
namespace = namespace.group(1) if namespace else ''
attributes = [
'groupId', 'artifactId', 'name', 'version', 'description', 'url'
]
package_spec = dict()
for attr in attributes:
try:
val = tree.find(namespace + attr).text
except AttributeError:
# try to look the attr up in the parent tag
parent = tree.find(namespace + 'parent')
if parent:
try:
val = parent.find(namespace + attr).text
except AttributeError:
val = None
else:
val = None
package_spec[attr] = val
package = MavenPackage(**package_spec)
return package
def __init__(self,node,name,converter=None):
self.name=name
node = ElementTree(file=fileName)
node = node.getroot()
node = node.find("drawing").find("library")
if converter==None:
converter=Converter()
symConverter=SchemConverter()
self.modules=[]
self.symbols=[]
packages=node.find("packages").findall("package")
symbols=node.find("symbols").findall("symbol")
if packages !=None:
for package in packages:
self.modules.append(Module(package,converter))
if symbols!=None:
for symbol in symbols:
self.symbols.append(Symbol(symbol,symConverter))
def parse_format(xml_file):
global VARIABLES
tree = ElementTree()
tree.parse(xml_file)
products = tree.find("product")
params = tree.find("parameters")
for param in params.getchildren():
VARIABLES[param.get("name")] = param.get("value")
types = {}
for prod in products:
ascii = (prod.tag in ["mphr", "sphr"])
res = []
for i in prod:
lres = CASES[i.tag](i, ascii)
if lres is not None:
res.append(lres)
types[(prod.tag, int(prod.get("subclass")))] = np.dtype(res)
return types
def vm_read_config(self):
"""
This method parses the libvirt xml config file and fills the
cfg_details dictionary. This method returns the dictionary or
raise exception if xml is not valid.
"""
domain = ET().parse(self.cfg_file)
vm_type = domain.get('type')
self.cfg_details['vm_type'] = HVM_LIBVIRT_NAMEMAP[vm_type]
self.cfg_details['vm_type_str'] = vm_type
self.cfg_details['displayName'] = domain.find('name').text
self.cfg_details['memsize'] = int(domain.find('memory').text) >> 10
primary_disk_list = []
for disk in domain.findall('devices/disk'):
disk_details = self.get_disk_details(disk)
if disk.get('type') == 'file' and \
disk.get('device') == 'disk' and \
disk_details['dev'] in ('sda', 'hda', 'vda') and \
disk_details['bus'] in ('ide', 'scsi', 'virtio'):
primary_disk_list.append(os.path.basename(disk_details['file']))
break
self.cfg_details['primary_disk'] = primary_disk_list
self.cfg_details['primary_disk_str'] = ','.join(primary_disk_list)
if not self.cfg_details:
raise config_file_invalid()
else:
return self.cfg_details
def __init__(self):
self.dialog = {}
self.color = pygame.color.Color("white")
self.layer = []
xml_file = ElementTree().parse(os.path.join(
CONFIG.system_path,
"gui",
CONFIG.general.THEME,
"theme.xml"))
if xml_file.find("color") is not None:
self.color = pygame.color.Color(
xml_file.find("color").attrib["value"])
if xml_file.find("dialog") is not None:
conf_d = xml_file.find("dialog")
w, h = CONFIG.general.WIDTH, CONFIG.general.HEIGHT
self.dialog["sizex"] = int(conf_d.attrib["sizex"]) * w / 100
self.dialog["sizey"] = int(conf_d.attrib["sizey"]) * h / 100
self.dialog["posx"] = int(conf_d.attrib["posx"]) * w / 100
self.dialog["posy"] = int(conf_d.attrib["posy"]) * h / 100
for node in xml_file.findall("layer"):
self.layer.append(Layer(node))
def test_proxy_validate_view_pt_success(self):
"""
When called with a valid ``ProxyTicket``, a ``GET`` request to
the view should return a validation success and the
``ProxyTicket`` should be consumed and invalid for future
validation attempts.
"""
query_str = "?service=%s&ticket=%s" % (self.service_url, self.pt.ticket)
response = self.client.get(reverse("cas_proxy_validate") + query_str)
tree = ElementTree(fromstring(response.content))
elem = tree.find(XMLNS + "authenticationSuccess/" + XMLNS + "user")
self.assertIsNotNone(elem)
self.assertEqual(elem.text, "ellen")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get("Content-Type"), "text/xml")
elem = tree.find(XMLNS + "authenticationSuccess/" + XMLNS + "proxies")
proxy = list(elem.getiterator(XMLNS + "proxy"))
self.assertEqual(len(proxy), 1)
self.assertEqual(proxy[0].text, "http://www.example.com")
# This request should fail as the ticket was consumed in the preceeding test
response = self.client.get(reverse("cas_proxy_validate") + query_str)
tree = ElementTree(fromstring(response.content))
elem = tree.find(XMLNS + "authenticationFailure")
self.assertIsNotNone(elem)
self.assertEqual(elem.get("code"), "INVALID_TICKET")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get("Content-Type"), "text/xml")
def _get_build_metadata(self, dir_name):
if os.path.exists(os.path.join(dir_name, 'jenkins_build.tar.gz')):
raise Skip('the build has already been archived', dir_name)
# Read the build.xml metadata file that Jenkins generates
build_metadata = os.path.join(dir_name, 'build.xml')
if not os.access(build_metadata, os.R_OK):
self.log.debug("Can't read build file at %s" % (build_metadata))
raise Exception("Can't access build.xml at %s" % (build_metadata))
else:
tree = ElementTree()
tree.parse(build_metadata)
keys = ['result', 'number', 'duration']
kv_pairs = ((k, tree.find(k)) for k in keys)
d = dict([(k, v.text) for k, v in kv_pairs if v is not None])
try:
d['branch'] = tree.find('actions') \
.find('hudson.plugins.git.util.BuildData') \
.find('buildsByBranchName') \
.find('entry') \
.find('hudson.plugins.git.util.Build') \
.find('revision') \
.find('branches') \
.find('hudson.plugins.git.Branch') \
.find('name') \
.text
except Exception: # nosec
pass
return d
def parse_fzp(self, fzp_file):
""" Parse the Fritzing component file """
tree = ElementTree(file=fzp_file)
try:
prefix = tree.find('label').text
except AttributeError:
pass
else:
self.component.add_attribute('_prefix', prefix)
symbol = Symbol()
self.component.add_symbol(symbol)
self.body = Body()
symbol.add_body(self.body)
self.cid2termid.update(self.parse_terminals(tree))
self.terminals.update(self.cid2termid.values())
layers = tree.find('views/schematicView/layers')
if layers is None:
self.image = None
else:
self.image = layers.get('image')
def __init__(self, f):
"""Data parsing"""
self.trackers = [] #: tracker properties and data
self.groups = [] #: groups []
self.priorities = [] #: priorities used
self.resolutions = [] #: resolutions (index, name)
self.tickets = [] #: all tickets
self.statuses = [] #: status (idx, name)
self.used_resolutions = {} #: id:name
self.used_categories = {} #: id:name
# id '100' means no category
self.used_categories['100'] = None
self.users = {} #: id:name
root = ElementTree().parse(f)
self.users = dict([(FlatXML(u).userid, FlatXML(u).username) for u in root.find('referenced_users')])
for tracker in root.find('trackers'):
tr = Tracker(tracker)
self.trackers.append(tr)
# groups-versions
for grp in tr.groups:
# group ids are tracker-specific even if names match
g = (grp.id, grp.group_name)
if g not in self.groups:
self.groups.append(g)
# resolutions
for res in tr.resolutions:
r = (res.id, res.name)
if r not in self.resolutions:
self.resolutions.append(r)
# statuses
self.statuses = [(s.id, s.name) for s in tr.statuses]
# tickets
for tck in tr.tracker_items:
if type(tck) == str: print repr(tck)
self.tickets.append(tck)
if int(tck.priority) not in self.priorities:
self.priorities.append(int(tck.priority))
res_id = getattr(tck, "resolution_id", None)
if res_id is not None and res_id not in self.used_resolutions:
for idx, name in self.resolutions:
if idx == res_id: break
self.used_resolutions[res_id] = dict(self.resolutions)[res_id]
# used categories
categories = dict(self.get_categories(tr, noowner=True))
if tck.category_id not in self.used_categories:
self.used_categories[tck.category_id] = categories[tck.category_id]
# sorting everything
self.trackers.sort(key=lambda x:x.name)
self.groups.sort()
self.priorities.sort()
def parse_format(xml_file):
"""Parse the xml file to create types, scaling factor types, and scales.
"""
tree = ElementTree()
tree.parse(xml_file)
for param in tree.find("parameters").getchildren():
VARIABLES[param.get("name")] = param.get("value")
types_scales = {}
for prod in tree.find("product"):
ascii = (prod.tag in ["mphr", "sphr"])
res = []
for i in prod:
lres = CASES[i.tag](i, ascii)
if lres is not None:
res.append(lres)
types_scales[(prod.tag, int(prod.get("subclass")))] = res
types = {}
stypes = {}
scales = {}
for key, val in types_scales.items():
types[key] = to_dtype(val)
stypes[key] = to_scaled_dtype(val)
scales[key] = to_scales(val)
return types, stypes, scales
def replace_information_in_xml_file_flame9(Subdir, XMLFileName):
if Subdir == None:
return "unable to replace information in a file located in a nonexistent directory\n"
elif XMLFileName == None:
return "unable to replace information in a nonexistent file!\n"
else:
tree = ElementTree()
tree.parse(XMLFileName)
xml.etree.ElementTree.register_namespace(
"", "http://PlatformGroup.efi.com/Fiery/SubsystemSetup")
p = tree.find(
".//{http://PlatformGroup.efi.com/Fiery/SubsystemSetup}RecoveryFiles"
)
newp = [p.remove(item) for item in p[1:]]
srcNode = tree.find(
".//{http://PlatformGroup.efi.com/Fiery/SubsystemSetup}RecoverySetupFileCopy"
)
srcNode[0].text = '\\' + Subdir
p = tree.findall(
".//{http://PlatformGroup.efi.com/Fiery/SubsystemSetup}ExternalTaskInfo"
)
for item in p:
temp = item.attrib['MediaMountPoint']
print(temp)
item.attrib['MediaMountPoint'] = "\\" + Subdir + temp
xml.etree.ElementTree.dump(tree)
tree.write(XMLFileName + ".new",
xml_declaration=True,
method='xml',
encoding='UTF-8')
class SchemeReader:
def __init__(self, file_name=None, text=None):
"""
self.xml = f.read();
self.parse();
"""
if (file_name):
f = open(file_name);
self.root = ElementTree(file=f);
self.parse();
f.close();
elif (text):
self.root = fromstring(text);
self.parse();
def parse(self):
"""
bs = BeautifulSoup.BeautifulSoup(self.xml, "xml");
print bs
date_tag = bs.find("Date");
print date_tag
self.date = DateScheme(date_tag);
text_tag = bs.find("Text");
self.text = TextScheme(text_tag);
"""
date_tag = self.root.find("Date");
self.date = DateScheme(date_tag);
text_tag = self.root.find("Text");
self.text = TextScheme(text_tag);
nextpage_tag = self.root.find("NextPage");
if (nextpage_tag):
self.has_nextpage = True;
self.nextpage = NextPageScheme(nextpage_tag);
else:
self.has_nextpage = False;
def parse_fzp(self, fzp_file):
""" Parse the Fritzing component file """
tree = ElementTree(file=fzp_file)
try:
prefix = tree.find('label').text
except AttributeError:
pass
else:
self.component.add_attribute('_prefix', prefix)
symbol = Symbol()
self.component.add_symbol(symbol)
self.body = SBody()
symbol.add_body(self.body)
self.cid2termid.update(self.parse_terminals(tree))
self.terminals.update(self.cid2termid.values())
layers = tree.find('views/schematicView/layers')
if layers is None:
self.image = None
else:
self.image = layers.get('image')
def __init__(self, ttx_path, px_step=200, font_height=4):
with open(ttx_path) as f:
elem_tree = ElementTree(file=f)
self.glyphs = elem_tree.find("glyf")
self.hmtx = elem_tree.find("hmtx")
self.cmap = elem_tree.find("cmap")
self.px_step = px_step
self.font_height = font_height
def _get_statement_el(self, tree: ET.ElementTree) -> ET.Element:
if self.version == CamtVersion.CAMT053:
stmt = tree.find("./s:BkToCstmrStmt/s:Stmt", self.xmlns)
else:
assert self.version == CamtVersion.CAMT052
stmt = tree.find("./s:BkToCstmrAcctRpt/s:Rpt", self.xmlns)
assert stmt is not None
return stmt
def isFormat(self, f):
"""Check if the necessary nodes to match can be extracted from the xml"""
try:
tree = ElementTree()
tree.parse(f)
elem = tree.find("hoomd_xml/position")
elem = tree.find("hoomd_xml/type")
except Exception, e:
return False
def load(self, path):
if not os.path.exists(path):
return
tree = ElementTree()
tree.parse(path)
self.schema_seq = int(tree.find("schema_seq").text)
self.replication_seq = int(tree.find("replication_seq").text)
self.last_replication_time = parse_time(tree.find("last_updated").text)
self.last_finished_time = parse_time(tree.find("last_finished").text)
def isFormat(self, f):
"""Check if the necessary nodes to match can be extracted from the xml"""
try:
tree = ElementTree()
tree.parse(f)
elem = tree.find("hoomd_xml/position")
elem = tree.find("hoomd_xml/type")
except Exception, e:
return False
def load(self, path):
if not os.path.exists(path):
return
tree = ElementTree()
tree.parse(path)
self.schema_seq = int(tree.find("schema_seq").text)
self.replication_seq = int(tree.find("replication_seq").text)
self.last_replication_time = parse_time(tree.find("last_updated").text)
self.last_finished_time = parse_time(tree.find("last_finished").text)
def xmlFileParse(xmlFile):
"Use xml.etree parse XML doc."
tree = ElementTree()
tree.parse(open(xmlFile))
systemInfo = tree.find('SystemInformation')
computerName = getValue(systemInfo.findtext('ComputerName'))
files = tree.find('Files')
fileList = {}
for file in files.iter('File'):
f = File()
f.id = file.get('Id')
f.path = getValue(list(file)[0].text)
f.size = getValue(list(file)[1].text)
f.attributes = getValue(list(file)[2].text)
f.signer = getValue(list(file)[3].text)
f.productName = getValue(list(file)[4].text)
f.productVersion = getValue(list(file)[5].text)
f.companyName = getValue(list(file)[6].text)
f.fileDescription = getValue(list(file)[7].text)
f.originalFilename = getValue(list(file)[8].text)
f.fileVersionLabel = getValue(list(file)[9].text)
f.fileVersionNumber = getValue(list(file)[10].text)
f.sha1 = getValue(list(file)[11].text)
f.md5 = getValue(list(file)[12].text)
f.rootkitInfo = getValue(list(file)[13].text)
f.createTime = getValue(list(file)[14].text)
f.lastAccessTime = getValue(list(file)[15].text)
f.lastWriteTime = getValue(list(file)[16].text)
fileList[f.id] = f
autoruns = tree.find('Autoruns')
autorunList = {}
for autorun in autoruns.iter('Autorun'):
a = Autorun()
a.id = autorun.get('Id')
a.fileId = getValue(list(autorun)[0].text)
a.location = getValue(list(autorun)[1].text)
a.itemName = getValue(list(autorun)[2].text)
a.launchString = getValue(list(autorun)[3].text)
a.groupId = getValue(list(autorun)[4].text)
autorunList[a.id] = a
processes = tree.find('Processes')
processList = {}
for process in processes.iter('Process'):
p = Process()
p.id = process.get('Id')
p.pid = getValue(list(process)[0].text)
p.parentPid = getValue(list(process)[1].text)
p.commandLine = getValue(list(process)[2].text)
p.userName = getValue(list(process)[3].text)
p.fileId = getValue(list(process)[4].text)
for i in range(0, len(list(process)[5])):
p.dlls.append(getValue(list(process)[5][i][0].text))
processList[p.id] = p
return (computerName, fileList, autorunList, processList)
def getSession(self):
#api_response = self.get("SetSession")
api_response = open('gapython/tree.xml')
if api_response is None:
raise("Could not connect to Global Agenda API")
tree = ElementTree(file=api_response)
if tree.find('rec_cd').text is not "0":
raise("Error returned on response" + tree.find('ret_msg').text)
def get_mi_nextseq_container(run_dir):
tree = ElementTree()
try:
tree.parse(os.path.join(run_dir, "runParameters.xml")) # MiSeq
return tree.find("ReagentKitRFIDTag/SerialNumber").text
except IOError:
tree.parse(os.path.join(run_dir, "RunParameters.xml")) # NextSeq
return tree.find("ReagentKitRfidTag/SerialNumber").text
except xml.parsers.expat.ExpatError:
pass # This happens
def _extract_prices_to_csv(self, fullpath, store_name, csv_output_folder):
logging.info("Starting to process file: " + fullpath)
input_file = gzip.open(fullpath, "rb")
strdata = input_file.read()
root = ElementTree(fromstring(strdata))
itemscount = root.find(".//Items")
num = itemscount.attrib.get("Count")
if num > 0:
csv_lines = []
store_id = root.find(".//StoreId").text
chain_id = root.find(".//ChainId").text
sub_chain_id = root.find(".//SubChainId").text
items_elem = root.findall(".//Items/Item")
for item in items_elem:
try:
price_update_date = item.find("PriceUpdateDate")
if price_update_date is not None and price_update_date.text is not None:
price_update_date = price_update_date.text
item_code = item.find("ItemCode")
if item_code is not None and item_code.text is not None:
item_code = item_code.text.encode('utf-8')
item_name = item.find("ItemName")
if item_name is not None and item_name.text is not None:
item_name = item_name.text.replace("#", "-").encode('utf-8')
manufacture_name = item.find("ManufacturerName")
if manufacture_name is not None and manufacture_name.text is not None:
manufacture_name = manufacture_name.text.replace("#", "-").encode('utf-8')
manufacture_country = item.find("ManufactureCountry")
if manufacture_country is not None and manufacture_country.text is not None:
manufacture_country = manufacture_country.text.replace("#", "-").encode('utf-8')
manufacture_item_desc = item.find("ManufacturerItemDescription")
if manufacture_item_desc is not None and manufacture_item_desc.text is not None:
manufacture_item_desc = manufacture_item_desc.text.replace("#", "-").encode('utf-8')
qty = item.find("Quantity")
if qty is not None and qty.text is not None:
qty = qty.text.encode('utf-8')
item_price = item.find("ItemPrice")
if item_price is not None and item_price.text is not None:
item_price = item_price.text.encode('utf-8')
item_id = item.find("ItemId")
if item_id is not None and item_id.text is not None:
item_id = item_id.text.encode('utf-8')
the_line = chain_id+self.csv_line_sep+sub_chain_id+self.csv_line_sep+store_id +\
self.csv_line_sep+item_id + self.csv_line_sep + item_price + self.csv_line_sep + \
qty + self.csv_line_sep + manufacture_name + self.csv_line_sep + manufacture_country + \
self.csv_line_sep + manufacture_item_desc + self.csv_line_sep + item_name + \
self.csv_line_sep + item_code + self.csv_line_sep + price_update_date
csv_lines.append(the_line.decode('utf-8').split(self.csv_line_sep))
except TypeError, e:
logging.error(
"Got problem with one of the xml elements... Error: " + str(e))
except AttributeError, e:
logging.error(
"Got problem with one of the xml elements and couldnt perform an action... Error: " + str(e))
def get_interval_sizes(dtatcfdir, time_boundaries, freq_words, tagset,
join_sign):
"""
Get token frequency in specific time intervals of dta.
:param dtatcfdir: path to directory with dta tcf files
:param time_boundaries: list of time boundaries seperating intervals
:param freq_words: list of words with sufficient frequency
:param tagset: list of POS-tags to include
:param join_sign: sign to join lemma + first char of POS
:return: dictionary, mapping file boundaries to token frequencies
"""
interval_size_dict = defaultdict(int)
print "Getting interval sizes..."
# get the corpus size of each time interval speciified in the input
for root, dirs, files in os.walk(dtatcfdir):
for filename in files:
if ".tcf" in filename:
dta_file = os.path.join(root, filename)
file_boundary = get_file_boundary(time_boundaries, tree)
if file_boundary == 0:
continue
tree = ElementTree()
tree.parse(dta_file)
lemmas = tree.find(
"{http://www.dspin.de/data/textcorpus}TextCorpus/{http://www.dspin.de/data/textcorpus}lemmas"
)
POStags = tree.find(
"{http://www.dspin.de/data/textcorpus}TextCorpus/{http://www.dspin.de/data/textcorpus}POStags"
)
for i, lemma_elem in enumerate(lemmas):
try:
lemma = lemma_elem.text
pos = POStags[i].text
target = lemma + join_sign + pos[
0] # lemma + first char of POS, e.g. run-v / run-n
# only count lemmas which are frequent enough and have the respective POS-tags
if not target in freq_words or not (pos.startswith(x)
for x in tagset):
continue
interval_size_dict[file_boundary] += 1
except:
pass
print "token skipped..."
print interval_size_dict
logging.info(interval_size_dict)
return interval_size_dict
def elevationAntennaPattern(self, burst):
eta_anx = burst.ascendingNodeTime
Ns = burst.numberOfSamples
fs = burst.rangeSampleRate
eta_start = burst.sensingStart
tau0 = burst.slantRangeTime
tau_sub = np.array(burst.slantRangeTimeSub)
theta_sub = np.array(burst.elevationAngle)
###########################################
#Reading the 2 way EAP (Elevation Antenna Pattern from AUX_CAL file)
fp = open(burst.auxFile, 'r')
xml_root = ElementTree(file=fp).getroot()
res = xml_root.find('calibrationParamsList/calibrationParams')
paramsList = xml_root.find('calibrationParamsList')
for par in (paramsList.getchildren()):
if par.find('swath').text == burst.swath and par.find(
'polarisation').text == burst.polarization:
print(par.find('swath').text)
print(par.find('polarisation').text)
delta_theta = float(
par.find('elevationAntennaPattern/elevationAngleIncrement'
).text)
Geap_IQ = [
float(val) for val in par.find(
'elevationAntennaPattern/values').text.split()
]
I = np.array(Geap_IQ[0::2])
Q = np.array(Geap_IQ[1::2])
Geap = I[:] + Q[:] * 1j # Complex vector of Elevation Antenna Pattern
Nelt = np.shape(Geap)[0]
#########################
# Vector of elevation angle in antenna frame
theta_AM = np.arange(-(Nelt - 1.) / 2,
(Nelt - 1.) / 2 + 1) * delta_theta
########################
delta_anx = (eta_start - eta_anx).total_seconds()
theta_offnadir = anx2roll(delta_anx)
theta_eap = theta_AM + theta_offnadir
########################
#interpolate the 2-way complex EAP
tau = tau0 + np.arange(Ns) / fs
from scipy.interpolate import interp1d
# f = interp1d(tau_sub,theta_sub)
# theta = f(tau)
theta = np.interp(tau, tau_sub, theta_sub)
# theta = interpolate(theta_sub,tau_sub,tau)
f2 = interp1d(theta_eap, Geap)
Geap_interpolated = f2(theta) # interpolate(Geap,theta_eap,theta)
# Geap_interpolated = np.interp(theta, theta_eap, Geap)
phi_EAP = np.angle(Geap_interpolated)
cJ = np.complex64(1.0j)
GEAP = np.exp(cJ * phi_EAP)
return GEAP
class xbmcScraper(scraper):
"""
the xbmcScraper class provides a generic ground foundation, which is
required for all XBMC scrapers.
"""
xml = ElementTree() # holds the scraper regex xml tree
addonxml = ElementTree() # xml tree of addon.xml
settingsxml= ElementTree() # xml tree of resources/settings.xml
path = None # filesystem path to scraper
basepath = None # the path which contains the scraper
requires = [] # an array of dicts with the keys: scrpaer, version
deps = [] # contains the dependencies of the scraper as Scraper object
def __init__(self, scraperPath = None):
self.xml = ElementTree()
self.addonxml = ElementTree()
self.settingsxml= ElementTree()
self.requires = []
self.deps = []
if scraperPath:
scraperPath = os.path.normpath(scraperPath)
self.addonxml.parse( os.path.join(scraperPath, "addon.xml") )
xmlpath = self.addonxml.find("extension").attrib["library"]
self.xml.parse( os.path.join(scraperPath, xmlpath) )
if os.path.exists(os.path.join(scraperPath, "resources/settings.xml")):
self.settingsxml.parse( os.path.join(scraperPath, "resources/settings.xml") )
requires = self.addonxml.find("requires")
if requires:
for require in requires.findall("import"):
self.requires.append({})
self.requires[-1]["scraper"] = require.attrib["addon"]
self.requires[-1]["version"] = require.attrib["version"]
else:
logging.warning("could not find <requires> in %s/addon.xml" % scraperPath)
self.basepath = os.path.split(scraperPath)[0]
self.path = scraperPath
if hasattr(self, "__stage2__"):
self.__stage2__()
def __stage2__(self):
""" a customizable appendix to __init__ """
def __resolve_deps__(self):
""" resolve import dependencies of the scraper """
for require in self.requires:
if not require["scraper"] in ["xbmc.metadata",]: # some deps are for xbmc only and are not scraper relevant
logging.info("importing scraper %s as dependency." % require["scraper"])
scraper = getScraper(os.path.join(self.basepath, require["scraper"]))
scraper.__resolve_deps__()
self.xml._setroot( mergeEtree( self.xml.getroot(), scraper.xml.getroot() ) )
def search(self, name):
""" dummy """
def parse(filename):
info = dict()
with zipfile.ZipFile(unicode(filename, 'utf-8')) as zf:
for name in zf.namelist():
if os.path.basename(name) == 'module.xml':
et = ElementTree(file=zf.open(name))
info['name'] = et.find('name').text
info['version'] = et.find('version').text
info['desc'] = et.find('description').text
break
return info
def configure(self, config_tree: ElementTree):
self.name = config_tree.get('name')
config_pins = config_tree.find('pins')
pins = config_pins.findall('pin')
self.extra = config_tree.find('extra')
logging.debug("Found %i pins for %s.", len(pins),
self.__class__.__name__)
for cpin in pins:
self.pins.append(Pin(cpin))
self._post_config()
def remove_trkpt_namespaces(trkpt: ET.ElementTree,
namespaces: Dict[str, str]) -> None:
'''
By default the each trkpt and their sub-elements would have an
"ns0:" prefix on them. We don't want that, so we set the tag
manually.
'''
trkpt.tag = 'trkpt'
ele = trkpt.find('gpx:ele', namespaces)
ele.tag = 'ele'
time = trkpt.find('gpx:time', namespaces)
time.tag = 'time'
def create(self):
assert (self.type in ['A', 'CNAME', 'MX', 'AAAA'])
assert (self.data)
if self._id:
raise AlreadyExists(self.fqdn)
# it works like in Zone.create()
url = Zerigo._url_api \
+ Host._url_template.substitute(zone_id=self.__zone._id)
Zerigo._logger.debug('retrieving ' + url)
template = self._conn.get(url)
tree = ElementTree()
tree.parse(template.body_file)
type = tree.find('host-type')
hostname = tree.find('hostname')
data = tree.find('data')
if type is None or hostname is None or data is None:
raise ParseError()
type.text = self.type
if 'nil' in hostname.attrib:
del hostname.attrib['nil']
hostname.text = self.hostname
if 'nil' in data.attrib:
del data.attrib['nil']
data.text = self.data
form = StringIO.StringIO()
tree.write(form)
form = form.getvalue()
url = Zerigo._url_api + Host._url_create.substitute(
zone_id=self.__zone._id)
# exact same block in Zone; we should find a way to factore this
try:
Zerigo._logger.debug('posting ' + url)
host = self._conn.post(url, body=form)
except restkit.RequestFailed as errors:
errors = StringIO.StringIO(errors)
tree = ElementTree()
tree.parse(errors)
errors = [err.text for err in tree.findall('error')]
raise CreateError(self.fqdn, ', '.join(errors))
# read the id
tree = ElementTree()
tree.parse(host.body_file)
id = tree.find('id')
if id is None or not id.text:
raise ParseError()
self._id = id.text
Zerigo._logger.debug('host ' + self.fqdn + ' created with id: ' +
self._id)
def create(self):
assert(self.type in ['A', 'CNAME', 'MX', 'AAAA'])
assert(self.data)
if self._id:
raise AlreadyExists(self.fqdn)
# it works like in Zone.create()
url = Zerigo._url_api \
+ Host._url_template.substitute(zone_id=self.__zone._id)
Zerigo._logger.debug('retrieving ' + url)
template = self._conn.get(url)
tree = ElementTree()
tree.parse(template.body_file)
type = tree.find('host-type')
hostname = tree.find('hostname')
data = tree.find('data')
if type is None or hostname is None or data is None:
raise ParseError()
type.text = self.type
if 'nil' in hostname.attrib:
del hostname.attrib['nil']
hostname.text = self.hostname
if 'nil' in data.attrib:
del data.attrib['nil']
data.text = self.data
form = StringIO.StringIO()
tree.write(form)
form = form.getvalue()
url = Zerigo._url_api + Host._url_create.substitute(zone_id=self.__zone._id)
# exact same block in Zone; we should find a way to factore this
try:
Zerigo._logger.debug('posting ' + url)
host = self._conn.post(url, body=form)
except restkit.RequestFailed as errors:
errors = StringIO.StringIO(errors)
tree = ElementTree()
tree.parse(errors)
errors = [err.text for err in tree.findall('error')]
raise CreateError(self.fqdn, ', '.join(errors))
# read the id
tree = ElementTree()
tree.parse(host.body_file)
id = tree.find('id')
if id is None or not id.text:
raise ParseError()
self._id = id.text
Zerigo._logger.debug('host ' + self.fqdn + ' created with id: ' + self._id)
def _parseconf(self, filename):
"""Parse the configuration file."""
try:
etree = ElementTree(file=filename)
except Exception:
err = sys.exc_info()[1]
raise ConfigurationError(filename, str(err))
if etree.getroot().tag != "bakonf":
raise ConfigurationError(filename, "XML file root is not bakonf")
self._cur_cfgfile = filename
if self.options.statefile is None:
vpath = etree.find("/config/statefile")
if vpath is None:
self.fs_statefile = DEFAULT_VPATH
else:
self.fs_statefile = vpath.text
else:
self.fs_statefile = self.options.statefile
msize = etree.find("/config/maxsize")
if msize is not None:
try:
self.fs_maxsize = int(msize.text)
except (ValueError, TypeError):
err = sys.exc_info()[1]
raise ConfigurationError(filename, "Invalid maxsize"
" value: %s" % err)
tlist = self._get_extra_sources(filename, etree)
# process scanning targets
for cfile, conft in tlist:
self._cur_cfgfile = cfile
for scan_path in conft.findall("/filesystem/scan"):
self._check_val(scan_path.text, "Invalid scan element")
paths = [os.path.abspath(i) for i in glob.glob(scan_path.text)]
self.fs_include += [ensure_text(i) for i in paths]
# process noscan targets
for noscan_path in conft.findall("/filesystem/noscan"):
self._check_val(noscan_path.text, "Invalid noscan element")
self.fs_exclude.append(ensure_text(noscan_path.text))
# command output
for cmdouts in conft.findall("/commands/storeoutput"):
cmd_line = ensure_text(cmdouts.text)
cmd_dest = ensure_text(cmdouts.get("destination"))
self._check_val(cmd_line, "Invalid storeoutput command")
self.cmd_outputs.append(CmdOutput(cmd_line, cmd_dest))
def convert_svg(filename, varbase, groupcount, scalefactor=256):
from xml.etree.ElementTree import ElementTree
tree = ElementTree()
tree.parse(filename)
# if whichchars:
# whichchars = unicode(whichchars)
# F**K YOU XML!!!!!!!!!!!!!!!!!!!!
ns = re.match("\{.*\}", tree.find(".").tag).group(0)
path = tree.find("%sg/%spath" % (ns, ns))
d = path.get("d")
bezierdata = makebezier(d)
print len(d), len(bezierdata)
# write out data to headerfile
fd = file("%s.c" % varbase, "wb")
fd.write('#include "fontheader.h"\n\n')
# data
fd.write("const bezier_t %s_data[] = {\n" % varbase)
first = True
for b in bezierdata:
if not first:
fd.write(",\n")
first = False
a = tuple(
map(lambda x: int(x * scalefactor),
(b[0][0], b[0][1], b[1][0], b[1][1], b[2][0], b[2][1])))
fd.write("\t{%s, %s, %s, %s, %s, %s}" % a)
fd.write("};\n\n")
# glyphs
fd.write("const glyph_t %s_glyph = " % varbase)
first = True
cumlen = 0
fd.write("{%s, %s, &%s_data[0], %s, " %
("' '", 0, varbase, len(bezierdata)))
groupdata = sort_glyph_to_groups(bezierdata, groupcount)
if groupdata:
starts, lens, pathlens = zip(*groupdata)
else:
starts, lens, pathlens = [], [], []
pathlens = map(lambda x: int(x * scalefactor), pathlens)
fd.write(
list_to_C(starts, maxgroups) + ", " + list_to_C(lens, maxgroups) +
"," + "}")
fd.write(";\n\n")
def _get_supplementary_material(tree, sup):
"""
Given an ElementTree returns supplementary materials as a
dictionary containing url, mimetype and label and caption.
"""
result = {}
sup_tree = ElementTree(sup)
label = sup_tree.find('label')
result['label'] = ''
if label is not None:
result['label'] = label.text
title = sup_tree.find('caption/title')
result['title'] = ''
if title is not None:
title = _strip_whitespace(' '.join(title.itertext()))
result['title'] = title
caption = sup_tree.find('caption')
result['caption'] = ''
if caption is not None:
caption_without_title = []
for node in caption:
if node.tag != 'title':
caption_without_title.append(''.join(node.itertext()))
caption = _strip_whitespace('\n'.join(caption_without_title))
# remove file size and type information, e.g. “(1.3 MB MPG)”
lastline = caption.split('\n')[-1]
if lastline.startswith('(') and lastline.endswith(')'):
caption = ' '.join(caption.split('\n')[:-1])
assert 'Click here' not in caption
result['caption'] = caption
media = sup_tree.find('media')
if media is not None:
try:
result['mimetype'] = media.attrib['mimetype']
result['mime-subtype'] = media.attrib['mime-subtype']
result['href'] = media.attrib['{http://www.w3.org/1999/xlink}href']
except KeyError:
result['mimetype'] = ''
result['mime-subtype'] = ''
result['href'] = ''
result['url'] = _get_supplementary_material_url(
_get_pmcid(tree),
result['href']
)
return result
class Settings:
SETTINGS_FILENAME = "settings.xml"
OAUTH_CONSUMER_KEY_PATH = "oauth/consumerKey"
OAUTH_CONSUMER_SECRET_PATH = "oauth/consumerSecret"
OAUTH_ACCESS_TOKEN_PATH = "oauth/accessToken"
OAUTH_ACCESS_TOKEN_SECRET_PATH = "oauth/accessTokenSecret"
def __init__(self, filename=SETTINGS_FILENAME):
self.settings = ElementTree()
self.settings.parse(filename)
def consumer_secret(self):
consumer_secret = self.settings.find(self.OAUTH_CONSUMER_SECRET_PATH)
if consumer_secret is not None:
return consumer_secret.text
return None
def consumer_key(self):
consumer_key = self.settings.find(self.OAUTH_CONSUMER_KEY_PATH)
if consumer_key is not None:
return consumer_key.text
return None
def access_token(self):
access_token = self.settings.find(self.OAUTH_ACCESS_TOKEN_PATH)
if access_token is not None:
return access_token.text
return None
def access_token_secret(self):
access_token_secret = self.settings.find(self.OAUTH_ACCESS_TOKEN_SECRET_PATH)
if access_token_secret is not None:
return access_token_secret.text
return None
def has_token(self):
return self.access_token() is not None
def write_access(self, access_token, access_token_secret):
xml_oauth = self.settings.find("oauth")
xml_access_token = SubElement(xml_oauth, "accessToken")
xml_access_token.text = access_token
xml_access_token_secret = SubElement(xml_oauth, "accessTokenSecret")
xml_access_token_secret.text = access_token_secret
self.settings.write(self.SETTINGS_FILENAME)
def adaptPARAMS(setName, runNumber, num_classes, runType):
'''
Adapt the parameter file and copy it to STYLENE.
'''
modPARAMS = os.path.splitext(PARAMS)[0] + '-mod.xml'
tree = ElementTree()
tree.parse(PARAMS)
tree.find('run-type').text = str(runType)
tree.find('run-number').text = str(runNumber)
tree.find('set-name').text = str(setName)
tree.find('number-of-classes').text = str(num_classes)
tree.write(modPARAMS, encoding='utf-8')
file_util.copy_file(modPARAMS, newPARAMS)
def add_to_datatypes_conf_xml(datatypes_conf_tree: ET.ElementTree,
consumer_name):
display_tag = ET.Element(
'display', {'file': get_display_app_xml_filename(consumer_name)})
for dt in datatypes_conf_tree.find('registration').findall('datatype'):
if dt.attrib['extension'] == 'json':
dt.append(display_tag)
def build_app_info(self, project_dir):
tiapp = ElementTree()
assets_tiappxml = os.path.join(project_dir, 'build', 'android', 'bin',
'assets', 'tiapp.xml')
self.app_info = {'fullscreen': 'false', 'navbar-hidden': 'false'}
self.app_properties = {}
if not os.path.exists(assets_tiappxml):
shutil.copy(os.path.join(project_dir, 'tiapp.xml'),
assets_tiappxml)
tiapp.parse(open(assets_tiappxml, 'r'))
for key in [
'id', 'name', 'version', 'publisher', 'url', 'copyright',
'description', 'icon', 'analytics', 'guid', 'navbar-hidden',
'fullscreen'
]:
el = tiapp.find(key)
if el != None:
self.app_info[key] = el.text
for property_el in tiapp.findall("property"):
name = property_el.get("name")
type = property_el.get("type")
value = property_el.text
if name == None: continue
if type == None: type = "string"
if value == None: value = ""
self.app_properties[name] = {"type": type, "value": value}
def _is_error_page(page_file):
doc = ElementTree(file=page_file)
title = doc.find("head/title")
page_file.seek(0) ## reset file's current position
if title.text.find("not available") != -1:
return True
return False
def get_pars_from_xml(xmlpath):
assert os.path.exists(xmlpath)
root = ElementTree().parse(xmlpath)
acquisitionSystem = root.find('acquisitionSystem')
n_channels = int(acquisitionSystem.find('nChannels').text)
sample_rate = np.float32(acquisitionSystem.find('samplingRate').text)
return n_channels, sample_rate
def _getTVDBThumbnail(self):
import os, time
if self.id:
# check if the file already exists
if os.path.isfile(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml'):
# if it is older than config['cacherenew'] days, delete the files and download again
if os.path.getctime(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml') < time.time()-(Config['cacherenew']*86400):
os.remove(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml')
if not os.path.isfile(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml'):
URL('http://www.thetvdb.com/api/'+Config['tvdbapikey']+'/series/'+self.id+'/all/'+Config['tvdblang']+'.xml').download(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml')
from xml.etree.ElementTree import ElementTree
tree = ElementTree()
try:
tree.parse(Config['tmpdir']+self.id+'-'+Config['tvdblang']+'.xml')
if Config['posterforpilot'] == True and self.season == 1 and self.episode == 1:
series = tree.find('Series')
if series.find('poster').text:
self.thumbnail = 'http://www.thetvdb.com/banners/'+series.find('poster').text
return True
for episode in tree.findall('Episode'):
if int(episode.find('SeasonNumber').text) == self.season and int(episode.find('EpisodeNumber').text) == self.episode:
if episode.find('filename').text:
self.thumbnail = 'http://www.thetvdb.com/banners/'+episode.find('filename').text
return True
except:
pass
return False
def getSvgGroupElement(tree: ET.ElementTree, key: str) -> ET.Element:
query = f".//default:g[@id='{key}']"
e = tree.find(query, SVGNamespace)
if e is None:
raise Exception("Not Found in SVG.", key)
return e
def update_show_indexer_metadata(self, show_obj):
if self.show_metadata and show_obj and self._has_show_metadata(show_obj):
sickrage.app.log.debug(
"Metadata provider " + self.name + " updating show indexer info metadata file for " + show_obj.name)
nfo_file_path = self.get_show_file_path(show_obj)
try:
with io.open(nfo_file_path, 'rb') as xmlFileObj:
showXML = ElementTree(file=xmlFileObj)
indexerid = showXML.find('id')
root = showXML.getroot()
if indexerid is not None:
indexerid.text = str(show_obj.indexerid)
else:
SubElement(root, "id").text = str(show_obj.indexerid)
# Make it purdy
indentXML(root)
showXML.write(nfo_file_path, encoding='UTF-8')
chmodAsParent(nfo_file_path)
return True
except IOError as e:
sickrage.app.log.error(
"Unable to write file to " + nfo_file_path + " - are you sure the folder is writable? {}".format(
e.message))
def convert_from_xml(self, f):
print(f)
glob.glob(f)
os.chdir(f)
for file in glob.glob("*.xml"):
with open(file, 'r') as f:
xcontent = ElementTree()
xcontent.parse(file)
doc = [
xcontent.find("title").text,
xcontent.find("content").text,
xcontent.find("keywords").text
]
out = open(file + ".txt", "w")
out.write("\n\n".join(doc))
return True
def install_drp_flag(self):
flag_disk_path = os.path.join(rcEnv.paths.pathvar, 'drp_flag.vdisk')
from xml.etree.ElementTree import ElementTree, SubElement
tree = ElementTree()
try:
tree.parse(self.cf)
except Exception as exc:
raise ex.excError("container config parsing error: %s" % exc)
# create the vdisk if it does not exist yet
if not os.path.exists(flag_disk_path):
with open(flag_disk_path, 'w') as f:
f.write('')
f.close()
# check if drp flag is already set up
for disk in tree.getiterator("disk"):
e = disk.find('source')
if e is None:
continue
(dev, path) = e.items()[0]
if path == flag_disk_path:
self.log.info("flag virtual disk already exists")
return
# add vdisk to the vm xml config
self.log.info("install drp flag virtual disk")
devices = tree.find("devices")
e = SubElement(devices, "disk", {'device': 'disk', 'type': 'file'})
SubElement(e, "driver", {'name': 'qemu'})
SubElement(e, "source", {'file': flag_disk_path})
SubElement(e, "target", {'bus': 'virtio', 'dev': 'vdosvc'})
tree.write(self.cf)
def populateIPFVersion(self):
'''
Get IPF version from the manifest file.
'''
if self.manifest is None:
return
nsp = "{http://www.esa.int/safe/sentinel-1.0}"
try:
fp = open(self.manifest, 'r')
root = ElementTree(file=fp).getroot()
fp.close()
elem = root.find('.//metadataObject[@ID="processing"]')
rdict = elem.find('.//xmlData/' + nsp + 'processing/' + nsp +
'facility/' + nsp + 'software').attrib
self.IPFversion = rdict['version']
print('Setting IPF version to : ', self.IPFversion)
except:
print(
'Could not read version number successfully from manifest file: ',
self.manifest)
pass
return
def _load_commands(self, cfg: ET.ElementTree) \
-> List[Tuple[str, Union[str, Dict]]]:
commands = cfg.find("commands")
if commands is None:
return
for cmd in commands:
if cmd.tag == "zfs":
yield ("zfs", cmd.text)
continue
if cmd.tag == "sudo":
yield ("sudo", cmd.text)
continue
name = cmd.attrib["name"]
command = cmd.find("command")
if command is None:
self._log.error("Could not load command %s: Missing <command>",
name)
argcfg = cmd.find("arguments")
arguments = ([] if argcfg is None else list(
[a.text for a in argcfg.findall("arg")]))
yield (name, {
"command": command.text,
"args": arguments,
"use_sudo": cmd.find("sudo") is not None,
"readonly": cmd.find("readonly") is not None,
})
def getInfo(xmlfile, propertyName):
from xml.etree.ElementTree import ElementTree
xmlfp = None
content = None
try:
xmlfp = open(xmlfile, 'r')
xmlx = ElementTree(file=xmlfp).getroot()
#search each possible propertyName
propertyNameList = [
propertyName,
propertyName.lower(),
propertyName.upper(),
propertyName.capitalize()
]
for propertyNameX in propertyNameList:
route = "property[@name='{}']/value".format(propertyNameX)
contentAll = xmlx.find(route)
if contentAll != None:
content = contentAll.text
content = content.strip(
"'") #remove the leading and trailing quote
content = content.strip(
'"') #remove the leading and trailing quote
#print("{}: {}".format(propertyName, content))
break
except (IOError, OSError) as strerr:
print("IOError: %s" % strerr)
return None
finally:
if xmlfp is not None:
xmlfp.close()
return content
