def __init__(self, name, entrys): self.name = name self.entrys = self.prepare_entrys(entrys) self.entrys_by_name = enumerable.new(self.entrys) \ .dict_values(lambda e: flect.invariate_identifier(e.name)) self.entrys_by_identifier = enumerable.new(self.entrys) \ .dict_values(lambda e: e.identifier)
def __init__(self, patterns): self.patterns = patterns self.regex = re.compile( "(" + enumerable.new(self.patterns) \ .convert_with_index(lambda p, i: "(?P<{0}>{1})".format(MultiPattern.GROUP_PREFIX + str(i), p)) \ .str("|") + ")" ) self.group_index_to_multi_index = enumerable.new(range(0, len(self.patterns))) \ .dict_values(lambda i: self.regex.groupindex.get(MultiPattern.GROUP_PREFIX + str(i)))
def render_object(obj, renderer): renderer.append("{") renderer.start_section() enumerable.new(obj.__dict__.iteritems()) \ .prepend_item(["@cls", type(obj).__name__]) \ .process_interleaved( lambda p: render_pair(p[0], p[1], renderer), lambda: renderer.end_line(",") ) renderer.end_section() renderer.append("}")
def render_list(lst, renderer): if len(lst) <= 0: renderer.append("[]") else: renderer.append("[") renderer.start_section() enumerable.new(lst) \ .process_interleaved( lambda v: render_value(v, renderer), lambda: renderer.end_line(",") ) renderer.end_section() renderer.append("]")
def render(self, pdf_renderer, value): if len(value) <= 0: pdf_renderer.append("<< >>") else: pdf_renderer.append("<<") pdf_renderer.start_section() enumerable.new(value.iteritems()) \ .skip(lambda p: p[1] is None) \ .process( lambda p: pdf_renderer.append_pair(p[0], p[1]) ) pdf_renderer.end_section() pdf_renderer.append(">>")
def render_dictionary(dictionary, renderer): if len(dictionary) <= 0: renderer.append("{}") else: renderer.append("{") renderer.start_section() enumerable.new(dictionary.iteritems()) \ .process_interleaved( lambda p: render_pair(p[0], p[1], renderer), lambda: renderer.end_line(",") ) renderer.end_section() renderer.append("}")
def validate(self): if not self.multi_pattern: self.multi_pattern = rexex.MultiPattern( enumerable.new(self.component_definition_tokens) \ .convert(lambda d: d.get_pattern()) \ .lst() )
def fetch_cls_handling_provider(self, cls): if cls: return helpers.get_or_create_by_key( self.cls_handling_providers, cls, lambda t: enumerable.new(flect.get_all_base_classes(cls)) \ .convert(lambda c: self.cls_handling_providers.get(c, None)) \ .skip_none() \ .first() )
def __init__(self, singular_name, plural_name, abbreviations): self.singular_name = singular_name self.plural_name = plural_name self.abbreviations = abbreviations self.identifiers = enumerable.new(self.abbreviations) \ .append_item(self.singular_name) \ .append_item(self.plural_name) \ .convert(lambda s: flect.invariate_identifier(s)) \ .set()
def render_to(self, renderer): renderer.start_line() renderer.append(str(self.method_info)) renderer.append("({0:.3f}s, {1:.2f}% of parent) ".format( self.get_total_time(), self.get_percent_of_parent() * 100.0)) renderer.append("({0:.3f}s, {1:.2f}% of self) ".format( self.get_self_time(), self.get_percent_of_total() * 100.0)) if len(self.child_method_instances): renderer.append_line("{") renderer.start_section() enumerable.new(self.child_method_instances.values()) \ .process( lambda v: v.render_to(renderer) ) renderer.end_section() renderer.append_line("}") renderer.end_line()
def create_image_pack_pdf(xobject_images, size): pdf = pdfex.PDFDocument() bounds = mhat.Rect2(size=size) to_pack = enumerable.new(xobject_images) \ .convert(lambda i: spack.PackedRect(i.get_physical_size(), i)) \ .lst() for sheet in spack.pack(bounds, to_pack): page = pdf.pages.add_page(pdfex.IndirectObject_PageEX(bounds=bounds)) for rect in sheet: page.contents.statements.append( pdfex.Statement_Compound_PaintImage(rect.data, rect.rect.get_lower_left()) ) return pdf
def pack_sheet(base_rect, to_pack, can_flip=False): boxs = [base_rect] packed_rects = [] unpacked_rects = [] for packed_rect in enumerable.new(to_pack).sort_descending( lambda p: p.size.get_max()): box, size = find_best_box_and_size(packed_rect.size, boxs, can_flip) if box: boxs.remove(box) ll, lr, ur, ul = box.quadsect_lower_left_offset(size) boxs.extend([lr, ur, ul]) packed_rect.pack(ll) packed_rects.append(packed_rect) else: packed_rect.depack() unpacked_rects.append(packed_rect) return packed_rects, unpacked_rects
def get_variable_expressions(self, variable): return enumerable.new(self.add_expressions) \ .append(self.subtract_expressions) \ .narrow(lambda e: e.has_variable(variable)) \ .lst()
def __str__(self, *args, **kwargs): return "[" + enumerable.new(self.components).str(", ") + "]"
def has_variable(self, variable): return enumerable.new(self.add_expressions) \ .append(self.subtract_expressions) \ .has(lambda e: e.has_variable(variable))
def get_xobjects(self): return enumerable.new(self.statements) \ .expand(lambda s: s.get_xobjects())
def repr_self_and_values(obj, values): return repr_string(obj, str(obj) + " : " + enumerable.new(values).str(", "))
def get_all_base_classes(cls): return enumerable.new(cls.__bases__) \ .expandigate(lambda x: get_all_base_classes_with_self(x))
def get_entrys(self): return enumerable.new(self.entrys) \ .dct(lambda e: [e.name, e.get_value()])
def get_all_subclasses(cls): return enumerable.new(cls.__subclasses__()) \ .expand(lambda x: get_all_subclasses_with_self(x))
def get_all_subclasses_with_self(cls): return enumerable.new(get_all_subclasses(cls)) \ .prepend_item(cls)
def repr_values(obj, values): return repr_string(obj, enumerable.new(values).str(", "))
def alternative_strings(strings): return enumerable.new(strings) \ .convert(lambda s: re.escape(s)) \ .str("|")
def get_xobject_entrys(self): return enumerable.new(self.get_xobjects()) \ .dct(lambda x: [x.name, x])
def get_isolation_partial_operation(self, expression): return algae.PartialOperation_Additive( enumerable.new( self.subtract_expressions).skip_item(expression).lst(), enumerable.new(self.add_expressions).skip_item(expression).lst())
def __init__(self, cls_handling_providers): self.cls_handling_providers = enumerable.new(cls_handling_providers) \ .dict_values(lambda v: v.cls)
def __str__(self, *args, **kwargs): return "(" + \ "(" + enumerable.new(self.add_expressions).str(" + ") + ")" \ "- (" + enumerable.new(self.subtract_expressions).str(" + ") + ")" \ ")"
def get_child_time(self): return enumerable.new(self.child_method_instances.values()) \ .convert(lambda c: c.get_total_time()) \ .sum()