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()
