BoghdadyJR/codesearch_python · Datasets at Hugging Face

text stringlengths 75 104k
def to_json_str(self): """Convert data to json string representation. Returns: json representation as string. """ adict = dict(vars(self), sort_keys=True) adict['type'] = self.__class__.__name__ return json.dumps(adict)
def find_file_match(folder_path, regex=''): """ Returns absolute paths of files that match the regex within folder_path and all its children folders. Note: The regex matching is done using the match function of the re module. Parameters ---------- folder_path: string regex: string Returns ------- A list of strings. """ outlist = [] for root, dirs, files in os.walk(folder_path): outlist.extend([os.path.join(root, f) for f in files if re.match(regex, f)]) return outlist
def qquery(xml_thing, xpath_thing, vars=None, funcs=None): ''' Quick query. Convenience for using the MicroXPath engine. Give it some XML and an expression and it will yield the results. No fuss. xml_thing - bytes or string, or amara3.xml.tree node xpath_thing - string or parsed XPath expression vars - optional mapping of variables, name to value funcs - optional mapping of functions, name to function object >>> from amara3.uxml.uxpath import qquery >>> results = qquery(b'<a>1<b>2</b>3</a>', 'a/text()')) >>> next(results).xml_value '1' >>> next(results).xml_value '3' ''' root = None if isinstance(xml_thing, nodetype): root = xml_thing elif isinstance(xml_thing, str): tb = tree.treebuilder() root = tb.parse(xml_thing) elif isinstance(xml_thing, bytes): tb = tree.treebuilder() #Force UTF-8 root = tb.parse(xml_thing.decode('utf-8')) if not root: return if isinstance(xpath_thing, str): parsed_expr = parse(xpath_thing) ctx = context(root, variables=vars, functions=funcs) result = parsed_expr.compute(ctx) yield from result
def p_function_call(p): """ FunctionCall : NAME FormalArguments """ #Hacking around the ambiguity between node type test & function call if p[1] in ('node', 'text'): p[0] = ast.NodeType(p[1]) else: p[0] = ast.FunctionCall(p[1], p[2])
def boolean_arg(ctx, obj): ''' Handles LiteralObjects as well as computable arguments ''' if hasattr(obj, 'compute'): obj = next(obj.compute(ctx), False) return to_boolean(obj)
def number_arg(ctx, obj): ''' Handles LiteralObjects as well as computable arguments ''' if hasattr(obj, 'compute'): obj = next(obj.compute(ctx), False) return to_number(obj)
def string_arg(ctx, obj): ''' Handles LiteralObjects as well as computable arguments ''' if hasattr(obj, 'compute'): obj = next(obj.compute(ctx), False) return to_string(obj)
def name(ctx, obj=None): ''' Yields one string a node name or the empty string, operating on the first item in the provided obj, or the current item if obj is omitted If this item is a node, yield its node name (generic identifier), otherwise yield '' If obj is provided, but empty, yield '' ''' if obj is None: item = ctx.item elif hasattr(obj, 'compute'): item = next(obj.compute(ctx), None) else: item = obj if isinstance(item, node): yield item.xml_name else: yield ''
def string_(ctx, seq=None): ''' Yields one string, derived from the argument literal (or the first item in the argument sequence, unless empty in which case yield '') as follows: * If a node, yield its string-value * If NaN, yield 'NaN' * If +0 or -0, yield '0' * If positive infinity, yield 'Infinity' * If negative infinity, yield '-Infinity' * If an integer, no decimal point and no leading zeros * If a non-integer number, at least one digit before the decimal point and at least one digit after * If boolean, either 'true' or 'false' ''' if seq is None: item = ctx.item elif hasattr(seq, 'compute'): item = next(seq.compute(ctx), '') else: item = seq yield next(to_string(item), '')
def concat(ctx, *strings): ''' Yields one string, concatenation of argument strings ''' strings = flatten([ (s.compute(ctx) if callable(s) else s) for s in strings ]) strings = (next(string_arg(ctx, s), '') for s in strings) #assert(all(map(lambda x: isinstance(x, str), strings))) #FIXME: Check arg types yield ''.join(strings)
def starts_with(ctx, full, part): ''' Yields one boolean, whether the first string starts with the second ''' full = next(string_arg(ctx, full), '') part = next(string_arg(ctx, part), '') yield full.startswith(part)
def contains(ctx, full, part): ''' Yields one boolean, whether the first string contains the second ''' full = next(string_arg(ctx, full), '') part = next(string_arg(ctx, part), '') yield part in full
def substring_before(ctx, full, part): ''' Yields one string ''' full = next(string_arg(ctx, full), '') part = next(string_arg(ctx, part), '') yield full.partition(part)[0]
def substring_after(ctx, full, part): ''' Yields one string ''' full = next(string_arg(ctx, full), '') part = next(string_arg(ctx, part), '') yield full.partition(part)[-1]
def substring(ctx, full, start, length): ''' Yields one string ''' full = next(string_arg(ctx, full), '') start = int(next(to_number(start))) length = int(next(to_number(length))) yield full[start-1:start-1+length]
def string_length(ctx, s=None): ''' Yields one number ''' if s is None: s = ctx.node elif callable(s): s = next(s.compute(ctx), '') yield len(s)
def boolean(ctx, obj): ''' Yields one boolean, false if the argument sequence is empty, otherwise * false if the first item is a boolean and false * false if the first item is a number and positive or negative zero or NaN * false if the first item is a string and '' * true in all other cases ''' if hasattr(obj, 'compute'): obj = next(seq.compute(ctx), '') else: obj = seq yield next(to_boolean(obj), '')
def number(ctx, seq=None): ''' Yields one float, derived from the first item in the argument sequence (unless empty in which case yield NaN) as follows: * If string with optional whitespace followed by an optional minus sign followed by a Number followed by whitespace, converte to the IEEE 754 number that is nearest (according to the IEEE 754 round-to-nearest rule) to the mathematical value represented by the string; in case of any other string yield NaN * If boolean true yield 1; if boolean false yield 0 * If a node convert to string as if by a call to string(); yield the same value as if passed that string argument to number() ''' if hasattr(obj, 'compute'): obj = next(seq.compute(ctx), '') else: obj = seq yield next(to_number(obj), '')
def foreach_(ctx, seq, expr): ''' Yields the result of applying an expression to each item in the input sequence. * seq: input sequence * expr: expression to be converted to string, then dynamically evaluated for each item on the sequence to produce the result ''' from . import context, parse as uxpathparse if hasattr(seq, 'compute'): seq = seq.compute(ctx) expr = next(string_arg(ctx, expr), '') pexpr = uxpathparse(expr) for item in seq: innerctx = ctx.copy(item=item) yield from pexpr.compute(innerctx)
def lookup_(ctx, tableid, key): ''' Yields a sequence of a single value, the result of looking up a value from the tables provided in the context, or an empty sequence if lookup is unsuccessful * tableid: id of the lookup table to use * expr: expression to be converted to string, then dynamically evaluated for each item on the sequence to produce the result ''' tableid = next(string_arg(ctx, tableid), '') key = next(string_arg(ctx, key), '') #value = ctx. for item in seq: innerctx = ctx.copy(item=item) yield from pexpr.compute(innerctx)
def replace_chars_for_svg_code(svg_content): """ Replace known special characters to SVG code. Parameters ---------- svg_content: str Returns ------- corrected_svg: str Corrected SVG content """ result = svg_content svg_char = [ ('&', '&'), ('>', '>'), ('<', '<'), ('"', '"'), ] for c, entity in svg_char: result = result.replace(c, entity) return result
def _check_svg_file(svg_file): """ Try to read a SVG file if `svg_file` is a string. Raise an exception in case of error or return the svg object. If `svg_file` is a svgutils svg object, will just return it. Parameters ---------- svg_file: str or svgutils.transform.SVGFigure object If a `str`: path to a '.svg' file, otherwise a svgutils svg object is expected. Returns ------- svgutils svg object Raises ------ Exception if any error happens. """ if isinstance(svg_file, str): try: svg = sg.fromfile(svg_file) except Exception as exc: raise Exception('Error reading svg file {}.'.format(svg_file)) from exc else: return svg if isinstance(svg_file, sg.SVGFigure): return svg_file raise ValueError('Expected `svg_file` to be `str` or `svgutils.SVG`, got {}.'.format(type(svg_file)))
def merge_svg_files(svg_file1, svg_file2, x_coord, y_coord, scale=1): """ Merge `svg_file2` in `svg_file1` in the given positions `x_coord`, `y_coord` and `scale`. Parameters ---------- svg_file1: str or svgutils svg document object Path to a '.svg' file. svg_file2: str or svgutils svg document object Path to a '.svg' file. x_coord: float Horizontal axis position of the `svg_file2` content. y_coord: float Vertical axis position of the `svg_file2` content. scale: float Scale to apply to `svg_file2` content. Returns ------- `svg1` svgutils object with the content of 'svg_file2' """ svg1 = _check_svg_file(svg_file1) svg2 = _check_svg_file(svg_file2) svg2_root = svg2.getroot() svg1.append([svg2_root]) svg2_root.moveto(x_coord, y_coord, scale=scale) return svg1
def rsvg_export(input_file, output_file, dpi=90, rsvg_binpath=None): """ Calls the `rsvg-convert` command, to convert a svg to a PDF (with unicode). Parameters ---------- rsvg_binpath: str Path to `rsvg-convert` command input_file: str Path to the input file output_file: str Path to the output file Returns ------- return_value Command call return value """ if not os.path.exists(input_file): log.error('File {} not found.'.format(input_file)) raise IOError((0, 'File not found.', input_file)) if rsvg_binpath is None: rsvg_binpath = which('rsvg-convert') check_command(rsvg_binpath) args_strings = [] args_strings += ["-f pdf"] args_strings += ["-o {}".format(output_file)] args_strings += ["--dpi-x {}".format(dpi)] args_strings += ["--dpi-y {}".format(dpi)] args_strings += [input_file] return call_command(rsvg_binpath, args_strings)
def merge_pdfs(pdf_filepaths, out_filepath): """ Merge all the PDF files in `pdf_filepaths` in a new PDF file `out_filepath`. Parameters ---------- pdf_filepaths: list of str Paths to PDF files. out_filepath: str Path to the result PDF file. Returns ------- path: str The output file path. """ merger = PdfFileMerger() for pdf in pdf_filepaths: merger.append(PdfFileReader(open(pdf, 'rb'))) merger.write(out_filepath) return out_filepath
def _embed_font_to_svg(filepath, font_files): """ Return the ElementTree of the SVG content in `filepath` with the font content embedded. """ with open(filepath, 'r') as svgf: tree = etree.parse(svgf) if not font_files: return tree fontfaces = FontFaceGroup() for font_file in font_files: fontfaces.append(FontFace(font_file)) for element in tree.iter(): if element.tag.split("}")[1] == 'svg': break element.insert(0, fontfaces.xml_elem) return tree
def embed_font_to_svg(filepath, outfile, font_files): """ Write ttf and otf font content from `font_files` in the svg file in `filepath` and write the result in `outfile`. Parameters ---------- filepath: str The SVG file whose content must be modified. outfile: str The file path where the result will be written. font_files: iterable of str List of paths to .ttf or .otf files. """ tree = _embed_font_to_svg(filepath, font_files) tree.write(outfile, encoding='utf-8', pretty_print=True)
def _check_inputs(self): ''' make some basic checks on the inputs to make sure they are valid''' try: _ = self._inputs[0] except TypeError: raise RuntimeError( "inputs should be iterable but found type='{0}', value=" "'{1}'".format(type(self._inputs), str(self._inputs))) from melody.inputs import Input for check_input in self._inputs: if not isinstance(check_input, Input): raise RuntimeError( "input should be a subclass of the Input class but " "found type='{0}', value='{1}'".format(type(check_input), str(check_input)))
def _check_function(self): ''' make some basic checks on the function to make sure it is valid''' # note, callable is valid for Python 2 and Python 3.2 onwards but # not inbetween if not callable(self._function): raise RuntimeError( "provided function '{0}' is not callable". format(str(self._function))) from inspect import getargspec arg_info = getargspec(self._function) if len(arg_info.args) != 1: print str(arg_info) raise RuntimeError( "provided function should have one argument but found " "{0}".format(len(arg_info.args)))
def _recurse(self, inputs, output): '''internal recursion routine called by the run method that generates all input combinations''' if inputs: my_input = inputs[0] name = my_input.name if my_input.state: my_options = my_input.options(self.state) else: my_options = my_input.options for option in my_options: my_output = list(output) my_output.append({name: option}) self._recurse(inputs[1:], my_output) else: try: valid, result = self._function(output) except ValueError: raise RuntimeError("function must return 2 values") print output, valid, result
def create_input(option, template_name, template_location="template"): '''create an input file using jinja2 by filling a template with the values from the option variable passed in.''' # restructure option list into jinja2 input format jinja2_input = {} for item in option: try: jinja2_input.update(item) except ValueError: raise RuntimeError( ("inputs.py, create_input : format of item '{0}' is not " "supported. Expecting a dictionary.".format(str(item)))) # load the template and fill it with the option variable contents import jinja2 try: template_loader = jinja2.FileSystemLoader(searchpath=template_location) template_env = jinja2.Environment(loader=template_loader) template = template_env.get_template(template_name) output_text = template.render(jinja2_input) except jinja2.TemplateNotFound: raise RuntimeError("template '{0}' not found".format(template_name)) # return the particular input file as a string return output_text
def _recurse(self, inputs, output, depth, max_depth): '''We work out all combinations using this internal recursion method''' if depth < max_depth: for index, option in enumerate(inputs): my_output = list(output) my_output.append(option) self._recurse(inputs[index + 1:], my_output, depth + 1, max_depth) else: self._options.append(output)
def to_string(obj): ''' Cast an arbitrary object or sequence to a string type ''' if isinstance(obj, LiteralWrapper): val = obj.obj elif isinstance(obj, Iterable) and not isinstance(obj, str): val = next(obj, None) else: val = obj if val is None: yield '' elif isinstance(val, str): yield val elif isinstance(val, node): yield strval(val) elif isinstance(val, int) or isinstance(val, float): yield str(val) elif isinstance(item, bool): yield 'true' if item else 'false' else: raise RuntimeError('Unknown type for string conversion: {}'.format(val))
def to_number(obj): ''' Cast an arbitrary object or sequence to a number type ''' if isinstance(obj, LiteralWrapper): val = obj.obj elif isinstance(obj, Iterable) and not isinstance(obj, str): val = next(obj, None) else: val = obj if val is None: #FIXME: Should be NaN, not 0 yield 0 elif isinstance(val, str): yield float(val) elif isinstance(val, node): yield float(strval(val)) elif isinstance(val, int) or isinstance(val, float): yield val else: raise RuntimeError('Unknown type for number conversion: {}'.format(val))
def to_boolean(obj): ''' Cast an arbitrary sequence to a boolean type ''' #if hasattr(obj, '__iter__'): if isinstance(obj, LiteralWrapper): val = obj.obj elif isinstance(obj, Iterable) and not isinstance(obj, str): val = next(obj, None) else: val = obj if val is None: yield False elif isinstance(val, bool): yield val elif isinstance(val, str): yield bool(str) elif isinstance(val, node): yield True elif isinstance(val, float) or isinstance(val, int): yield bool(val) else: raise RuntimeError('Unknown type for boolean conversion: {}'.format(val))
def _serialize(xp_ast): '''Generate token strings which, when joined together, form a valid XPath serialization of the AST.''' if hasattr(xp_ast, '_serialize'): for tok in xp_ast._serialize(): yield(tok) elif isinstance(xp_ast, str): yield(repr(xp_ast))
def change_xml_encoding(filepath, src_enc, dst_enc='utf-8'): """ Modify the encoding entry in the XML file. Parameters ---------- filepath: str Path to the file to be modified. src_enc: str Encoding that is written in the file dst_enc: str Encoding to be set in the file. """ enc_attr = "encoding='{}'" replace_file_content(filepath, enc_attr.format(src_enc), enc_attr.format(dst_enc), 1)
def save_into_qrcode(text, out_filepath, color='', box_size=10, pixel_size=1850): """ Save `text` in a qrcode svg image file. Parameters ---------- text: str The string to be codified in the QR image. out_filepath: str Path to the output file color: str A RGB color expressed in 6 hexadecimal values. box_size: scalar Size of the QR code boxes. """ try: qr = qrcode.QRCode(version=1, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=box_size, border=0, ) qr.add_data(text) qr.make(fit=True) except Exception as exc: raise Exception('Error trying to generate QR code ' ' from `vcard_string`: {}'.format(text)) from exc else: img = qr.make_image(image_factory=qrcode.image.svg.SvgPathImage) _ = _qrcode_to_file(img, out_filepath) if color: replace_file_content(out_filepath, 'fill:#000000', 'fill:#{}'.format(color))
def _qrcode_to_file(qrcode, out_filepath): """ Save a `qrcode` object into `out_filepath`. Parameters ---------- qrcode: qrcode object out_filepath: str Path to the output file. """ try: qrcode.save(out_filepath) except Exception as exc: raise IOError('Error trying to save QR code file {}.'.format(out_filepath)) from exc else: return qrcode
def handle_cdata(pos, window, charpat, stopchars): ''' Return (result, new_position) tuple. Result is cdata string if possible and None if more input is needed Or of course bad syntax can raise a RuntimeError ''' cdata = '' cursor = start = pos try: while True: while charpat.match(window[cursor]): cursor += 1 addchars = window[start:cursor] cdata += addchars #if window[pos] != openattr: # raise RuntimeError('Mismatch in attribute quotes') if window[cursor] in stopchars: return cdata, cursor #Check for charref elif window[cursor] == '&': start = cursor = cursor + 1 if window[cursor] == '#' and window[cursor + 1] == 'x': #Numerical charref start = cursor = cursor + 2 while True: if HEXCHARENTOK.match(window[cursor]): cursor += 1 elif window[cursor] == ';': c = chr(int(window[start:cursor], 16)) if not CHARACTER.match(c): raise RuntimeError('Character reference gives an illegal character: {0}'.format('&' + window[start:cursor] + ';')) cdata += c break else: raise RuntimeError('Illegal in character entity: {0}'.format(window[cursor])) else: #Named charref while True: if NAMEDCHARENTOK.match(window[cursor]): cursor += 1 elif window[cursor] == ';': for cn, c in CHARNAMES: if window[start:cursor] == cn: cdata += c #cursor += 1 #Skip ; break else: raise RuntimeError('Unknown named character reference: {0}'.format(repr(window[start:cursor]))) break else: raise RuntimeError('Illegal in character reference: {0} (around {1})'.format(window[cursor]), error_context(window, start, cursor)) #print(start, cursor, cdata, window[cursor]) cursor += 1 start = cursor except IndexError: return None, cursor
def launch(option): '''Set the gromacs input data using the supplied input options, run gromacs and extract and return the required outputs.''' from melody.inputs import create_input _ = create_input(option, template_name="input.mdp") # save the input file in the appropriate place and launch gromacs using # longbow ... # determine if the run was successful success = True results = None if success: # extract the required outputs results = {"rate": {"value": 35, "units": "ns/day"}, } return success, results
def call_command(cmd_name, args_strings): """Call CLI command with arguments and returns its return value. Parameters ---------- cmd_name: str Command name or full path to the binary file. arg_strings: str Argument strings list. Returns ------- return_value Command return value. """ if not os.path.isabs(cmd_name): cmd_fullpath = which(cmd_name) else: cmd_fullpath = cmd_name try: cmd_line = [cmd_fullpath] + args_strings log.debug('Calling: `{}`.'.format(' '.join(cmd_line))) # retval = subprocess.check_call(cmd_line) retval = subprocess.call(' '.join(cmd_line), shell=True) except CalledProcessError as ce: log.exception( "Error calling command with arguments: " "{} \n With return code: {}".format(cmd_line, ce.returncode) ) raise else: return retval
def getCSV(self): """ Returns ------- filename: str """ import getpass import gspread user = raw_input("Insert Google username:") password = getpass.getpass(prompt="Insert password:") name = raw_input("SpreadSheet filename on Drive:") sheet = raw_input("Sheet name (first sheet is default):") cl = gspread.login(user, password) sh = cl.open(name) if not (sheet.strip()): ws = sh.sheet1 sheet = "1" else: ws = sh.worksheet(sheet) filename = name + '-worksheet_' + sheet + '.csv' with open(filename, 'wb') as f: writer = UnicodeWriter(f) writer.writerows(ws.get_all_values()) return filename
def write(elem, a_writer): ''' Write a MicroXML element node (yes, even one representign a whole document) elem - Amara MicroXML element node to be written out writer - instance of amara3.uxml.writer to implement the writing process ''' a_writer.start_element(elem.xml_name, attribs=elem.xml_attributes) for node in elem.xml_children: if isinstance(node, tree.element): write(node, a_writer) elif isinstance(node, tree.text): a_writer.text(node) a_writer.end_element(elem.xml_name) return
def tex2pdf(tex_file, output_file=None, output_format='pdf'): """ Call PDFLatex to convert TeX files to PDF. Parameters ---------- tex_file: str Path to the input LateX file. output_file: str Path to the output PDF file. If None, will use the same output directory as the tex_file. output_format: str Output file format. Choices: 'pdf' or 'dvi'. Default: 'pdf' Returns ------- return_value PDFLatex command call return value. """ if not os.path.exists(tex_file): raise IOError('Could not find file {}.'.format(tex_file)) if output_format != 'pdf' and output_format != 'dvi': raise ValueError("Invalid output format given {}. Can only accept 'pdf' or 'dvi'.".format(output_format)) cmd_name = 'pdflatex' check_command(cmd_name) args_strings = [cmd_name] if output_file is not None: args_strings += ['-output-directory="{}" '.format(os.path.abspath(os.path.dirname(output_file)))] result_dir = os.path.dirname(output_file) if output_file else os.path.dirname(tex_file) args_strings += ['-output-format="{}"'.format(output_format)] args_strings += ['"' + tex_file + '"'] log.debug('Calling command {} with args: {}.'.format(cmd_name, args_strings)) ret = simple_call(args_strings) result_file = os.path.join(result_dir, remove_ext(os.path.basename(tex_file)) + '.' + output_format) if os.path.exists(result_file): shutil.move(result_file, output_file) else: raise IOError('Could not find PDFLatex result file.') log.debug('Cleaning .aux and .log files from folder {}.'.format(result_dir)) cleanup(result_dir, 'aux') cleanup(result_dir, 'log') return ret
def options(self, my_psy): '''Returns all potential loop fusion options for the psy object provided''' # compute options dynamically here as they may depend on previous # changes to the psy tree my_options = [] invokes = my_psy.invokes.invoke_list #print "there are {0} invokes".format(len(invokes)) if self._dependent_invokes: raise RuntimeError( "dependent invokes assumes fusion in one invoke might " "affect fusion in another invoke. This is not yet " "implemented") else: # treat each invoke separately for idx, invoke in enumerate(invokes): print "invoke {0}".format(idx) # iterate through each outer loop for loop in invoke.schedule.loops(): if loop.loop_type == "outer": siblings = loop.parent.children my_index = siblings.index(loop) option = [] self._recurse(siblings, my_index, option, my_options, invoke) return my_options
def transform(geom, to_sref): """Returns a transformed Geometry. Arguments: geom -- any coercible Geometry value or Envelope to_sref -- SpatialReference or EPSG ID as int """ # If we have an envelope, assume it's in the target sref. try: geom = getattr(geom, 'polygon', Envelope(geom).polygon) except (TypeError, ValueError): pass else: geom.AssignSpatialReference(to_sref) try: geom_sref = geom.GetSpatialReference() except AttributeError: return transform(Geometry(geom), to_sref) if geom_sref is None: raise Exception('Cannot transform from unknown spatial reference') # Reproject geom if necessary if not geom_sref.IsSame(to_sref): geom = geom.Clone() geom.TransformTo(to_sref) return geom
def Geometry(args, kwargs): """Returns an ogr.Geometry instance optionally created from a geojson str or dict. The spatial reference may also be provided. """ # Look for geojson as a positional or keyword arg. arg = kwargs.pop('geojson', None) or len(args) and args[0] try: srs = kwargs.pop('srs', None) or arg.srs.wkt except AttributeError: srs = SpatialReference(4326) if hasattr(arg, 'keys'): geom = ogr.CreateGeometryFromJson(json.dumps(arg)) elif hasattr(arg, 'startswith'): # WKB as hexadecimal string. char = arg[0] if arg else ' ' i = char if isinstance(char, int) else ord(char) if i in (0, 1): geom = ogr.CreateGeometryFromWkb(arg) elif arg.startswith('{'): geom = ogr.CreateGeometryFromJson(arg) elif arg.startswith('<gml'): geom = ogr.CreateGeometryFromGML(arg) else: raise ValueError('Invalid geometry value: %s' % arg) elif hasattr(arg, 'wkb'): geom = ogr.CreateGeometryFromWkb(bytes(arg.wkb)) else: geom = ogr.Geometry(args, **kwargs) if geom: if not isinstance(srs, SpatialReference): srs = SpatialReference(srs) geom.AssignSpatialReference(srs) return geom
def centroid(self): """Returns the envelope centroid as a (x, y) tuple.""" return self.min_x + self.width * 0.5, self.min_y + self.height * 0.5
def expand(self, other): """Expands this envelope by the given Envelope or tuple. Arguments: other -- Envelope, two-tuple, or four-tuple """ if len(other) == 2: other += other mid = len(other) // 2 self.ll = map(min, self.ll, other[:mid]) self.ur = map(max, self.ur, other[mid:])
def intersect(self, other): """Returns the intersection of this and another Envelope.""" inter = Envelope(tuple(self)) if inter.intersects(other): mid = len(other) // 2 inter.ll = map(max, inter.ll, other[:mid]) inter.ur = map(min, inter.ur, other[mid:]) else: inter.ll = (0, 0) inter.ur = (0, 0) return inter
def intersects(self, other): """Returns true if this envelope intersects another. Arguments: other -- Envelope or tuple of (minX, minY, maxX, maxY) """ try: return (self.min_x <= other.max_x and self.max_x >= other.min_x and self.min_y <= other.max_y and self.max_y >= other.min_y) except AttributeError: return self.intersects(Envelope(other))
def scale(self, xfactor, yfactor=None): """Returns a new envelope rescaled from center by the given factor(s). Arguments: xfactor -- int or float X scaling factor yfactor -- int or float Y scaling factor """ yfactor = xfactor if yfactor is None else yfactor x, y = self.centroid xshift = self.width * xfactor * 0.5 yshift = self.height * yfactor * 0.5 return Envelope(x - xshift, y - yshift, x + xshift, y + yshift)
def polygon(self): """Returns an OGR Geometry for this envelope.""" ring = ogr.Geometry(ogr.wkbLinearRing) for coord in self.ll, self.lr, self.ur, self.ul, self.ll: ring.AddPoint_2D(*coord) polyg = ogr.Geometry(ogr.wkbPolygon) polyg.AddGeometryDirectly(ring) return polyg
def from_name(cls, name): "Imports a mass table from a file" filename = os.path.join(package_dir, 'data', name + '.txt') return cls.from_file(filename, name)
def from_file(cls, filename, name=''): "Imports a mass table from a file" df = pd.read_csv(filename, header=0, delim_whitespace=True, index_col=[0, 1])['M'] df.name = name return cls(df=df, name=name)
def from_ZNM(cls, Z, N, M, name=''): """ Creates a table from arrays Z, N and M Example: ________ >>> Z = [82, 82, 83] >>> N = [126, 127, 130] >>> M = [-21.34, -18.0, -14.45] >>> Table.from_ZNM(Z, N, M, name='Custom Table') Z N 82 126 -21.34 127 -18.00 83 130 -14.45 Name: Custom Table, dtype: float64 """ df = pd.DataFrame.from_dict({'Z': Z, 'N': N, 'M': M}).set_index(['Z', 'N'])['M'] df.name = name return cls(df=df, name=name)
def to_file(self, path): """Export the contents to a file as comma separated values. Parameters ---------- path : string File path where the data should be saved to Example ------- Export the last ten elements of AME2012 to a new file: >>> Table('AME2012').tail(10).to_file('last_ten.txt') """ with open(path, 'w') as f: f.write('Z N M\n') self.df.to_csv(path, sep='\t', mode='a')
def select(self, condition, name=''): """ Selects nuclei according to a condition on Z,N or M Parameters ---------- condition : function, Can have one of the signatures f(M), f(Z,N) or f(Z, N, M) must return a boolean value name: string, optional name for the resulting Table Example: -------- Select all nuclei with A > 160: >>> A_gt_160 = lambda Z,N: Z + N > 160 >>> Table('AME2003').select(A_gt_160) """ if condition.func_code.co_argcount == 1: idx = [(Z, N) for (Z, N), M in self if condition(M)] if condition.func_code.co_argcount == 2: idx = [(Z, N) for (Z, N) in self.index if condition(Z, N)] if condition.func_code.co_argcount == 3: idx = [(Z, N) for (Z, N), M in self if condition(Z, N, M)] index = pd.MultiIndex.from_tuples(idx, names=['Z', 'N']) return Table(df=self.df.ix[index], name=name)
def at(self, nuclei): """Return a selection of the Table at positions given by ``nuclei`` Parameters ---------- nuclei: list of tuples A list where each element is tuple of the form (Z,N) Example ------- Return binding energies at magic nuclei: >>> magic_nuclei = [(20,28), (50,50), (50,82), (82,126)] >>> Table('AME2012').binding_energy.at(magic_nuclei) Z N 20 28 416.014215 50 50 825.325172 82 1102.876416 82 126 1636.486450 """ index = pd.MultiIndex.from_tuples(nuclei, names=['Z', 'N']) return Table(df=self.df.ix[index], name=self.name)
def intersection(self, table): """ Select nuclei which also belong to ``table`` Parameters ---------- table: Table, Table object Example: ---------- Table('AME2003').intersection(Table('AME1995')) """ idx = self.df.index & table.df.index return Table(df=self.df[idx], name=self.name)
def not_in(self, table): """ Select nuclei not in table Parameters ---------- table: Table, Table object from where nuclei should be removed Example: ---------- Find the new nuclei in AME2003 with Z,N >= 8: >>> Table('AME2003').not_in(Table('AME1995'))[8:,8:].count 389 """ idx = self.df.index - table.df.index return Table(df=self.df[idx], name=self.name)
def odd_odd(self): """Selects odd-odd nuclei from the table: >>> Table('FRDM95').odd_odd Out[13]: Z N 9 9 1.21 11 0.10 13 3.08 15 9.32 ... """ return self.select(lambda Z, N: (Z % 2) and (N % 2), name=self.name)
def odd_even(self): """ Selects odd-even nuclei from the table """ return self.select(lambda Z, N: (Z % 2) and not(N % 2), name=self.name)
def even_odd(self): """ Selects even-odd nuclei from the table """ return self.select(lambda Z, N: not(Z % 2) and (N % 2), name=self.name)
def even_even(self): """ Selects even-even nuclei from the table """ return self.select(lambda Z, N: not(Z % 2) and not(N % 2), name=self.name)
def error(self, relative_to='AME2003'): """ Calculate error difference Parameters ---------- relative_to : string, a valid mass table name. Example: ---------- >>> Table('DUZU').error(relative_to='AME2003') """ df = self.df - Table(relative_to).df return Table(df=df)
def rmse(self, relative_to='AME2003'): """Calculate root mean squared error Parameters ---------- relative_to : string, a valid mass table name. Example: ---------- >>> template = '{0:10}\|{1:^6.2f}\|{2:^6.2f}\|{3:^6.2f}' >>> print 'Model ', 'AME95 ', 'AME03 ', 'AME12 ' # Table header ... for name in Table.names: ... print template.format(name, Table(name).rmse(relative_to='AME1995'), ... Table(name).rmse(relative_to='AME2003'), ... Table(name).rmse(relative_to='AME2012')) Model AME95 AME03 AME12 AME2003 \| 0.13 \| 0.00 \| 0.13 AME2003all\| 0.42 \| 0.40 \| 0.71 AME2012 \| 0.16 \| 0.13 \| 0.00 AME2012all\| 0.43 \| 0.43 \| 0.69 AME1995 \| 0.00 \| 0.13 \| 0.16 AME1995all\| 0.00 \| 0.17 \| 0.21 DUZU \| 0.52 \| 0.52 \| 0.76 FRDM95 \| 0.79 \| 0.78 \| 0.95 KTUY05 \| 0.78 \| 0.77 \| 1.03 ETFSI12 \| 0.84 \| 0.84 \| 1.04 HFB14 \| 0.84 \| 0.83 \| 1.02 """ error = self.error(relative_to=relative_to) return math.sqrt((error.df ** 2).mean())
def binding_energy(self): """ Return binding energies instead of mass excesses """ M_P = 938.2723 # MeV M_E = 0.5110 # MeV M_N = 939.5656 # MeV AMU = 931.494028 # MeV df = self.Z * (M_P + M_E) + (self.A - self.Z) * M_N - (self.df + self.A * AMU) return Table(df=df, name='BE' + '(' + self.name + ')')
def q_alpha(self): """Return Q_alpha""" M_ALPHA = 2.4249156 # He4 mass excess in MeV f = lambda parent, daugther: parent - daugther - M_ALPHA return self.derived('Q_alpha', (-2, -2), f)
def q_beta(self): """Return Q_beta""" f = lambda parent, daugther: parent - daugther return self.derived('Q_beta', (1, -1), f)
def s2n(self): """Return 2 neutron separation energy""" M_N = 8.0713171 # neutron mass excess in MeV f = lambda parent, daugther: -parent + daugther + 2 * M_N return self.derived('s2n', (0, -2), f)
def s1n(self): """Return 1 neutron separation energy""" M_N = 8.0713171 # neutron mass excess in MeV f = lambda parent, daugther: -parent + daugther + M_N return self.derived('s1n', (0, -1), f)
def s2p(self): """Return 2 proton separation energy""" M_P = 7.28897050 # proton mass excess in MeV f = lambda parent, daugther: -parent + daugther + 2 * M_P return self.derived('s2p', (-2, 0), f)
def s1p(self): """Return 1 proton separation energy""" M_P = 7.28897050 # proton mass excess in MeV f = lambda parent, daugther: -parent + daugther + M_P return self.derived('s1p', (-1, 0), f)
def derived(self, name, relative_coords, formula): """Helper function for derived quantities""" relZ, relN = relative_coords daughter_idx = [(x[0] + relZ, x[1] + relN) for x in self.df.index] values = formula(self.df.values, self.df.loc[daughter_idx].values) return Table(df=pd.Series(values, index=self.df.index, name=name + '(' + self.name + ')'))
def ds2n(self): """Calculates the derivative of the neutron separation energies: ds2n(Z,A) = s2n(Z,A) - s2n(Z,A+2) """ idx = [(x[0] + 0, x[1] + 2) for x in self.df.index] values = self.s2n.values - self.s2n.loc[idx].values return Table(df=pd.Series(values, index=self.df.index, name='ds2n' + '(' + self.name + ')'))
def ds2p(self): """Calculates the derivative of the neutron separation energies: ds2n(Z,A) = s2n(Z,A) - s2n(Z,A+2) """ idx = [(x[0] + 2, x[1]) for x in self.df.index] values = self.s2p.values - self.s2p.loc[idx].values return Table(df=pd.Series(values, index=self.df.index, name='ds2p' + '(' + self.name + ')'))
def chart_plot(self, ax=None, cmap='RdBu', xlabel='N', ylabel='Z', grid_on=True, colorbar=True): """Plot a nuclear chart with (N,Z) as axis and the values of the Table as a color scale Parameters ---------- ax: optional matplotlib axes defaults to current axes cmap: a matplotlib colormap default: 'RdBu' xlabel: string representing the label of the x axis default: 'N' ylabel: string, default: 'Z' the label of the x axis grid_on: boolean, default: True, whether to draw the axes grid or not colorbar: boolean, default: True whether to draw a colorbar or not Returns ------- ax: a matplotlib axes object Example ------- Plot the theoretical deviation for the Möller's model:: >>> Table('FRDM95').error().chart_plot() """ from matplotlib.mlab import griddata from numpy import linspace, meshgrid import matplotlib.pyplot as plt # extract the 1D arrays to be plotted x = self.dropna().N y = self.dropna().Z z = self.dropna().values #convert to matplotlibs grid format xi = linspace(min(x), max(x), max(x) - min(x) + 1) yi = linspace(min(y), max(y), max(y) - min(y) + 1) Z = griddata(x, y, z, xi, yi) X, Y = meshgrid(xi, yi) # create and customize plot if ax is None: ax = plt.gca() chart = ax.pcolormesh(X, Y, Z, cmap=cmap) ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) ax.grid(grid_on) ax.set_aspect('equal') if colorbar: plt.colorbar(chart) return ax
def _uses_db(func, self, args, kwargs): """ Use as a decorator for operations on the database, to ensure connection setup and teardown. Can only be used on methods on objects with a `self.session` attribute. """ if not self.session: _logger.debug('Creating new db session') self._init_db_session() try: ret = func(self, args, **kwargs) self.session.commit() except: self.session.rollback() tb = traceback.format_exc() _logger.debug(tb) raise finally: _logger.debug('Closing db session') self.session.close() return ret
def derive_key(self, master_password): """ Computes the key from the salt and the master password. """ encoder = encoding.Encoder(self.charset) bytes = ('%s:%s' % (master_password, self.name)).encode('utf8') start_time = time.clock() # we fix the scrypt parameters in case the defaults change digest = scrypt.hash(bytes, self.salt, N=1<<14, r=8, p=1) key = encoder.encode(digest, self.key_length) derivation_time_in_s = time.clock() - start_time _logger.debug('Key derivation took %.2fms', derivation_time_in_s*1000) return key
def bootstrap(self, path_or_uri): """ Initialize a database. :param database_path: The absolute path to the database to initialize. """ _logger.debug("Bootstrapping new database: %s", path_or_uri) self.database_uri = _urify_db(path_or_uri) db = sa.create_engine(self.database_uri) Base.metadata.create_all(db)
def search(self, query): """ Search the database for the given query. Will find partial matches. """ results = self.session.query(Domain).filter(Domain.name.ilike('%%%s%%' % query)).all() return results
def get_domain(self, domain_name): """ Get the :class:`Domain <pwm.Domain>` object from a name. :param domain_name: The domain name to fetch the object for. :returns: The :class:`Domain <pwm.core.Domain>` class with this domain_name if found, else None. """ protocol = self.database_uri.split(':', 1)[0] if protocol in ('https', 'http'): return self._get_domain_from_rest_api(domain_name) else: domain = self._get_domain_from_db(domain_name) if domain: return domain else: raise NoSuchDomainException
def modify_domain(self, domain_name, new_salt=False, username=None): """ Modify an existing domain. :param domain_name: The name of the domain to modify. :param new_salt: Whether to generate a new salt for the domain. :param username: If given, change domain username to this value. :returns: The modified :class:`Domain <pwm.core.Domain>` object. """ domain = self._get_domain_from_db(domain_name) if domain is None: raise NoSuchDomainException if new_salt: _logger.info("Generating new salt..") domain.new_salt() if username is not None: domain.username = username return domain
def create_domain(self, domain_name, username=None, alphabet=Domain.DEFAULT_ALPHABET, length=Domain.DEFAULT_KEY_LENGTH): """ Create a new domain entry in the database. :param username: The username to associate with this domain. :param alphabet: A character set restriction to impose on keys generated for this domain. :param length: The length of the generated key, in case of restrictions on the site. """ # Wrap the actual implementation to do some error handling try: return self._create_domain(domain_name, username, alphabet, length) except Exception as ex: _logger.warn("Inserting new domain failed: %s", ex) raise DuplicateDomainException
def from_bbox(bbox, zlevs): """Yields tile (x, y, z) tuples for a bounding box and zoom levels. Arguments: bbox - bounding box as a 4-length sequence zlevs - sequence of tile zoom levels """ env = Envelope(bbox) for z in zlevs: corners = [to_tile(coord + (z,)) for coord in (env.ul, env.lr)] xs, ys = [range(p1, p2 + 1) for p1, p2 in zip(corners)] for coord in itertools.product(xs, ys, (z,)): yield coord
def to_lonlat(xtile, ytile, zoom): """Returns a tuple of (longitude, latitude) from a map tile xyz coordinate. See http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Lon..2Flat._to_tile_numbers_2 Arguments: xtile - x tile location as int or float ytile - y tile location as int or float zoom - zoom level as int or float """ n = 2.0 ** zoom lon = xtile / n * 360.0 - 180.0 # Caculate latitude in radians and convert to degrees constrained from -90 # to 90. Values too big for tile coordinate pairs are invalid and could # overflow. try: lat_rad = math.atan(math.sinh(math.pi * (1 - 2 * ytile / n))) except OverflowError: raise ValueError('Invalid tile coordinate for zoom level %d' % zoom) lat = math.degrees(lat_rad) return lon, lat
def to_tile(lon, lat, zoom): """Returns a tuple of (xtile, ytile) from a (longitude, latitude) coordinate. See http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames Arguments: lon - longitude as int or float lat - latitude as int or float zoom - zoom level as int or float """ lat_rad = math.radians(lat) n = 2.0 ** zoom xtile = int((lon + 180.0) / 360.0 * n) ytile = int((1.0 - math.log(math.tan(lat_rad) + (1 / math.cos(lat_rad))) / math.pi) / 2.0 * n) return xtile, ytile
def extract_hbs(fileobj, keywords, comment_tags, options): """Extract messages from Handlebars templates. It returns an iterator yielding tuples in the following form ``(lineno, funcname, message, comments)``. TODO: Things to improve: --- Return comments """ server = get_pipeserver() server.sendline(COMMAND+u'PARSE FILE:'+fileobj.name) server.expect(RESPONSE+'SENDING OUTPUT') server.expect(RESPONSE+'OUTPUT END') trans_strings = server.before for item in json.loads(trans_strings): messages = [item['content']] if item['funcname'] == 'ngettext': messages.append(item['alt_content']) yield item['line_number'],item['funcname'],tuple(messages),[]
def vsiprefix(path): """Returns a GDAL virtual filesystem prefixed path. Arguments: path -- file path as str """ vpath = path.lower() scheme = VSI_SCHEMES.get(urlparse(vpath).scheme, '') for ext in VSI_TYPES: if ext in vpath: filesys = VSI_TYPES[ext] break else: filesys = '' if filesys and scheme: filesys = filesys[:-1] return ''.join((filesys, scheme, path))
def srid(self): """Returns the EPSG ID as int if it exists.""" epsg_id = (self.GetAuthorityCode('PROJCS') or self.GetAuthorityCode('GEOGCS')) try: return int(epsg_id) except TypeError: return
def main(): """ Main entry point for the CLI. """ args = get_args() ret_code = args.target(args) _logger.debug('Exiting with code %d', ret_code) sys.exit(ret_code)
def _init_logging(verbose=False): """ Initialize loggers. """ config = { 'version': 1, 'formatters': { 'console': { 'format': '* %(message)s', } }, 'handlers': { 'console': { 'class': 'logging.StreamHandler', 'level': 'DEBUG', 'formatter': 'console', 'stream': 'ext://sys.stdout', } }, 'loggers': { 'pwm': { 'level': 'DEBUG' if verbose else 'INFO', 'handlers': ['console'], 'propagate': True, }, 'requests.packages.urllib3': { 'level': 'INFO' if verbose else 'WARNING', 'handlers': ['console'], 'propagate': True, } } } logging.config.dictConfig(config) HTTPConnection.debuglevel = 1 if verbose else 0
def update_file(url, filename): """Update the content of a single file.""" resp = urlopen(url) if resp.code != 200: raise Exception('GET {} failed.'.format(url)) with open(_get_package_path(filename), 'w') as fp: for l in resp: if not l.startswith(b'#'): fp.write(l.decode('utf8')) print('Updated {}'.format(filename))
def available_drivers(): """Returns a dictionary of enabled GDAL Driver metadata keyed by the 'ShortName' attribute. """ drivers = {} for i in range(gdal.GetDriverCount()): d = gdal.GetDriver(i) drivers[d.ShortName] = d.GetMetadata() return drivers
def driver_for_path(path, drivers=None): """Returns the gdal.Driver for a path or None based on the file extension. Arguments: path -- file path as str with a GDAL supported file extension """ ext = (os.path.splitext(path)[1][1:] or path).lower() drivers = drivers or ImageDriver.registry if ext else {} for name, meta in drivers.items(): if ext == meta.get('DMD_EXTENSION', '').lower(): return ImageDriver(name) return None
def geom_to_array(geom, size, affine): """Converts an OGR polygon to a 2D NumPy array. Arguments: geom -- OGR Geometry size -- array size in pixels as a tuple of (width, height) affine -- AffineTransform """ driver = ImageDriver('MEM') rast = driver.raster(driver.ShortName, size) rast.affine = affine rast.sref = geom.GetSpatialReference() with MemoryLayer.from_records([(1, geom)]) as ml: status = gdal.RasterizeLayer(rast.ds, (1,), ml.layer, burn_values=(1,)) arr = rast.array() rast.close() return arr
def rasterize(layer, rast): """Returns a Raster from layer features. Arguments: layer -- Layer to rasterize rast -- Raster with target affine, size, and sref """ driver = ImageDriver('MEM') r2 = driver.raster(driver.ShortName, rast.size) r2.affine = rast.affine sref = rast.sref if not sref.srid: sref = SpatialReference(4326) r2.sref = sref ml = MemoryLayer(sref, layer.GetGeomType()) ml.load(layer) status = gdal.RasterizeLayer( r2.ds, (1,), ml.layer, options=['ATTRIBUTE=%s' % ml.id]) ml.close() return r2
def open(path, mode=gdalconst.GA_ReadOnly): """Returns a Raster instance. Arguments: path -- local or remote path as str or file-like object Keyword args: mode -- gdal constant representing access mode """ path = getattr(path, 'name', path) try: return Raster(vsiprefix(path), mode) except AttributeError: try: imgdata = path.read() except AttributeError: raise TypeError('Not a file-like object providing read()') else: imgio = MemFileIO(delete=False) gdal.FileFromMemBuffer(imgio.name, imgdata) return Raster(imgio, mode) raise ValueError('Failed to open raster from "%r"' % path)

def to_json_str(self): """Convert data to json string representation. Returns: json representation as string. """ adict = dict(vars(self), sort_keys=True) adict['type'] = self.__class__.__name__ return json.dumps(adict)

def find_file_match(folder_path, regex=''): """ Returns absolute paths of files that match the regex within folder_path and all its children folders. Note: The regex matching is done using the match function of the re module. Parameters ---------- folder_path: string regex: string Returns ------- A list of strings. """ outlist = [] for root, dirs, files in os.walk(folder_path): outlist.extend([os.path.join(root, f) for f in files if re.match(regex, f)]) return outlist

def qquery(xml_thing, xpath_thing, vars=None, funcs=None): ''' Quick query. Convenience for using the MicroXPath engine. Give it some XML and an expression and it will yield the results. No fuss. xml_thing - bytes or string, or amara3.xml.tree node xpath_thing - string or parsed XPath expression vars - optional mapping of variables, name to value funcs - optional mapping of functions, name to function object >>> from amara3.uxml.uxpath import qquery >>> results = qquery(b'<a>1<b>2</b>3</a>', 'a/text()')) >>> next(results).xml_value '1' >>> next(results).xml_value '3' ''' root = None if isinstance(xml_thing, nodetype): root = xml_thing elif isinstance(xml_thing, str): tb = tree.treebuilder() root = tb.parse(xml_thing) elif isinstance(xml_thing, bytes): tb = tree.treebuilder() #Force UTF-8 root = tb.parse(xml_thing.decode('utf-8')) if not root: return if isinstance(xpath_thing, str): parsed_expr = parse(xpath_thing) ctx = context(root, variables=vars, functions=funcs) result = parsed_expr.compute(ctx) yield from result

def p_function_call(p): """ FunctionCall : NAME FormalArguments """ #Hacking around the ambiguity between node type test & function call if p[1] in ('node', 'text'): p[0] = ast.NodeType(p[1]) else: p[0] = ast.FunctionCall(p[1], p[2])

def boolean_arg(ctx, obj): ''' Handles LiteralObjects as well as computable arguments ''' if hasattr(obj, 'compute'): obj = next(obj.compute(ctx), False) return to_boolean(obj)

def number_arg(ctx, obj): ''' Handles LiteralObjects as well as computable arguments ''' if hasattr(obj, 'compute'): obj = next(obj.compute(ctx), False) return to_number(obj)

def string_arg(ctx, obj): ''' Handles LiteralObjects as well as computable arguments ''' if hasattr(obj, 'compute'): obj = next(obj.compute(ctx), False) return to_string(obj)

def name(ctx, obj=None): ''' Yields one string a node name or the empty string, operating on the first item in the provided obj, or the current item if obj is omitted If this item is a node, yield its node name (generic identifier), otherwise yield '' If obj is provided, but empty, yield '' ''' if obj is None: item = ctx.item elif hasattr(obj, 'compute'): item = next(obj.compute(ctx), None) else: item = obj if isinstance(item, node): yield item.xml_name else: yield ''

def string_(ctx, seq=None): ''' Yields one string, derived from the argument literal (or the first item in the argument sequence, unless empty in which case yield '') as follows: * If a node, yield its string-value * If NaN, yield 'NaN' * If +0 or -0, yield '0' * If positive infinity, yield 'Infinity' * If negative infinity, yield '-Infinity' * If an integer, no decimal point and no leading zeros * If a non-integer number, at least one digit before the decimal point and at least one digit after * If boolean, either 'true' or 'false' ''' if seq is None: item = ctx.item elif hasattr(seq, 'compute'): item = next(seq.compute(ctx), '') else: item = seq yield next(to_string(item), '')

def concat(ctx, *strings): ''' Yields one string, concatenation of argument strings ''' strings = flatten([ (s.compute(ctx) if callable(s) else s) for s in strings ]) strings = (next(string_arg(ctx, s), '') for s in strings) #assert(all(map(lambda x: isinstance(x, str), strings))) #FIXME: Check arg types yield ''.join(strings)

def starts_with(ctx, full, part): ''' Yields one boolean, whether the first string starts with the second ''' full = next(string_arg(ctx, full), '') part = next(string_arg(ctx, part), '') yield full.startswith(part)

def contains(ctx, full, part): ''' Yields one boolean, whether the first string contains the second ''' full = next(string_arg(ctx, full), '') part = next(string_arg(ctx, part), '') yield part in full

def substring_before(ctx, full, part): ''' Yields one string ''' full = next(string_arg(ctx, full), '') part = next(string_arg(ctx, part), '') yield full.partition(part)[0]

def substring_after(ctx, full, part): ''' Yields one string ''' full = next(string_arg(ctx, full), '') part = next(string_arg(ctx, part), '') yield full.partition(part)[-1]

def substring(ctx, full, start, length): ''' Yields one string ''' full = next(string_arg(ctx, full), '') start = int(next(to_number(start))) length = int(next(to_number(length))) yield full[start-1:start-1+length]

def string_length(ctx, s=None): ''' Yields one number ''' if s is None: s = ctx.node elif callable(s): s = next(s.compute(ctx), '') yield len(s)

def boolean(ctx, obj): ''' Yields one boolean, false if the argument sequence is empty, otherwise * false if the first item is a boolean and false * false if the first item is a number and positive or negative zero or NaN * false if the first item is a string and '' * true in all other cases ''' if hasattr(obj, 'compute'): obj = next(seq.compute(ctx), '') else: obj = seq yield next(to_boolean(obj), '')

def number(ctx, seq=None): ''' Yields one float, derived from the first item in the argument sequence (unless empty in which case yield NaN) as follows: * If string with optional whitespace followed by an optional minus sign followed by a Number followed by whitespace, converte to the IEEE 754 number that is nearest (according to the IEEE 754 round-to-nearest rule) to the mathematical value represented by the string; in case of any other string yield NaN * If boolean true yield 1; if boolean false yield 0 * If a node convert to string as if by a call to string(); yield the same value as if passed that string argument to number() ''' if hasattr(obj, 'compute'): obj = next(seq.compute(ctx), '') else: obj = seq yield next(to_number(obj), '')

def foreach_(ctx, seq, expr): ''' Yields the result of applying an expression to each item in the input sequence. * seq: input sequence * expr: expression to be converted to string, then dynamically evaluated for each item on the sequence to produce the result ''' from . import context, parse as uxpathparse if hasattr(seq, 'compute'): seq = seq.compute(ctx) expr = next(string_arg(ctx, expr), '') pexpr = uxpathparse(expr) for item in seq: innerctx = ctx.copy(item=item) yield from pexpr.compute(innerctx)

def lookup_(ctx, tableid, key): ''' Yields a sequence of a single value, the result of looking up a value from the tables provided in the context, or an empty sequence if lookup is unsuccessful * tableid: id of the lookup table to use * expr: expression to be converted to string, then dynamically evaluated for each item on the sequence to produce the result ''' tableid = next(string_arg(ctx, tableid), '') key = next(string_arg(ctx, key), '') #value = ctx. for item in seq: innerctx = ctx.copy(item=item) yield from pexpr.compute(innerctx)

def replace_chars_for_svg_code(svg_content): """ Replace known special characters to SVG code. Parameters ---------- svg_content: str Returns ------- corrected_svg: str Corrected SVG content """ result = svg_content svg_char = [ ('&', '&'), ('>', '>'), ('<', '<'), ('"', '"'), ] for c, entity in svg_char: result = result.replace(c, entity) return result

def _check_svg_file(svg_file): """ Try to read a SVG file if `svg_file` is a string. Raise an exception in case of error or return the svg object. If `svg_file` is a svgutils svg object, will just return it. Parameters ---------- svg_file: str or svgutils.transform.SVGFigure object If a `str`: path to a '.svg' file, otherwise a svgutils svg object is expected. Returns ------- svgutils svg object Raises ------ Exception if any error happens. """ if isinstance(svg_file, str): try: svg = sg.fromfile(svg_file) except Exception as exc: raise Exception('Error reading svg file {}.'.format(svg_file)) from exc else: return svg if isinstance(svg_file, sg.SVGFigure): return svg_file raise ValueError('Expected `svg_file` to be `str` or `svgutils.SVG`, got {}.'.format(type(svg_file)))

def merge_svg_files(svg_file1, svg_file2, x_coord, y_coord, scale=1): """ Merge `svg_file2` in `svg_file1` in the given positions `x_coord`, `y_coord` and `scale`. Parameters ---------- svg_file1: str or svgutils svg document object Path to a '.svg' file. svg_file2: str or svgutils svg document object Path to a '.svg' file. x_coord: float Horizontal axis position of the `svg_file2` content. y_coord: float Vertical axis position of the `svg_file2` content. scale: float Scale to apply to `svg_file2` content. Returns ------- `svg1` svgutils object with the content of 'svg_file2' """ svg1 = _check_svg_file(svg_file1) svg2 = _check_svg_file(svg_file2) svg2_root = svg2.getroot() svg1.append([svg2_root]) svg2_root.moveto(x_coord, y_coord, scale=scale) return svg1

def rsvg_export(input_file, output_file, dpi=90, rsvg_binpath=None): """ Calls the `rsvg-convert` command, to convert a svg to a PDF (with unicode). Parameters ---------- rsvg_binpath: str Path to `rsvg-convert` command input_file: str Path to the input file output_file: str Path to the output file Returns ------- return_value Command call return value """ if not os.path.exists(input_file): log.error('File {} not found.'.format(input_file)) raise IOError((0, 'File not found.', input_file)) if rsvg_binpath is None: rsvg_binpath = which('rsvg-convert') check_command(rsvg_binpath) args_strings = [] args_strings += ["-f pdf"] args_strings += ["-o {}".format(output_file)] args_strings += ["--dpi-x {}".format(dpi)] args_strings += ["--dpi-y {}".format(dpi)] args_strings += [input_file] return call_command(rsvg_binpath, args_strings)

def merge_pdfs(pdf_filepaths, out_filepath): """ Merge all the PDF files in `pdf_filepaths` in a new PDF file `out_filepath`. Parameters ---------- pdf_filepaths: list of str Paths to PDF files. out_filepath: str Path to the result PDF file. Returns ------- path: str The output file path. """ merger = PdfFileMerger() for pdf in pdf_filepaths: merger.append(PdfFileReader(open(pdf, 'rb'))) merger.write(out_filepath) return out_filepath

def _embed_font_to_svg(filepath, font_files): """ Return the ElementTree of the SVG content in `filepath` with the font content embedded. """ with open(filepath, 'r') as svgf: tree = etree.parse(svgf) if not font_files: return tree fontfaces = FontFaceGroup() for font_file in font_files: fontfaces.append(FontFace(font_file)) for element in tree.iter(): if element.tag.split("}")[1] == 'svg': break element.insert(0, fontfaces.xml_elem) return tree

def embed_font_to_svg(filepath, outfile, font_files): """ Write ttf and otf font content from `font_files` in the svg file in `filepath` and write the result in `outfile`. Parameters ---------- filepath: str The SVG file whose content must be modified. outfile: str The file path where the result will be written. font_files: iterable of str List of paths to .ttf or .otf files. """ tree = _embed_font_to_svg(filepath, font_files) tree.write(outfile, encoding='utf-8', pretty_print=True)

def _check_inputs(self): ''' make some basic checks on the inputs to make sure they are valid''' try: _ = self._inputs[0] except TypeError: raise RuntimeError( "inputs should be iterable but found type='{0}', value=" "'{1}'".format(type(self._inputs), str(self._inputs))) from melody.inputs import Input for check_input in self._inputs: if not isinstance(check_input, Input): raise RuntimeError( "input should be a subclass of the Input class but " "found type='{0}', value='{1}'".format(type(check_input), str(check_input)))

def _check_function(self): ''' make some basic checks on the function to make sure it is valid''' # note, callable is valid for Python 2 and Python 3.2 onwards but # not inbetween if not callable(self._function): raise RuntimeError( "provided function '{0}' is not callable". format(str(self._function))) from inspect import getargspec arg_info = getargspec(self._function) if len(arg_info.args) != 1: print str(arg_info) raise RuntimeError( "provided function should have one argument but found " "{0}".format(len(arg_info.args)))

def _recurse(self, inputs, output): '''internal recursion routine called by the run method that generates all input combinations''' if inputs: my_input = inputs[0] name = my_input.name if my_input.state: my_options = my_input.options(self.state) else: my_options = my_input.options for option in my_options: my_output = list(output) my_output.append({name: option}) self._recurse(inputs[1:], my_output) else: try: valid, result = self._function(output) except ValueError: raise RuntimeError("function must return 2 values") print output, valid, result

def create_input(option, template_name, template_location="template"): '''create an input file using jinja2 by filling a template with the values from the option variable passed in.''' # restructure option list into jinja2 input format jinja2_input = {} for item in option: try: jinja2_input.update(item) except ValueError: raise RuntimeError( ("inputs.py, create_input : format of item '{0}' is not " "supported. Expecting a dictionary.".format(str(item)))) # load the template and fill it with the option variable contents import jinja2 try: template_loader = jinja2.FileSystemLoader(searchpath=template_location) template_env = jinja2.Environment(loader=template_loader) template = template_env.get_template(template_name) output_text = template.render(jinja2_input) except jinja2.TemplateNotFound: raise RuntimeError("template '{0}' not found".format(template_name)) # return the particular input file as a string return output_text

def _recurse(self, inputs, output, depth, max_depth): '''We work out all combinations using this internal recursion method''' if depth < max_depth: for index, option in enumerate(inputs): my_output = list(output) my_output.append(option) self._recurse(inputs[index + 1:], my_output, depth + 1, max_depth) else: self._options.append(output)

def to_string(obj): ''' Cast an arbitrary object or sequence to a string type ''' if isinstance(obj, LiteralWrapper): val = obj.obj elif isinstance(obj, Iterable) and not isinstance(obj, str): val = next(obj, None) else: val = obj if val is None: yield '' elif isinstance(val, str): yield val elif isinstance(val, node): yield strval(val) elif isinstance(val, int) or isinstance(val, float): yield str(val) elif isinstance(item, bool): yield 'true' if item else 'false' else: raise RuntimeError('Unknown type for string conversion: {}'.format(val))

def to_number(obj): ''' Cast an arbitrary object or sequence to a number type ''' if isinstance(obj, LiteralWrapper): val = obj.obj elif isinstance(obj, Iterable) and not isinstance(obj, str): val = next(obj, None) else: val = obj if val is None: #FIXME: Should be NaN, not 0 yield 0 elif isinstance(val, str): yield float(val) elif isinstance(val, node): yield float(strval(val)) elif isinstance(val, int) or isinstance(val, float): yield val else: raise RuntimeError('Unknown type for number conversion: {}'.format(val))

def to_boolean(obj): ''' Cast an arbitrary sequence to a boolean type ''' #if hasattr(obj, '__iter__'): if isinstance(obj, LiteralWrapper): val = obj.obj elif isinstance(obj, Iterable) and not isinstance(obj, str): val = next(obj, None) else: val = obj if val is None: yield False elif isinstance(val, bool): yield val elif isinstance(val, str): yield bool(str) elif isinstance(val, node): yield True elif isinstance(val, float) or isinstance(val, int): yield bool(val) else: raise RuntimeError('Unknown type for boolean conversion: {}'.format(val))

def _serialize(xp_ast): '''Generate token strings which, when joined together, form a valid XPath serialization of the AST.''' if hasattr(xp_ast, '_serialize'): for tok in xp_ast._serialize(): yield(tok) elif isinstance(xp_ast, str): yield(repr(xp_ast))

def change_xml_encoding(filepath, src_enc, dst_enc='utf-8'): """ Modify the encoding entry in the XML file. Parameters ---------- filepath: str Path to the file to be modified. src_enc: str Encoding that is written in the file dst_enc: str Encoding to be set in the file. """ enc_attr = "encoding='{}'" replace_file_content(filepath, enc_attr.format(src_enc), enc_attr.format(dst_enc), 1)

def save_into_qrcode(text, out_filepath, color='', box_size=10, pixel_size=1850): """ Save `text` in a qrcode svg image file. Parameters ---------- text: str The string to be codified in the QR image. out_filepath: str Path to the output file color: str A RGB color expressed in 6 hexadecimal values. box_size: scalar Size of the QR code boxes. """ try: qr = qrcode.QRCode(version=1, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=box_size, border=0, ) qr.add_data(text) qr.make(fit=True) except Exception as exc: raise Exception('Error trying to generate QR code ' ' from `vcard_string`: {}'.format(text)) from exc else: img = qr.make_image(image_factory=qrcode.image.svg.SvgPathImage) _ = _qrcode_to_file(img, out_filepath) if color: replace_file_content(out_filepath, 'fill:#000000', 'fill:#{}'.format(color))

def _qrcode_to_file(qrcode, out_filepath): """ Save a `qrcode` object into `out_filepath`. Parameters ---------- qrcode: qrcode object out_filepath: str Path to the output file. """ try: qrcode.save(out_filepath) except Exception as exc: raise IOError('Error trying to save QR code file {}.'.format(out_filepath)) from exc else: return qrcode

def handle_cdata(pos, window, charpat, stopchars): ''' Return (result, new_position) tuple. Result is cdata string if possible and None if more input is needed Or of course bad syntax can raise a RuntimeError ''' cdata = '' cursor = start = pos try: while True: while charpat.match(window[cursor]): cursor += 1 addchars = window[start:cursor] cdata += addchars #if window[pos] != openattr: # raise RuntimeError('Mismatch in attribute quotes') if window[cursor] in stopchars: return cdata, cursor #Check for charref elif window[cursor] == '&': start = cursor = cursor + 1 if window[cursor] == '#' and window[cursor + 1] == 'x': #Numerical charref start = cursor = cursor + 2 while True: if HEXCHARENTOK.match(window[cursor]): cursor += 1 elif window[cursor] == ';': c = chr(int(window[start:cursor], 16)) if not CHARACTER.match(c): raise RuntimeError('Character reference gives an illegal character: {0}'.format('&' + window[start:cursor] + ';')) cdata += c break else: raise RuntimeError('Illegal in character entity: {0}'.format(window[cursor])) else: #Named charref while True: if NAMEDCHARENTOK.match(window[cursor]): cursor += 1 elif window[cursor] == ';': for cn, c in CHARNAMES: if window[start:cursor] == cn: cdata += c #cursor += 1 #Skip ; break else: raise RuntimeError('Unknown named character reference: {0}'.format(repr(window[start:cursor]))) break else: raise RuntimeError('Illegal in character reference: {0} (around {1})'.format(window[cursor]), error_context(window, start, cursor)) #print(start, cursor, cdata, window[cursor]) cursor += 1 start = cursor except IndexError: return None, cursor

def launch(option): '''Set the gromacs input data using the supplied input options, run gromacs and extract and return the required outputs.''' from melody.inputs import create_input _ = create_input(option, template_name="input.mdp") # save the input file in the appropriate place and launch gromacs using # longbow ... # determine if the run was successful success = True results = None if success: # extract the required outputs results = {"rate": {"value": 35, "units": "ns/day"}, } return success, results

def call_command(cmd_name, args_strings): """Call CLI command with arguments and returns its return value. Parameters ---------- cmd_name: str Command name or full path to the binary file. arg_strings: str Argument strings list. Returns ------- return_value Command return value. """ if not os.path.isabs(cmd_name): cmd_fullpath = which(cmd_name) else: cmd_fullpath = cmd_name try: cmd_line = [cmd_fullpath] + args_strings log.debug('Calling: `{}`.'.format(' '.join(cmd_line))) # retval = subprocess.check_call(cmd_line) retval = subprocess.call(' '.join(cmd_line), shell=True) except CalledProcessError as ce: log.exception( "Error calling command with arguments: " "{} \n With return code: {}".format(cmd_line, ce.returncode) ) raise else: return retval

def getCSV(self): """ Returns ------- filename: str """ import getpass import gspread user = raw_input("Insert Google username:") password = getpass.getpass(prompt="Insert password:") name = raw_input("SpreadSheet filename on Drive:") sheet = raw_input("Sheet name (first sheet is default):") cl = gspread.login(user, password) sh = cl.open(name) if not (sheet.strip()): ws = sh.sheet1 sheet = "1" else: ws = sh.worksheet(sheet) filename = name + '-worksheet_' + sheet + '.csv' with open(filename, 'wb') as f: writer = UnicodeWriter(f) writer.writerows(ws.get_all_values()) return filename

def write(elem, a_writer): ''' Write a MicroXML element node (yes, even one representign a whole document) elem - Amara MicroXML element node to be written out writer - instance of amara3.uxml.writer to implement the writing process ''' a_writer.start_element(elem.xml_name, attribs=elem.xml_attributes) for node in elem.xml_children: if isinstance(node, tree.element): write(node, a_writer) elif isinstance(node, tree.text): a_writer.text(node) a_writer.end_element(elem.xml_name) return

def tex2pdf(tex_file, output_file=None, output_format='pdf'): """ Call PDFLatex to convert TeX files to PDF. Parameters ---------- tex_file: str Path to the input LateX file. output_file: str Path to the output PDF file. If None, will use the same output directory as the tex_file. output_format: str Output file format. Choices: 'pdf' or 'dvi'. Default: 'pdf' Returns ------- return_value PDFLatex command call return value. """ if not os.path.exists(tex_file): raise IOError('Could not find file {}.'.format(tex_file)) if output_format != 'pdf' and output_format != 'dvi': raise ValueError("Invalid output format given {}. Can only accept 'pdf' or 'dvi'.".format(output_format)) cmd_name = 'pdflatex' check_command(cmd_name) args_strings = [cmd_name] if output_file is not None: args_strings += ['-output-directory="{}" '.format(os.path.abspath(os.path.dirname(output_file)))] result_dir = os.path.dirname(output_file) if output_file else os.path.dirname(tex_file) args_strings += ['-output-format="{}"'.format(output_format)] args_strings += ['"' + tex_file + '"'] log.debug('Calling command {} with args: {}.'.format(cmd_name, args_strings)) ret = simple_call(args_strings) result_file = os.path.join(result_dir, remove_ext(os.path.basename(tex_file)) + '.' + output_format) if os.path.exists(result_file): shutil.move(result_file, output_file) else: raise IOError('Could not find PDFLatex result file.') log.debug('Cleaning *.aux and *.log files from folder {}.'.format(result_dir)) cleanup(result_dir, 'aux') cleanup(result_dir, 'log') return ret

def options(self, my_psy): '''Returns all potential loop fusion options for the psy object provided''' # compute options dynamically here as they may depend on previous # changes to the psy tree my_options = [] invokes = my_psy.invokes.invoke_list #print "there are {0} invokes".format(len(invokes)) if self._dependent_invokes: raise RuntimeError( "dependent invokes assumes fusion in one invoke might " "affect fusion in another invoke. This is not yet " "implemented") else: # treat each invoke separately for idx, invoke in enumerate(invokes): print "invoke {0}".format(idx) # iterate through each outer loop for loop in invoke.schedule.loops(): if loop.loop_type == "outer": siblings = loop.parent.children my_index = siblings.index(loop) option = [] self._recurse(siblings, my_index, option, my_options, invoke) return my_options

def transform(geom, to_sref): """Returns a transformed Geometry. Arguments: geom -- any coercible Geometry value or Envelope to_sref -- SpatialReference or EPSG ID as int """ # If we have an envelope, assume it's in the target sref. try: geom = getattr(geom, 'polygon', Envelope(geom).polygon) except (TypeError, ValueError): pass else: geom.AssignSpatialReference(to_sref) try: geom_sref = geom.GetSpatialReference() except AttributeError: return transform(Geometry(geom), to_sref) if geom_sref is None: raise Exception('Cannot transform from unknown spatial reference') # Reproject geom if necessary if not geom_sref.IsSame(to_sref): geom = geom.Clone() geom.TransformTo(to_sref) return geom

def Geometry(*args, **kwargs): """Returns an ogr.Geometry instance optionally created from a geojson str or dict. The spatial reference may also be provided. """ # Look for geojson as a positional or keyword arg. arg = kwargs.pop('geojson', None) or len(args) and args[0] try: srs = kwargs.pop('srs', None) or arg.srs.wkt except AttributeError: srs = SpatialReference(4326) if hasattr(arg, 'keys'): geom = ogr.CreateGeometryFromJson(json.dumps(arg)) elif hasattr(arg, 'startswith'): # WKB as hexadecimal string. char = arg[0] if arg else ' ' i = char if isinstance(char, int) else ord(char) if i in (0, 1): geom = ogr.CreateGeometryFromWkb(arg) elif arg.startswith('{'): geom = ogr.CreateGeometryFromJson(arg) elif arg.startswith('<gml'): geom = ogr.CreateGeometryFromGML(arg) else: raise ValueError('Invalid geometry value: %s' % arg) elif hasattr(arg, 'wkb'): geom = ogr.CreateGeometryFromWkb(bytes(arg.wkb)) else: geom = ogr.Geometry(*args, **kwargs) if geom: if not isinstance(srs, SpatialReference): srs = SpatialReference(srs) geom.AssignSpatialReference(srs) return geom

def centroid(self): """Returns the envelope centroid as a (x, y) tuple.""" return self.min_x + self.width * 0.5, self.min_y + self.height * 0.5

def expand(self, other): """Expands this envelope by the given Envelope or tuple. Arguments: other -- Envelope, two-tuple, or four-tuple """ if len(other) == 2: other += other mid = len(other) // 2 self.ll = map(min, self.ll, other[:mid]) self.ur = map(max, self.ur, other[mid:])

def intersect(self, other): """Returns the intersection of this and another Envelope.""" inter = Envelope(tuple(self)) if inter.intersects(other): mid = len(other) // 2 inter.ll = map(max, inter.ll, other[:mid]) inter.ur = map(min, inter.ur, other[mid:]) else: inter.ll = (0, 0) inter.ur = (0, 0) return inter

def intersects(self, other): """Returns true if this envelope intersects another. Arguments: other -- Envelope or tuple of (minX, minY, maxX, maxY) """ try: return (self.min_x <= other.max_x and self.max_x >= other.min_x and self.min_y <= other.max_y and self.max_y >= other.min_y) except AttributeError: return self.intersects(Envelope(other))

def scale(self, xfactor, yfactor=None): """Returns a new envelope rescaled from center by the given factor(s). Arguments: xfactor -- int or float X scaling factor yfactor -- int or float Y scaling factor """ yfactor = xfactor if yfactor is None else yfactor x, y = self.centroid xshift = self.width * xfactor * 0.5 yshift = self.height * yfactor * 0.5 return Envelope(x - xshift, y - yshift, x + xshift, y + yshift)

def polygon(self): """Returns an OGR Geometry for this envelope.""" ring = ogr.Geometry(ogr.wkbLinearRing) for coord in self.ll, self.lr, self.ur, self.ul, self.ll: ring.AddPoint_2D(*coord) polyg = ogr.Geometry(ogr.wkbPolygon) polyg.AddGeometryDirectly(ring) return polyg

def from_name(cls, name): "Imports a mass table from a file" filename = os.path.join(package_dir, 'data', name + '.txt') return cls.from_file(filename, name)

def from_file(cls, filename, name=''): "Imports a mass table from a file" df = pd.read_csv(filename, header=0, delim_whitespace=True, index_col=[0, 1])['M'] df.name = name return cls(df=df, name=name)

def from_ZNM(cls, Z, N, M, name=''): """ Creates a table from arrays Z, N and M Example: ________ >>> Z = [82, 82, 83] >>> N = [126, 127, 130] >>> M = [-21.34, -18.0, -14.45] >>> Table.from_ZNM(Z, N, M, name='Custom Table') Z N 82 126 -21.34 127 -18.00 83 130 -14.45 Name: Custom Table, dtype: float64 """ df = pd.DataFrame.from_dict({'Z': Z, 'N': N, 'M': M}).set_index(['Z', 'N'])['M'] df.name = name return cls(df=df, name=name)

def to_file(self, path): """Export the contents to a file as comma separated values. Parameters ---------- path : string File path where the data should be saved to Example ------- Export the last ten elements of AME2012 to a new file: >>> Table('AME2012').tail(10).to_file('last_ten.txt') """ with open(path, 'w') as f: f.write('Z N M\n') self.df.to_csv(path, sep='\t', mode='a')

def select(self, condition, name=''): """ Selects nuclei according to a condition on Z,N or M Parameters ---------- condition : function, Can have one of the signatures f(M), f(Z,N) or f(Z, N, M) must return a boolean value name: string, optional name for the resulting Table Example: -------- Select all nuclei with A > 160: >>> A_gt_160 = lambda Z,N: Z + N > 160 >>> Table('AME2003').select(A_gt_160) """ if condition.func_code.co_argcount == 1: idx = [(Z, N) for (Z, N), M in self if condition(M)] if condition.func_code.co_argcount == 2: idx = [(Z, N) for (Z, N) in self.index if condition(Z, N)] if condition.func_code.co_argcount == 3: idx = [(Z, N) for (Z, N), M in self if condition(Z, N, M)] index = pd.MultiIndex.from_tuples(idx, names=['Z', 'N']) return Table(df=self.df.ix[index], name=name)

def at(self, nuclei): """Return a selection of the Table at positions given by ``nuclei`` Parameters ---------- nuclei: list of tuples A list where each element is tuple of the form (Z,N) Example ------- Return binding energies at magic nuclei: >>> magic_nuclei = [(20,28), (50,50), (50,82), (82,126)] >>> Table('AME2012').binding_energy.at(magic_nuclei) Z N 20 28 416.014215 50 50 825.325172 82 1102.876416 82 126 1636.486450 """ index = pd.MultiIndex.from_tuples(nuclei, names=['Z', 'N']) return Table(df=self.df.ix[index], name=self.name)

def intersection(self, table): """ Select nuclei which also belong to ``table`` Parameters ---------- table: Table, Table object Example: ---------- Table('AME2003').intersection(Table('AME1995')) """ idx = self.df.index & table.df.index return Table(df=self.df[idx], name=self.name)

def not_in(self, table): """ Select nuclei not in table Parameters ---------- table: Table, Table object from where nuclei should be removed Example: ---------- Find the new nuclei in AME2003 with Z,N >= 8: >>> Table('AME2003').not_in(Table('AME1995'))[8:,8:].count 389 """ idx = self.df.index - table.df.index return Table(df=self.df[idx], name=self.name)

def odd_odd(self): """Selects odd-odd nuclei from the table: >>> Table('FRDM95').odd_odd Out[13]: Z N 9 9 1.21 11 0.10 13 3.08 15 9.32 ... """ return self.select(lambda Z, N: (Z % 2) and (N % 2), name=self.name)

def odd_even(self): """ Selects odd-even nuclei from the table """ return self.select(lambda Z, N: (Z % 2) and not(N % 2), name=self.name)

def even_odd(self): """ Selects even-odd nuclei from the table """ return self.select(lambda Z, N: not(Z % 2) and (N % 2), name=self.name)

def even_even(self): """ Selects even-even nuclei from the table """ return self.select(lambda Z, N: not(Z % 2) and not(N % 2), name=self.name)

def error(self, relative_to='AME2003'): """ Calculate error difference Parameters ---------- relative_to : string, a valid mass table name. Example: ---------- >>> Table('DUZU').error(relative_to='AME2003') """ df = self.df - Table(relative_to).df return Table(df=df)

def rmse(self, relative_to='AME2003'): """Calculate root mean squared error Parameters ---------- relative_to : string, a valid mass table name. Example: ---------- >>> template = '{0:10}|{1:^6.2f}|{2:^6.2f}|{3:^6.2f}' >>> print 'Model ', 'AME95 ', 'AME03 ', 'AME12 ' # Table header ... for name in Table.names: ... print template.format(name, Table(name).rmse(relative_to='AME1995'), ... Table(name).rmse(relative_to='AME2003'), ... Table(name).rmse(relative_to='AME2012')) Model AME95 AME03 AME12 AME2003 | 0.13 | 0.00 | 0.13 AME2003all| 0.42 | 0.40 | 0.71 AME2012 | 0.16 | 0.13 | 0.00 AME2012all| 0.43 | 0.43 | 0.69 AME1995 | 0.00 | 0.13 | 0.16 AME1995all| 0.00 | 0.17 | 0.21 DUZU | 0.52 | 0.52 | 0.76 FRDM95 | 0.79 | 0.78 | 0.95 KTUY05 | 0.78 | 0.77 | 1.03 ETFSI12 | 0.84 | 0.84 | 1.04 HFB14 | 0.84 | 0.83 | 1.02 """ error = self.error(relative_to=relative_to) return math.sqrt((error.df ** 2).mean())

def binding_energy(self): """ Return binding energies instead of mass excesses """ M_P = 938.2723 # MeV M_E = 0.5110 # MeV M_N = 939.5656 # MeV AMU = 931.494028 # MeV df = self.Z * (M_P + M_E) + (self.A - self.Z) * M_N - (self.df + self.A * AMU) return Table(df=df, name='BE' + '(' + self.name + ')')

def q_alpha(self): """Return Q_alpha""" M_ALPHA = 2.4249156 # He4 mass excess in MeV f = lambda parent, daugther: parent - daugther - M_ALPHA return self.derived('Q_alpha', (-2, -2), f)

def q_beta(self): """Return Q_beta""" f = lambda parent, daugther: parent - daugther return self.derived('Q_beta', (1, -1), f)

def s2n(self): """Return 2 neutron separation energy""" M_N = 8.0713171 # neutron mass excess in MeV f = lambda parent, daugther: -parent + daugther + 2 * M_N return self.derived('s2n', (0, -2), f)

def s1n(self): """Return 1 neutron separation energy""" M_N = 8.0713171 # neutron mass excess in MeV f = lambda parent, daugther: -parent + daugther + M_N return self.derived('s1n', (0, -1), f)

def s2p(self): """Return 2 proton separation energy""" M_P = 7.28897050 # proton mass excess in MeV f = lambda parent, daugther: -parent + daugther + 2 * M_P return self.derived('s2p', (-2, 0), f)

def s1p(self): """Return 1 proton separation energy""" M_P = 7.28897050 # proton mass excess in MeV f = lambda parent, daugther: -parent + daugther + M_P return self.derived('s1p', (-1, 0), f)

def derived(self, name, relative_coords, formula): """Helper function for derived quantities""" relZ, relN = relative_coords daughter_idx = [(x[0] + relZ, x[1] + relN) for x in self.df.index] values = formula(self.df.values, self.df.loc[daughter_idx].values) return Table(df=pd.Series(values, index=self.df.index, name=name + '(' + self.name + ')'))

def ds2n(self): """Calculates the derivative of the neutron separation energies: ds2n(Z,A) = s2n(Z,A) - s2n(Z,A+2) """ idx = [(x[0] + 0, x[1] + 2) for x in self.df.index] values = self.s2n.values - self.s2n.loc[idx].values return Table(df=pd.Series(values, index=self.df.index, name='ds2n' + '(' + self.name + ')'))

def ds2p(self): """Calculates the derivative of the neutron separation energies: ds2n(Z,A) = s2n(Z,A) - s2n(Z,A+2) """ idx = [(x[0] + 2, x[1]) for x in self.df.index] values = self.s2p.values - self.s2p.loc[idx].values return Table(df=pd.Series(values, index=self.df.index, name='ds2p' + '(' + self.name + ')'))

def chart_plot(self, ax=None, cmap='RdBu', xlabel='N', ylabel='Z', grid_on=True, colorbar=True): """Plot a nuclear chart with (N,Z) as axis and the values of the Table as a color scale Parameters ---------- ax: optional matplotlib axes defaults to current axes cmap: a matplotlib colormap default: 'RdBu' xlabel: string representing the label of the x axis default: 'N' ylabel: string, default: 'Z' the label of the x axis grid_on: boolean, default: True, whether to draw the axes grid or not colorbar: boolean, default: True whether to draw a colorbar or not Returns ------- ax: a matplotlib axes object Example ------- Plot the theoretical deviation for the Möller's model:: >>> Table('FRDM95').error().chart_plot() """ from matplotlib.mlab import griddata from numpy import linspace, meshgrid import matplotlib.pyplot as plt # extract the 1D arrays to be plotted x = self.dropna().N y = self.dropna().Z z = self.dropna().values #convert to matplotlibs grid format xi = linspace(min(x), max(x), max(x) - min(x) + 1) yi = linspace(min(y), max(y), max(y) - min(y) + 1) Z = griddata(x, y, z, xi, yi) X, Y = meshgrid(xi, yi) # create and customize plot if ax is None: ax = plt.gca() chart = ax.pcolormesh(X, Y, Z, cmap=cmap) ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) ax.grid(grid_on) ax.set_aspect('equal') if colorbar: plt.colorbar(chart) return ax

def _uses_db(func, self, *args, **kwargs): """ Use as a decorator for operations on the database, to ensure connection setup and teardown. Can only be used on methods on objects with a `self.session` attribute. """ if not self.session: _logger.debug('Creating new db session') self._init_db_session() try: ret = func(self, *args, **kwargs) self.session.commit() except: self.session.rollback() tb = traceback.format_exc() _logger.debug(tb) raise finally: _logger.debug('Closing db session') self.session.close() return ret

def derive_key(self, master_password): """ Computes the key from the salt and the master password. """ encoder = encoding.Encoder(self.charset) bytes = ('%s:%s' % (master_password, self.name)).encode('utf8') start_time = time.clock() # we fix the scrypt parameters in case the defaults change digest = scrypt.hash(bytes, self.salt, N=1<<14, r=8, p=1) key = encoder.encode(digest, self.key_length) derivation_time_in_s = time.clock() - start_time _logger.debug('Key derivation took %.2fms', derivation_time_in_s*1000) return key

def bootstrap(self, path_or_uri): """ Initialize a database. :param database_path: The absolute path to the database to initialize. """ _logger.debug("Bootstrapping new database: %s", path_or_uri) self.database_uri = _urify_db(path_or_uri) db = sa.create_engine(self.database_uri) Base.metadata.create_all(db)

def search(self, query): """ Search the database for the given query. Will find partial matches. """ results = self.session.query(Domain).filter(Domain.name.ilike('%%%s%%' % query)).all() return results

def get_domain(self, domain_name): """ Get the :class:`Domain <pwm.Domain>` object from a name. :param domain_name: The domain name to fetch the object for. :returns: The :class:`Domain <pwm.core.Domain>` class with this domain_name if found, else None. """ protocol = self.database_uri.split(':', 1)[0] if protocol in ('https', 'http'): return self._get_domain_from_rest_api(domain_name) else: domain = self._get_domain_from_db(domain_name) if domain: return domain else: raise NoSuchDomainException

def modify_domain(self, domain_name, new_salt=False, username=None): """ Modify an existing domain. :param domain_name: The name of the domain to modify. :param new_salt: Whether to generate a new salt for the domain. :param username: If given, change domain username to this value. :returns: The modified :class:`Domain <pwm.core.Domain>` object. """ domain = self._get_domain_from_db(domain_name) if domain is None: raise NoSuchDomainException if new_salt: _logger.info("Generating new salt..") domain.new_salt() if username is not None: domain.username = username return domain

def create_domain(self, domain_name, username=None, alphabet=Domain.DEFAULT_ALPHABET, length=Domain.DEFAULT_KEY_LENGTH): """ Create a new domain entry in the database. :param username: The username to associate with this domain. :param alphabet: A character set restriction to impose on keys generated for this domain. :param length: The length of the generated key, in case of restrictions on the site. """ # Wrap the actual implementation to do some error handling try: return self._create_domain(domain_name, username, alphabet, length) except Exception as ex: _logger.warn("Inserting new domain failed: %s", ex) raise DuplicateDomainException

def from_bbox(bbox, zlevs): """Yields tile (x, y, z) tuples for a bounding box and zoom levels. Arguments: bbox - bounding box as a 4-length sequence zlevs - sequence of tile zoom levels """ env = Envelope(bbox) for z in zlevs: corners = [to_tile(*coord + (z,)) for coord in (env.ul, env.lr)] xs, ys = [range(p1, p2 + 1) for p1, p2 in zip(*corners)] for coord in itertools.product(xs, ys, (z,)): yield coord

def to_lonlat(xtile, ytile, zoom): """Returns a tuple of (longitude, latitude) from a map tile xyz coordinate. See http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Lon..2Flat._to_tile_numbers_2 Arguments: xtile - x tile location as int or float ytile - y tile location as int or float zoom - zoom level as int or float """ n = 2.0 ** zoom lon = xtile / n * 360.0 - 180.0 # Caculate latitude in radians and convert to degrees constrained from -90 # to 90. Values too big for tile coordinate pairs are invalid and could # overflow. try: lat_rad = math.atan(math.sinh(math.pi * (1 - 2 * ytile / n))) except OverflowError: raise ValueError('Invalid tile coordinate for zoom level %d' % zoom) lat = math.degrees(lat_rad) return lon, lat

def to_tile(lon, lat, zoom): """Returns a tuple of (xtile, ytile) from a (longitude, latitude) coordinate. See http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames Arguments: lon - longitude as int or float lat - latitude as int or float zoom - zoom level as int or float """ lat_rad = math.radians(lat) n = 2.0 ** zoom xtile = int((lon + 180.0) / 360.0 * n) ytile = int((1.0 - math.log(math.tan(lat_rad) + (1 / math.cos(lat_rad))) / math.pi) / 2.0 * n) return xtile, ytile

def extract_hbs(fileobj, keywords, comment_tags, options): """Extract messages from Handlebars templates. It returns an iterator yielding tuples in the following form ``(lineno, funcname, message, comments)``. TODO: Things to improve: --- Return comments """ server = get_pipeserver() server.sendline(COMMAND+u'PARSE FILE:'+fileobj.name) server.expect(RESPONSE+'SENDING OUTPUT') server.expect(RESPONSE+'OUTPUT END') trans_strings = server.before for item in json.loads(trans_strings): messages = [item['content']] if item['funcname'] == 'ngettext': messages.append(item['alt_content']) yield item['line_number'],item['funcname'],tuple(messages),[]

def vsiprefix(path): """Returns a GDAL virtual filesystem prefixed path. Arguments: path -- file path as str """ vpath = path.lower() scheme = VSI_SCHEMES.get(urlparse(vpath).scheme, '') for ext in VSI_TYPES: if ext in vpath: filesys = VSI_TYPES[ext] break else: filesys = '' if filesys and scheme: filesys = filesys[:-1] return ''.join((filesys, scheme, path))

def srid(self): """Returns the EPSG ID as int if it exists.""" epsg_id = (self.GetAuthorityCode('PROJCS') or self.GetAuthorityCode('GEOGCS')) try: return int(epsg_id) except TypeError: return

def main(): """ Main entry point for the CLI. """ args = get_args() ret_code = args.target(args) _logger.debug('Exiting with code %d', ret_code) sys.exit(ret_code)

def _init_logging(verbose=False): """ Initialize loggers. """ config = { 'version': 1, 'formatters': { 'console': { 'format': '* %(message)s', } }, 'handlers': { 'console': { 'class': 'logging.StreamHandler', 'level': 'DEBUG', 'formatter': 'console', 'stream': 'ext://sys.stdout', } }, 'loggers': { 'pwm': { 'level': 'DEBUG' if verbose else 'INFO', 'handlers': ['console'], 'propagate': True, }, 'requests.packages.urllib3': { 'level': 'INFO' if verbose else 'WARNING', 'handlers': ['console'], 'propagate': True, } } } logging.config.dictConfig(config) HTTPConnection.debuglevel = 1 if verbose else 0

def update_file(url, filename): """Update the content of a single file.""" resp = urlopen(url) if resp.code != 200: raise Exception('GET {} failed.'.format(url)) with open(_get_package_path(filename), 'w') as fp: for l in resp: if not l.startswith(b'#'): fp.write(l.decode('utf8')) print('Updated {}'.format(filename))

def available_drivers(): """Returns a dictionary of enabled GDAL Driver metadata keyed by the 'ShortName' attribute. """ drivers = {} for i in range(gdal.GetDriverCount()): d = gdal.GetDriver(i) drivers[d.ShortName] = d.GetMetadata() return drivers

def driver_for_path(path, drivers=None): """Returns the gdal.Driver for a path or None based on the file extension. Arguments: path -- file path as str with a GDAL supported file extension """ ext = (os.path.splitext(path)[1][1:] or path).lower() drivers = drivers or ImageDriver.registry if ext else {} for name, meta in drivers.items(): if ext == meta.get('DMD_EXTENSION', '').lower(): return ImageDriver(name) return None

def geom_to_array(geom, size, affine): """Converts an OGR polygon to a 2D NumPy array. Arguments: geom -- OGR Geometry size -- array size in pixels as a tuple of (width, height) affine -- AffineTransform """ driver = ImageDriver('MEM') rast = driver.raster(driver.ShortName, size) rast.affine = affine rast.sref = geom.GetSpatialReference() with MemoryLayer.from_records([(1, geom)]) as ml: status = gdal.RasterizeLayer(rast.ds, (1,), ml.layer, burn_values=(1,)) arr = rast.array() rast.close() return arr

def rasterize(layer, rast): """Returns a Raster from layer features. Arguments: layer -- Layer to rasterize rast -- Raster with target affine, size, and sref """ driver = ImageDriver('MEM') r2 = driver.raster(driver.ShortName, rast.size) r2.affine = rast.affine sref = rast.sref if not sref.srid: sref = SpatialReference(4326) r2.sref = sref ml = MemoryLayer(sref, layer.GetGeomType()) ml.load(layer) status = gdal.RasterizeLayer( r2.ds, (1,), ml.layer, options=['ATTRIBUTE=%s' % ml.id]) ml.close() return r2

def open(path, mode=gdalconst.GA_ReadOnly): """Returns a Raster instance. Arguments: path -- local or remote path as str or file-like object Keyword args: mode -- gdal constant representing access mode """ path = getattr(path, 'name', path) try: return Raster(vsiprefix(path), mode) except AttributeError: try: imgdata = path.read() except AttributeError: raise TypeError('Not a file-like object providing read()') else: imgio = MemFileIO(delete=False) gdal.FileFromMemBuffer(imgio.name, imgdata) return Raster(imgio, mode) raise ValueError('Failed to open raster from "%r"' % path)