def export_intervals(chanjo_db, include_header=True, bed_score=0): r"""Return BED-formatted interval lines from existing ``chanjo_db``. BED lines are ready to be printed or written to a file. Args: chanjo_db (session): ``sqlalchemy.orm.session`` object with a ``.query``-method include_header (bool, optional): whether to include BED header bed_score (int, optional): dummy score (0-1000) to insert at field 5 to complete the BED format Yields: str: stringified and tab-delimited interval Examples: >>> from chanjo import export_intervals, Store ... # instantiate a new connection to a Chanjo database >>> db = Store('./coverage.sqlite') >>> with open('intervals.sorted.bed', 'w') as stream: ... # write intervals in BED-format with appropriate headers ... for bed_line in export_intervals(db): ... stream.write(bed_line + '\n') """ if include_header: yield '#chrom\tchromStart\tchromEnd\tname\tscore\tstrand' # setup up which columns to fetch to make BED file # column 5 is just a silly default for the "score" field in BED i = Interval # alias columns = (i.contig, i.start - 1, i.end, i.id, i.strand) # BED files are tab-delimited delimiter = '\t' # 1. fetch interval tuples from the database (producer) # 2. stringify each item in each subsequence (interval tuple) # 3. join lines on tab-character # 4. prepend the header bed_lines = pipe( fetch_records(chanjo_db, columns), map(map(str)), # convert fields to strings map(juxt(compose(list, take(4)), # keep first 4 fields lambda _: [str(bed_score)], # insert BED score compose(list, last))), # keep last field map(concat), # flatten each item map(delimiter.join) # join on \t ) for bed_line in bed_lines: yield bed_line
def make_data(val): clients = compose( count, unique, pluck('customer'), lambda: val ) animals = compose( valmap(count), groupby('species'), lambda: val ) return { 'total_val': reduce(lambda total, x: total + x.get('total_vat'), val, 0.00), 'animals': _get_dict_to_csv(animals()), 'clients': clients() }
def _get_filters(filters): join = compose(lambda x: " AND ".join(x), concatv) clauses = join( ["bl.posting_datetime BETWEEN %(from_date)s AND %(to_date)s"], ["bl.station = %(station)s"] if filters.station else [], ) return clauses, filters
def tom_base_state_to_base_state(tom_base_state): tom_base_state = valmap(compose(np.copy, np.flip), tom_base_state) q, T, z, rho = get(["qv", "T", "z", "rho"], tom_base_state) return { "QT": q * 1000.0, "SLI": T + grav / cp * z, "height_center": z, "density": rho }
def get_orders_for(station=None, shipping_order=None): def get_qty(row): if row.get("loading_unit") == "Packages": return row.get("no_of_packages") if row.get("loading_unit") == "Weight": return row.get("weight_actual") return 0 def set_qty(row): qty = get_qty(row) return merge(row, {"qty": qty, "available": qty}) get_result = compose(list, map(set_qty), frappe.db.sql) if station: return get_result( """ SELECT bl.booking_order, MAX(bl.loading_unit) AS loading_unit, SUM(bl.no_of_packages) AS no_of_packages, SUM(bl.weight_actual) AS weight_actual, bl.bo_detail, bofd.item_description AS description FROM `tabBooking Log` AS bl LEFT JOIN `tabBooking Order Freight Detail` AS bofd ON bofd.name = bl.bo_detail WHERE bl.station = %(station)s GROUP BY bl.bo_detail HAVING SUM(bl.no_of_packages) > 0 OR SUM(bl.weight_actual) > 0 """, values={"station": station}, as_dict=1, ) if shipping_order: return get_result( """ SELECT bl.booking_order, MAX(bl.loading_unit) AS loading_unit, -SUM(bl.no_of_packages) AS no_of_packages, -SUM(bl.weight_actual) AS weight_actual, bl.bo_detail, bofd.item_description AS description FROM `tabBooking Log` AS bl LEFT JOIN `tabBooking Order Freight Detail` AS bofd ON bofd.name = bl.bo_detail WHERE bl.shipping_order = %(shipping_order)s GROUP BY bl.bo_detail HAVING SUM(bl.no_of_packages) < 0 OR SUM(bl.weight_actual) < 0 """, values={"shipping_order": shipping_order}, as_dict=1, ) return []
def __init__(self, **kwargs): self.attrs = pipe( self.imports, reversed, map(vars), merge, keyfilter(compose(str.islower, first), ), valfilter(callable), ) self.attrs.update()
def __repr__(self): self._tokens = pipe( self._tokens, filter( compose(complement( lambda s: s.startswith('_ipython') or s.startswith('_repr') if isinstance(s, str) else s, ), first, second,) ), list ) return super().__repr__()
def get_realStats(coords_all, coords_sub, indexes, r_stat, cell, pbc): frac_coords = get_scaled_positions(cell=cell, pbc=pbc, wrap=True) real_coords = get_real_positions(cell=cell) rescale = compose(real_coords, frac_coords) return pipe( indexes, lambda indxs: rescale(coords_all[indxs[:, 1]] - coords_sub[ indxs[:, 0]] + cell.diagonal() / 2), lambda crds: crds - cell.diagonal() / 2)
def extract_ctr_children_sum(doc: Tabs_doc) -> Dict[Tab_num, Disp_dur]: default = {'dispatchCount': np.nan, 'duration': np.nan} def reduce_children(chs: List[Disp_dur]): # TODO: extract host info? disp_durs = lmap(extract_dur_disp_tab, chs) return reduce_keys(op.add, disp_durs) or default tab_docs = z.valmap(z.compose(reduce_children, itg('children')), doc) return tab_docs
def get_legal_doc(content_type): get_content = compose( lambda x: frappe.get_cached_value("Terms and Conditions", x, "terms"), lambda x: frappe.get_cached_value("Leiteng Website Settings", None, x), ) if content_type in ["privacy", "terms"]: return get_content(content_type) return None
def remove_paths(paths, graph): # Allow passing a single path. if isinstance(paths, str): paths = [paths] indices_to_remove = tlz.compose( list, tlz.map(lambda v: v.index), tlz.remove(is_None), tlz.map(find_vertex_by_name_or_none(graph)))(paths) return graph - indices_to_remove if len(indices_to_remove) > 0 else graph
def sequence(*args): """Compose functions in order Args: args: the functions to compose Returns: composed functions """ return compose(*args[::-1])
def _get_filters(filters): join = compose(lambda x: " AND ".join(x), concatv) clauses = join( ["True"], ["`tabItem`.item_group = %(item_group)s"] if filters.get("item_group") else [], ["`tabBin`.warehouse = %(warehouse)s"] if filters.get("warehouse") else [], ["`tabItem Supplier`.supplier = %(supplier)s"] if filters.get("supplier") else [], ) return clauses, filters
def rcompose(*args): """Compose functions in order Args: args: the functions to compose Returns: composed functions >>> assert rcompose(lambda x: x + 1, lambda x: x * 2)(3) == 8 """ return compose(*args[::-1])
def from_tom_base_state(tom_base_state): """Return WaveEq from Tom's base state""" # TODO refactor this to an abstract factor (A) tom_base_state = valmap(compose(np.copy, np.flip), tom_base_state) q, T, z, rho = get(["qv", "T", "z", "rho"], tom_base_state) base_state = { "QT": q * 1000.0, "SLI": T + grav / cp * z, "height_center": z, "density": rho } return WaveEq(base_state)
def _get_species(patients): species = compose( valmap(lambda x: x['vc_species']), valmap(first), groupby('name'), lambda: frappe.get_all( 'Patient', filters=[['name', 'in', patients]], fields=['name', 'vc_species'] ) ) return species()
def register_jinja2_magic(env=Environment(), display='Markdown'): """Display reusable jinja2 templates. Returns a jinja2 template. """ magical( 'jinja2', lang='jinja2', display=compose( IPython.display.display, IPython.display.Markdown, lambda x: x.render(**IPython.get_ipython().user_ns), ) )(env.from_string) return env
def _get_root_groups(): def get_root(x): # assuming that parent - child relationship is never circular parent = get_parent(x) if parent: return get_root(parent) return x groups = frappe.get_all( "Item Group", fields=["name", "parent_item_group"], filters={"show_in_website": 1}, ) get_parent = compose( excepts(StopIteration, first, lambda _: None), lambda x: filter(lambda y: y.get("name") == x.get("parent_item_group"), groups), ) make_unique_roots = compose(list, unique, map(lambda x: x.get("name")), map(get_root)) return make_unique_roots(groups)
def flatten_references_graph(references_graph, pipeline, exclude_paths=None): if exclude_paths is not None: exclude_paths = frozenset(exclude_paths) references_graph = tlz.compose( tlz.map( over("references", lambda xs: frozenset(xs).difference(exclude_paths))), tlz.remove(lambda node: node["path"] in exclude_paths))( references_graph) igraph_graph = references_graph_to_igraph(references_graph) return create_list_of_lists_of_strings(pipe(pipeline, igraph_graph))
def list_addresses(token, page="1", page_length="10"): decoded_token = get_decoded_token(token) customer_id = frappe.db.exists( "Customer", {"le_firebase_uid": decoded_token["uid"]} ) if not customer_id: frappe.throw(frappe._("Customer does not exist on backend")) get_count = compose( lambda x: x[0][0], lambda x: frappe.db.sql( """ SELECT COUNT(name) FROM `tabDynamic Link` WHERE parenttype = 'Address' AND link_doctype = 'Customer' AND link_name = %(link_name)s """, values={"link_name": x}, ), ) addresses = frappe.db.sql( """ SELECT a.name AS name, a.address_line1 AS address_line1, a.address_line2 AS address_line2, a.city AS city, a.state AS state, a.country AS country, a.pincode AS pincode FROM `tabDynamic Link` AS dl LEFT JOIN `tabAddress` AS a ON a.name = dl.parent WHERE dl.parenttype = 'Address' AND dl.link_doctype = 'Customer' AND dl.link_name = %(link_name)s GROUP BY a.name ORDER BY a.modified DESC LIMIT %(start)s, %(page_length)s """, values={ "link_name": customer_id, "start": (frappe.utils.cint(page) - 1) * frappe.utils.cint(page_length), "page_length": frappe.utils.cint(page_length), }, as_dict=1, ) return { "count": get_count(customer_id), "items": addresses, }
def get_realStats(coords_all, coords_sub, r_stat, cutoff, cell, cell_dim, pbc,): import MDAnalysis tree = MDAnalysis.lib.pkdtree.PeriodicKDTree(box=cell_dim.astype(np.float32)) tree.set_coords(coords_all.astype(np.float32), cutoff=np.float32(cutoff)) frac_coords = get_scaled_positions(cell=cell, pbc=pbc, wrap=True) real_coords = get_real_positions(cell=cell) rescale = compose(real_coords, frac_coords) return pipe(tree.search_tree(coords_sub, radius=r_stat), lambda indxs: rescale(coords_all[indxs[:,1]] - coords_sub[indxs[:,0]] + cell.diagonal()/2), lambda crds: crds - cell.diagonal()/2)
def _extend_data(filters, data, inv_idx, emp_idx): invoices = [x[inv_idx] for x in data] get_employee_map = compose( valmap(lambda x: [x.get("pb_sales_employee"), x.get("pb_sales_employee_name")]), valmap(first), groupby("name"), lambda: frappe.db.sql( """ SELECT name, pb_sales_employee, pb_sales_employee_name FROM `tabSales Invoice` WHERE name IN %(invoices)s """, values={"invoices": invoices}, as_dict=1, ), ) employees = get_employee_map() if invoices else {} set_employee = compose(list, lambda x: concatv(employees[x[inv_idx]], x)) set_commission = compose( list, lambda x: concatv( x, [ x[filters.net_amount_col_idx] * frappe.utils.flt( filters.commission_rate) / 100 ], ), ) make_row = compose(set_employee, set_commission) extended = [make_row(x) for x in data] if not filters.sales_employee: return extended return [x for x in extended if x[emp_idx] == filters.sales_employee]
def list_addresses(token, page="1", page_length="10"): customer_id = get_customer_id(token) get_count = compose( lambda x: x[0][0], lambda x: frappe.db.sql( """ SELECT COUNT(name) FROM `tabDynamic Link` WHERE parenttype = 'Address' AND link_doctype = 'Customer' AND link_name = %(link_name)s """, values={"link_name": x}, ), ) addresses = frappe.db.sql( """ SELECT a.name AS name, a.address_line1 AS address_line1, a.address_line2 AS address_line2, a.city AS city, a.state AS state, a.country AS country, a.pincode AS pincode FROM `tabDynamic Link` AS dl LEFT JOIN `tabAddress` AS a ON a.name = dl.parent WHERE dl.parenttype = 'Address' AND dl.link_doctype = 'Customer' AND dl.link_name = %(link_name)s GROUP BY a.name ORDER BY a.modified DESC LIMIT %(start)s, %(page_length)s """, values={ "link_name": customer_id, "start": (frappe.utils.cint(page) - 1) * frappe.utils.cint(page_length), "page_length": frappe.utils.cint(page_length), }, as_dict=1, ) count = get_count(customer_id) return { "count": count, "pages": frappe.utils.ceil(count / frappe.utils.cint(page_length)), "items": addresses, }
def subcomponent(mode, paths, graph): path_indices = tlz.compose( tlz.map(attrgetter('index')), tlz.remove(is_None), tlz.map(find_vertex_by_name_or_none(graph)))(paths) debug("path_indices", path_indices) main_indices = list(subcomponent_multi(graph, path_indices, mode)) debug('main_indices', main_indices) return { "main": graph.induced_subgraph(main_indices), "rest": graph - main_indices }
def __init__(self, limit=None, schema=None, keep_properties=True, chunk=False): self.schema = schema self.limit = limit self.chunk = chunk or False self.set_property_filter(keep_properties) # Set up pipeline, in reverse order steps = [self.validate, self.process] if self.limit is not None: self.logger.debug(f'Loading %s features only', self.limit) steps.append(take(self.limit)) if self.chunk: self.logger.debug(f'Features will arrive in batches of %s', self.chunk) steps.append(lambda it: grouper(self.chunk, it)) self.pipeline = compose(*reversed(steps))
def _update_freight(bo, si): get_freight_row = compose( excepts(StopIteration, first, lambda _: None), lambda name: filter(lambda x: x.name == name, bo.freight), ) for sii in [x for x in si.items if x.gg_update_freight]: freight = get_freight_row(sii.gg_bo_detail) if freight: freight.based_on = frappe.get_cached_value("Item", sii.item_code, "gg_freight_based_on") if freight.based_on == "Packages": freight.no_of_packages = sii.qty elif freight.based_on == "Weight": freight.weight_actual = sii.qty freight.rate = sii.rate freight.amount = sii.amount
def get_item(route): item_code = frappe.db.exists("Item", { "route": route.replace("__", "/"), "show_in_website": 1 }) if not item_code: frappe.throw(frappe._("Item does not exist at this route")) doc = frappe.db.get_value( "Item", item_code, fieldname=[ "name", "item_name", "item_group", "has_variants", "description", "web_long_description", "image", "website_image", ], as_dict=1, ) get_price_list_rate = compose( lambda x: frappe.db.get_value( "Item Price", filters={ "item_code": item_code, "price_list": x }, fieldname="price_list_rate", ) if x else None, lambda: frappe.get_cached_value("Shopping Cart Settings", None, "price_list"), ) return merge( {"route": route}, doc, { "description": frappe.utils.strip_html_tags(doc.get("description") or ""), "price_list_rate": get_price_list_rate(), }, )
def sort_ips(inpath, keepcomments, clipboard): '''Given a list of IPs (one per line) from a file path (INPATH), the clipboard (-C), or stdin if nothing provided, print in sorted order (to stdout unless -C is provided). ''' content = get_input_content(inpath, clipboard) return pipe( content.splitlines(), map(do_nothing if keepcomments else strip_comments), filter(lambda l: l.strip()), filter(compose(is_ip, strip, strip_comments)), sortips, '\n'.join, print if not clipboard else cb_copy_ensure_nl, )
def fcompose(*args): """Helper function to compose functions. >>> f = lambda x: x - 2 >>> g = lambda x: 2 * x >>> f(g(3)) 4 >>> fcompose(g, f)(3) 4 Args: *args: tuple of functions Returns: composed functions """ return compose(*args[::-1])
def fcompose(*args): """Helper function to compose functions. >>> f = lambda x: x - 2 >>> g = lambda x: 2 * x >>> f(g(3)) 4 >>> fcompose(g, f)(3) 4 Args:xb *args: tuple of funct]ions Retuns: composed functions """ return compose(*args[::-1])
def _get_columns(filters): join = compose(list, concatv) return join( [ { "fieldtype": "Data", "fieldname": "item_description", "label": "Description", "width": 240, }, { "fieldtype": "Link", "fieldname": "booking_order", "options": "Booking Order", "label": "Booking Order", "width": 120, }, { "fieldtype": "Data", "fieldname": "consignor_name", "label": "Consignor Name", "width": 180, }, { "fieldtype": "Data", "fieldname": "consignee_name", "label": "Consignee Name", "width": 180, }, ], concat([ { "fieldtype": "Int", "fieldname": "{}__no_of_packages".format(x), "label": "{} Packages".format(x), "width": 90, }, { "fieldtype": "Float", "fieldname": "{}__weight_actual".format(x), "label": "{} Weight".format(x), "width": 90, }, ] for x in activities), )
def add_weight(answer: dict): def is_a_matching_question(answer): return pipe( [answer_keys.match_left, answer_keys.incorrect], map(lambda k: k in answer), any, ) needs_weight = compose( any, juxt(complement(is_a_matching_question), ), ) if needs_weight(answer): return assoc(answer, answer_keys.weight, int(answer.get(answer_keys.weight, 0) and 100)) return answer
"EXPOSE 5000\n" "\n" "ENTRYPOINT [ \"bokeh-server\" ]\n" "CMD [ \"--ip=0.0.0.0\", \"--port=5000\" ]\n" ).format(version=version) def write_file((filename, data)): print("Write '{}' .. ".format(filename), end="") with open(filename, 'w') as f: f.write(data) print("OK") if __name__ == "__main__": import argparse parser = argparse.ArgumentParser(description="Generates bokeh Dockerfile for given version") parser.add_argument("version", type=str, nargs="*") args = parser.parse_args() list(map( compose( write_file, juxt([ "Dockerfile_{}".format, get_dockerfile ]) ), args.version ))