def mask_id64_as_system(input): result = input if util.is_str(input): result = int(result, 16) result &= (2**55) - 1 if util.is_str(input): result = '{0:016X}'.format(result) return result
def mask_id64_as_body(input): result = input if util.is_str(input): result = int(result, 16) result >>= 55 result &= (2**9) - 1 if util.is_str(input): result = '{0:X}'.format(result) return result
def _get_sector_class(sect): if util.is_str(sect) and sect.lower() in pgdata.ha_sectors: return "ha" frags = get_sector_fragments(sect) if util.is_str(sect) else sect if frags is not None and len(frags) == 4 and frags[ 0] in pgdata.cx_prefixes and frags[2] in pgdata.cx_prefixes: return 2 elif frags is not None and len(frags) in [ 3, 4 ] and frags[0] in pgdata.cx_prefixes: return 1 else: return None
def get_mcode(input): if util.is_str(input) and len(input) == 1: return input.lower() elif isinstance(input, numbers.Number) and (int(input) % 10) == 0: return chr(int(math.log(input / 10, 2)) + ord('a')) else: raise ValueError("First argument to get_mcode must be string or numeric and multiple of 10")
def _get_as_filters(self, s): if s is None: return None elif util.is_str(s): return self.parse_filter_string(s) else: return s
def get_mcode_cube_width(mcode): if util.is_str(mcode): return sector_size / pow(2, ord('h') - ord(mcode.lower())) elif isinstance(mcode, numbers.Number): return mcode else: raise ValueError("First argument to get_mcode_cube_width must be string or numeric")
def calculate_from_id64(input): # If input is a string, assume hex if util.is_str(input): input = int(input, 16) # Calculate the shifts we need to do to get the individual fields out # Can't tell how long N2 field is (or if the start moves!), assuming ~16 for now len_used = 0 input, mc = util.unpack_and_shift(input, 3) len_used += 3 # mc = 0-7 for a-h input, boxel_z = util.unpack_and_shift(input, 7 - mc) len_used += 7 - mc input, sector_z = util.unpack_and_shift(input, 7) len_used += 7 input, boxel_y = util.unpack_and_shift(input, 7 - mc) len_used += 7 - mc input, sector_y = util.unpack_and_shift(input, 6) len_used += 6 input, boxel_x = util.unpack_and_shift(input, 7 - mc) len_used += 7 - mc input, sector_x = util.unpack_and_shift(input, 7) len_used += 7 input, n2 = util.unpack_and_shift(input, 55 - len_used) input, body_id = util.unpack_and_shift(input, 9) # Multiply each X/Y/Z value by the cube width to get actual coords boxel_size = 10 * (2**mc) coord_x = (sector_x * sector.sector_size) + (boxel_x * boxel_size) + (boxel_size / 2) coord_y = (sector_y * sector.sector_size) + (boxel_y * boxel_size) + (boxel_size / 2) coord_z = (sector_z * sector.sector_size) + (boxel_z * boxel_size) + (boxel_size / 2) coords_internal = vector3.Vector3(coord_x, coord_y, coord_z) # Shift the coords to be the origin we know and love coords = coords_internal + sector.internal_origin_offset return (coords, boxel_size, n2, body_id)
def format_sector_name(input): frags = get_sector_fragments(input) if util.is_str(input) else input if frags is None: return None if len(frags) == 4 and frags[2] in pgdata.cx_prefixes: return "{0}{1} {2}{3}".format(*frags) else: return "".join(frags)
def __init__(self, Words, DocIndex=dict(), Results=[], SubSentenceMultiplier=100, WordMultiplier=100, Prg=dict(), WordsDetected=set(), FileSourceBaseName=""): if util.is_str(Words): Words = [Words] self.Words = Words # ["apple"] name is a list with used keywords+operators # if you have more than one elem in Words, you get it after an operator exec self.Prg = Prg self.WordsDetected = WordsDetected self.DocIndex = DocIndex self.FileSourceBaseName = FileSourceBaseName self.SubSentenceMultiplier = SubSentenceMultiplier self.WordMultiplier = WordMultiplier self.IsOperator = False self.IsKeyword = False self.IsGroup = False self.Results = [] # list, because set can't differentiate objects with wame values self.Explain = [] self.OperatorName = "" if len(Words) == 1: Word = Words[0] if is_operator(Word): self.IsOperator = True self.OperatorName = Word elif util.is_str(Word): # the word can be written with uppercase/lowercase too, # in the db I use lowercase version self.IsKeyword = True self.load_from_docindex([Word.lower()]) if not self.Results: self.group_words_collect(Word) elif len(Words) > 1: self.IsGroup = True if Results: self.Results = Results
def get_system_by_id64(self, id64, keep_data=False): if util.is_str(id64): id64 = int(id64, 16) coords, cube_width, n2, _ = system.calculate_from_id64(id64) # Get a system prototype to steal its name sys_proto = pgnames.get_system(coords, cube_width) pname = sys_proto.name + str(n2) result = self._backend.get_system_by_id64(id64, fallback_name=pname) if result is not None: return _make_known_system(result, keep_data) else: return None
def _get_sector_from_name(sector_name, allow_ha=True): sector_name = get_canonical_name(sector_name, sector_only=True) if sector_name is None: return None if allow_ha and util.is_str( sector_name) and sector_name.lower() in pgdata.ha_sectors: return pgdata.ha_sectors[sector_name.lower()] else: frags = get_sector_fragments(sector_name) if util.is_str( sector_name) else sector_name if frags is not None: sc = _get_sector_class(frags) if sc == 2: # Class 2 return _c2_get_sector(frags) elif sc == 1: # Class 1 return _c1_get_sector(frags) else: return None else: return None
def _c2_get_sector(input): frags = get_sector_fragments(input) if util.is_str(input) else input if frags is None: return None offset = _c2_get_offset_from_name(frags) if offset is None: return None # Calculate the X/Y/Z positions from the offset spos = _get_sector_pos_from_offset(offset, sector.galaxy_size) name = format_sector_name(frags) return sector.PGSector(spos[0], spos[1], spos[2], name, _get_sector_class(frags))
def TxtToObj(TokenTxtList, Index, FileSourceBaseName): # recursive txt-> TokenObj converter TokenObjects = [] for Elem in TokenTxtList: if util.is_str(Elem): TokenObjects.append( tokens.TokenObj(Elem, Index, Prg=Prg, WordsDetected=WordsDetected, FileSourceBaseName=FileSourceBaseName)) if util.is_list(Elem): TokenObjects.append(TxtToObj(Elem, Index, FileSourceBaseName)) return TokenObjects
def _c1_get_infixes(input): frags = get_sector_fragments(input) if util.is_str(input) else input if frags is None: return None if frags[-1] in pgdata.cx_prefixes: if frags[-1] in pgdata.c1_prefix_infix_override_map: return pgdata.c1_infixes[pgdata.c1_prefix_infix_override_map[ frags[-1]]] else: return pgdata.c1_infixes[1] elif frags[-1] in pgdata.c1_infixes[1]: return pgdata.c1_infixes[2] elif frags[-1] in pgdata.c1_infixes[2]: return pgdata.c1_infixes[1] else: return None
def from_id64(id, allow_ha=True, allow_known=True): if util.is_str(id): id = int(id, 16) if allow_known: with env.use() as data: ks = data.get_system_by_id64(mask_id64_as_system(id)) if ks is not None: return ks coords, cube_width, n2, _ = calculate_from_id64(id) # Get a system prototype to steal its name sys_proto = pgnames.get_system(coords, cube_width, allow_ha) name = sys_proto.name + str(n2) x, y, z = sys_proto.position return PGSystem(x, y, z, name, sector=sys_proto.sector, uncertainty=cube_width / 2.0)
def _c2_get_offset_from_name(input): frags = get_sector_fragments(input) if util.is_str(input) else input if frags is None: return try: # Get the current indexes within prefix runs (3037) cur_idx0 = _prefix_offsets[frags[0]][0] + _get_suffixes( frags[0]).index(frags[1]) cur_idx1 = _prefix_offsets[frags[2]][0] + _get_suffixes( frags[2]).index(frags[3]) except: # Either the prefix or suffix lookup failed, likely a dodgy name log.warning( "Failed to look up prefixes/suffixes in _c2_get_offset_from_name; bad sector name?" ) return None # Interleave the individual offsets into one big offset return util.interleave(cur_idx0, cur_idx1, 32) # Again, length is anyone's guess
def _get_suffixes(input, get_all=False): frags = get_sector_fragments(input) if util.is_str(input) else input if frags is None: return None wordstart = frags[0] if frags[-1] in pgdata.cx_prefixes: # Append suffix straight onto a prefix (probably C2) suffix_map_idx = pgdata.c2_prefix_suffix_override_map.get(frags[-1], 1) result = pgdata.c2_suffixes[suffix_map_idx] wordstart = frags[-1] else: # Likely C1 if frags[-1] in pgdata.c1_infixes[2]: # Last infix is consonant-ish, return the vowel-ish suffix list result = pgdata.c1_suffixes[1] else: result = pgdata.c1_suffixes[2] if get_all: return result else: return result[0:_get_prefix_run_length(wordstart)]
def is_valid_sector_name(input): frags = get_sector_fragments(input) if util.is_str(input) else input if frags is None or len(frags) == 0 or frags[0] not in pgdata.cx_prefixes: return False if len(frags) == 4 and frags[2] in pgdata.cx_prefixes: # Class 2 f1idx = pgdata.c2_prefix_suffix_override_map.get(frags[0], 1) f3idx = pgdata.c2_prefix_suffix_override_map.get(frags[2], 1) return (frags[1] in pgdata.c2_suffixes[f1idx] and frags[3] in pgdata.c2_suffixes[f3idx]) elif len(frags) in [3, 4]: # Class 1 fli_idx = pgdata.c1_prefix_infix_override_map.get(frags[0], 1) if frags[1] not in pgdata.c1_infixes[fli_idx]: return False if len(frags) == 4: fli_idx = 2 if fli_idx == 1 else 1 if frags[2] not in pgdata.c1_infixes[fli_idx]: return False flastidx = 2 if fli_idx == 1 else 1 return (frags[-1] in pgdata.c1_suffixes[flastidx]) else: # Class NOPE return False
def trans_e(mtd, e): curried = partial(trans_e, mtd) buf = cStringIO.StringIO() if e.kind == C.E.ANNO: anno = e.anno if anno.name == C.A.NEW: pass # TODO elif anno.name == C.A.OBJ: buf.write("retrieve_{}@log({})".format(util.sanitize_ty(anno.typ), anno.idx)) # @Compare(exps) => {| exps[0] (< | <= | == | != | >= | >) exps[1] |} # @CompareString(exps) => exps[0].eqauls(exps[1]) elif anno.name in [C.A.CMP, C.A.CMP_STR]: le = curried(anno.exps[0]) re = curried(anno.exps[1]) if anno.name == C.A.CMP: buf.write("{| " + le + " (< | <= | == | != | >= | >) " + re + " |}") else: buf.write("{}({},{})".format(trans_mname(C.J.STR, u"equals"), le, re)) elif e.kind == C.E.GEN: if e.es: buf.write("{| ") buf.write(" | ".join(map(curried, e.es))) buf.write(" |}") else: buf.write(C.T.HOLE) elif e.kind == C.E.ID: if hasattr(e, "ty"): buf.write(trans_ty(e.ty) + ' ') fld = None if mtd and e.id not in mtd.param_vars: fld = find_fld(mtd.clazz.name, e.id) if fld: # fname -> self.new_fname (unless the field is static) new_fname = trans_fname(fld.clazz.name, e.id, fld.is_static) if fld.is_static: # access to the static field inside the same class if fld.clazz.name == mtd.clazz.name: buf.write(e.id) # o.w., e.g., static constant in an interface, call the accessor else: buf.write(new_fname + "()") else: buf.write('.'.join([C.SK.self, new_fname])) elif e.id in [C.J.THIS, C.J.SUP]: buf.write(C.SK.self) elif util.is_str(e.id): # constant string, such as "Hello, World" str_init = trans_mname(C.J.STR, C.J.STR, [u"char[]", C.J.i, C.J.i]) s_hash = hash(e.id) % 256 # hash string value itself buf.write("{}(new Object(hash={}), {}, 0, {})".format(str_init, s_hash, e.id, len(e.id))) else: buf.write(e.id) elif e.kind == C.E.UOP: buf.write(' '.join([e.op, curried(e.e)])) elif e.kind == C.E.BOP: buf.write(' '.join([curried(e.le), e.op, curried(e.re)])) elif e.kind == C.E.DOT: # with package names, e.g., javax.swing.SwingUtilities if util.is_class_name(e.re.id) and class_lookup(e.re.id): buf.write(curried(e.re)) elif e.re.id == C.J.THIS: # ClassName.this buf.write(C.SK.self) else: rcv_ty = typ_of_e(mtd, e.le) fld = find_fld(rcv_ty, e.re.id) new_fname = trans_fname(rcv_ty, e.re.id, fld.is_static) if fld.is_static: # access to the static field inside the same class if mtd and rcv_ty == mtd.clazz.name: buf.write(e.re.id) # o.w., e.g., static constant in an interface, call the accessor else: buf.write(new_fname + "()") else: buf.write('.'.join([curried(e.le), new_fname])) elif e.kind == C.E.IDX: buf.write(curried(e.e) + '[' + curried(e.idx) + ']') elif e.kind == C.E.NEW: if e.e.kind == C.E.CALL: ty = typ_of_e(mtd, e.e.f) cls = class_lookup(ty) if cls and cls.has_init: arg_typs = map(partial(typ_of_e, mtd), e.e.a) mname = trans_mname(cls.name, cls.name, arg_typs) obj = "alloc@log({})".format(cls.id) args = [obj] + map(unicode, map(curried, e.e.a)) buf.write("{}({})".format(mname, ", ".join(args))) else: # collection or Object buf.write(C.J.NEW + ' ' + trans_ty(ty) + "()") else: # o.w., array initialization, e.g., new int[] { ... } buf.write(str(e.init)) elif e.kind == C.E.CALL: arg_typs = map(partial(typ_of_e, mtd), e.a) def trans_call(callee, rcv_ty, rcv): if callee.is_static: rcv = None logging = None if not util.is_collection(callee.clazz.name): logging = str(check_logging(mtd, callee)).lower() args = util.rm_none([rcv] + map(curried, e.a) + [logging]) mid = trans_mname(rcv_ty, callee.name, arg_typs) return u"{}({})".format(mid, ", ".join(args)) def dynamic_dispatch(rcv_ty, rcv, acc, callee): _dispatched = trans_call(callee, callee.clazz.name, rcv) _guarded = "{}.__cid == {} ? {}".format(rcv, callee.clazz.id, _dispatched) return "({} : {})".format(_guarded, acc) if e.f.kind == C.E.DOT: # rcv.mid rcv_ty = typ_of_e(mtd, e.f.le) rcv = curried(e.f.le) mname = e.f.re.id mtd_callees = find_mtds_by_sig(rcv_ty, mname, arg_typs) if mtd_callees and 1 < len(mtd_callees): # needs dynamic dispatch curried_dispatch = partial(dynamic_dispatch, rcv_ty, rcv) # TODO: use least upper bound? default_v = util.default_value(mtd_callees[0].typ) buf.write(reduce(curried_dispatch, mtd_callees, default_v)) elif mtd_callees and 1 == len(mtd_callees): mtd_callee = mtd_callees[0] buf.write(trans_call(mtd_callee, rcv_ty, rcv)) else: # unresolved, maybe library method mid = trans_mname(rcv_ty, mname, arg_typs) args = util.rm_none([rcv] + map(curried, e.a)) buf.write("{}({})".format(mid, ", ".join(args))) else: # mid mname = e.f.id # pre-defined meta information or Sketch primitive functions if mname in C.typ_arrays + [u"minimize"]: mid = mname rcv = None args = util.rm_none([rcv] + map(curried, e.a)) buf.write("{}({})".format(mid, ", ".join(args))) elif mname == C.J.SUP and mtd.is_init: # super(...) inside <init> sup = class_lookup(mtd.clazz.sup) mid = trans_mname(sup.name, sup.name, arg_typs) rcv = C.SK.self args = util.rm_none([rcv] + map(curried, e.a)) buf.write("{}({})".format(mid, ", ".join(args))) else: # member methods mtd_callees = find_mtds_by_sig(mtd.clazz.name, mname, arg_typs) if mtd_callees and 1 < len(mtd_callees): # needs dynamic dispatch curried_dispatch = partial(dynamic_dispatch, mtd.clazz.name, C.SK.self) # TODO: use least upper bound? default_v = util.default_value(mtd_callees[0].typ) buf.write(reduce(curried_dispatch, mtd_callees, default_v)) elif mtd_callees and 1 == len(mtd_callees): mtd_callee = mtd_callees[0] buf.write(trans_call(mtd_callee, mtd.clazz.name, C.SK.self)) else: # unresolved, maybe library method mid = trans_mname(mtd.clazz.name, mname, arg_typs) args = util.rm_none([rcv] + map(curried, e.a)) buf.write("{}({})".format(mid, ", ".join(args))) elif e.kind == C.E.CAST: # since a family of classes is merged, simply ignore the casting buf.write(curried(e.e)) elif e.kind == C.E.INS_OF: ty = typ_of_e(mtd, e.ty) cls = class_lookup(ty) if cls: buf.write(curried(e.e) + ".__cid == " + str(cls.id)) else: logging.debug("unknown type: {}".format(ty)) buf.write("0") else: buf.write(str(e)) return buf.getvalue()
def trans_e(mtd, e): curried = partial(trans_e, mtd) buf = cStringIO.StringIO() if e.kind == C.E.GEN: if e.es: buf.write("{| ") buf.write(" | ".join(map(curried, e.es))) buf.write(" |}") else: buf.write(C.T.HOLE) elif e.kind == C.E.ID: if hasattr(e, "ty"): buf.write(trans_ty(e.ty) + ' ') fld = None if mtd and e.id not in mtd.param_vars: fld = find_fld(mtd.clazz.name, e.id) if fld: # fname -> self.new_fname (unless the field is static) new_fname = trans_fname(fld.clazz.name, e.id, fld.is_static) if fld.is_static: # access to the static field inside the same class if fld.clazz.name == mtd.clazz.name: buf.write(e.id) # o.w., e.g., static constant in an interface, call the accessor else: buf.write(new_fname + "()") else: buf.write('.'.join([C.SK.self, new_fname])) elif e.id in [C.J.THIS, C.J.SUP]: buf.write(C.SK.self) elif util.is_str(e.id): # constant string, such as "Hello, World" str_init = trans_mname(C.J.STR, C.J.STR, [u"char[]", C.J.i, C.J.i]) s_hash = hash(e.id) % 256 # hash string value itself buf.write("{}(new Object(hash={}), {}, 0, {})".format(str_init, s_hash, e.id, len(e.id))) else: buf.write(e.id) elif e.kind == C.E.UOP: buf.write(' '.join([e.op, curried(e.e)])) elif e.kind == C.E.BOP: buf.write(' '.join([curried(e.le), e.op, curried(e.re)])) elif e.kind == C.E.DOT: # with package names, e.g., javax.swing.SwingUtilities if util.is_class_name(e.re.id) and class_lookup(e.re.id): buf.write(curried(e.re)) elif e.re.id == C.J.THIS: # ClassName.this buf.write(C.SK.self) else: rcv_ty = typ_of_e(mtd, e.le) fld = find_fld(rcv_ty, e.re.id) new_fname = trans_fname(rcv_ty, e.re.id, fld.is_static) if fld.is_static: # access to the static field inside the same class if mtd and rcv_ty == mtd.clazz.name: buf.write(e.re.id) # o.w., e.g., static constant in an interface, call the accessor else: buf.write(new_fname + "()") else: buf.write('.'.join([curried(e.le), new_fname])) elif e.kind == C.E.IDX: buf.write(curried(e.e) + '[' + curried(e.idx) + ']') elif e.kind == C.E.NEW: if e.e.kind == C.E.CALL: ty = typ_of_e(mtd, e.e.f) cls = class_lookup(ty) if cls and cls.has_init: arg_typs = map(partial(typ_of_e, mtd), e.e.a) mname = trans_mname(cls.name, cls.name, arg_typs) obj = "alloc@log({})".format(cls.id) args = [obj] + map(unicode, map(curried, e.e.a)) buf.write("{}({})".format(mname, ", ".join(args))) else: # collection or Object buf.write(C.J.NEW + ' ' + trans_ty(ty) + "()") else: # o.w., array initialization, e.g., new int[] { ... } buf.write(str(e.init)) elif e.kind == C.E.CALL: arg_typs = map(partial(typ_of_e, mtd), e.a) def trans_call(callee, rcv_ty, rcv): if callee.is_static: rcv = None args = util.rm_none([rcv] + map(curried, e.a)) mid = trans_mname(rcv_ty, callee.name, arg_typs) return u"{}({})".format(mid, ", ".join(args)) def dynamic_dispatch(rcv_ty, rcv, acc, callee): _dispatched = trans_call(callee, callee.clazz.name, rcv) _guarded = "{}.__cid == {} ? {}".format(rcv, callee.clazz.id, _dispatched) return "({} : {})".format(_guarded, acc) if e.f.kind == C.E.DOT: # rcv.mid rcv_ty = typ_of_e(mtd, e.f.le) rcv = curried(e.f.le) mname = e.f.re.id mtd_callees = find_mtds_by_sig(rcv_ty, mname, arg_typs) if mtd_callees and 1 < len(mtd_callees): # needs dynamic dispatch curried_dispatch = partial(dynamic_dispatch, rcv_ty, rcv) # TODO: use least upper bound? default_v = util.default_value(mtd_callees[0].typ) buf.write(reduce(curried_dispatch, mtd_callees, default_v)) elif mtd_callees and 1 == len(mtd_callees): mtd_callee = mtd_callees[0] buf.write(trans_call(mtd_callee, rcv_ty, rcv)) else: # unresolved, maybe library method mid = trans_mname(rcv_ty, mname, arg_typs) args = util.rm_none([rcv] + map(curried, e.a)) buf.write("{}({})".format(mid, ", ".join(args))) else: # mid mname = e.f.id # pre-defined meta information or Sketch primitive functions if mname in C.typ_arrays + [u"minimize"]: mid = mname rcv = None args = util.rm_none([rcv] + map(curried, e.a)) buf.write("{}({})".format(mid, ", ".join(args))) elif mname == C.J.SUP and mtd.is_init: # super(...) inside <init> sup = class_lookup(mtd.clazz.sup) mid = trans_mname(sup.name, sup.name, arg_typs) rcv = C.SK.self args = util.rm_none([rcv] + map(curried, e.a)) buf.write("{}({})".format(mid, ", ".join(args))) else: # member methods mtd_callees = find_mtds_by_sig(mtd.clazz.name, mname, arg_typs) if mtd_callees and 1 < len(mtd_callees): # needs dynamic dispatch curried_dispatch = partial(dynamic_dispatch, mtd.clazz.name, C.SK.self) # TODO: use least upper bound? default_v = util.default_value(mtd_callees[0].typ) buf.write(reduce(curried_dispatch, mtd_callees, default_v)) elif mtd_callees and 1 == len(mtd_callees): mtd_callee = mtd_callees[0] buf.write(trans_call(mtd_callee, mtd.clazz.name, C.SK.self)) else: # unresolved, maybe library method mid = trans_mname(mtd.clazz.name, mname, arg_typs) args = util.rm_none([rcv] + map(curried, e.a)) buf.write("{}({})".format(mid, ", ".join(args))) elif e.kind == C.E.CAST: # since a family of classes is merged, simply ignore the casting buf.write(curried(e.e)) elif e.kind == C.E.INS_OF: ty = typ_of_e(mtd, e.ty) cls = class_lookup(ty) if cls: buf.write(curried(e.e) + ".__cid == " + str(cls.id)) else: logging.debug("unknown type: {}".format(ty)) buf.write("0") else: buf.write(str(e)) return buf.getvalue()
def is_operator(Token): if util.is_str(Token): # if we got a string, then check in the Operators, else False return Token in Operators return False
def parse_filter_string(s, extra_converters={}): entries = s.split(entry_separator) output = {} # For each separate filter entry... for entry in entries: ksv = entry_kvseparator_re.split(entry, 1) key = ksv[0].strip() if key in _conversions: multiple = (_conversions[key]['max'] != 1) else: raise KeyError("Unexpected filter key provided: {0}".format(key)) ksvlist = ksv[2].strip().split(entry_subseparator) # Do we have sub-entries, or just a simple key=value ? value = {} # For each sub-entry... for e in ksvlist: eksv = [s.strip() for s in entry_kvseparator_re.split(e, 1)] # Is this sub-part a subkey=value? if len(eksv) > 1: if eksv[0] not in value: value[eksv[0]] = [] value[eksv[0]].append(Operator(value=eksv[2], op=eksv[1])) else: # If not, give it a position-based index if PosArgs not in value: value[PosArgs] = [] value[PosArgs].append(Operator(value=eksv[0], op=ksv[1])) # Set the value and move on if key not in output: output[key] = [] output[key].append(value) # For each result for k in output.keys(): # Do we know about it? if k in _conversions: if _conversions[k]['max'] not in [ None, 1 ] and len(output[k]) > _conversions[k]['max']: raise KeyError( "Filter key {} provided more than its maximum {} times". format(k, _conversions[k]['max'])) # Is it a complicated one, or a simple key=value? if isinstance(_conversions[k]['fn'], dict): # For each present subkey, check if we know about it outlist = output[k] # For each subkey... for outentry in outlist: # For each named entry in that subkey (and None for positional args)... for ek in outentry: # For each instance of that named entry... for i in range(0, len(outentry[ek])): ev = outentry[ek][i] # Check we have a valid conversion for the provided name conv = _get_valid_conversion( _conversions[k]['fn'], ek, i) if not conv: raise KeyError( "Unexpected filter subkey provided: {0}". format(ek)) # Check the provided operator is valid in this scenario if ev.operator not in _get_valid_ops(conv): raise KeyError( "Invalid operator provided for filter subkey '{}/{}'" .format(k, ek)) # Do the conversions specials = _conversions[k]['fn'][ek]['special'] if ( ek in _conversions[k]['fn'] and isinstance( _conversions[k]['fn'][ek], dict)) else [] ev.value, continue_conv = _global_conv( ev.value, specials) if continue_conv: if util.is_str(conv): if conv in extra_converters: ev.value = extra_converters[conv]( ev.value) else: raise ValueError( "Could not perform conversion for filter subkey '{}/{}' with custom converter '{}'" .format(k, ek, conv)) else: ev.value = conv(ev.value) else: # For each entry associated with this key... for ovl in output[k]: # For each entry in the positional args list... for ov in ovl[PosArgs]: # Check the provided operator is valid in this scenario if ov.operator not in _get_valid_ops( _conversions[k]['fn']): raise KeyError( "Invalid operator provided for filter key '{}'" .format(k)) # Do the conversions ov.value, continue_conv = _global_conv( ov.value, _conversions[k]['special']) if continue_conv: if util.is_str(_conversions[k]['fn']): if _conversions[k]['fn'] in extra_converters: ov.value = extra_converters[ _conversions[k]['fn']](ov.value) else: raise ValueError( "Could not perform conversion for special converter '{}'" .format(_conversions[k]['fn'])) else: ov.value = _conversions[k]['fn'](ov.value) else: raise KeyError("Unexpected filter key provided: {0}".format(k)) return output
def _c1_get_offset_from_name(input): frags = get_sector_fragments(input) if util.is_str(input) else input if frags is None: return None sufs = _get_suffixes(frags[0:-1], True) suf_len = len(sufs) # Add the total length of all the infixes we've already passed over if len(frags) > 3: # We have a 4-phoneme name, which means we have to handle adjusting our "coordinates" # from individual suffix runs up to fragment3 runs and then to fragment2 runs # STEP 1: Acquire the offset for suffix runs, and adjust it suf_offset = sufs.index(frags[-1]) # Check which fragment3 run we're on, and jump us up by that many total run lengths if not the first suf_offset += (sufs.index(frags[-1]) // _c1_get_infix_run_length( frags[2])) * _c1_get_infix_total_run_length(frags[2]) # STEP 2: Take our current offset from "suffix space" to "fragment3 space" # Divide by the current fragment3's run length # Remember the offset that we're at on the current suffix-run f3_offset, f3_offset_mod = divmod(suf_offset, _c1_get_infix_run_length(frags[2])) # Multiply by the total run length for this series of fragment3s f3_offset *= _c1_get_infix_total_run_length(frags[2]) # Reapply the f3 offset from earlier f3_offset += f3_offset_mod # Add the offset of the current fragment3, to give us our overall position in the f3-sequence f3_offset += _c1_infix_offsets[frags[2]][0] # STEP 3: Take our current offset from "fragment3 space" to "fragment2 space" # Divide by the current fragment2's run length # Remember the offset that we're at on the current f3-run f2_offset, f2_offset_mod = divmod(f3_offset, _c1_get_infix_run_length(frags[1])) # Multiply by the total run length for this series of fragment2s f2_offset *= _c1_get_infix_total_run_length(frags[1]) # Reapply the f2 offset from earlier f2_offset += f2_offset_mod # Add the offset of the current fragment2, to give us our overall position in the f2-sequence f2_offset += _c1_infix_offsets[frags[1]][0] # Set this as the global offset to be manipulated by the prefix step offset = f2_offset else: # We have a 3-phoneme name, which means we just have to adjust our coordinates # from "suffix space" to "fragment2 space" (since there is no fragment3) # STEP 1: Acquire the offset for suffix runs, and adjust it suf_offset = sufs.index(frags[-1]) # STEP 2: Take our current offset from "suffix space" to "fragment2 space" # Divide by the current fragment2's run length # Remember the offset we're at on the current suffix-run f2_offset, f2_offset_mod = divmod(suf_offset, _c1_get_infix_run_length(frags[1])) # Multiply by the total run length for this series of fragment2s f2_offset *= _c1_get_infix_total_run_length(frags[1]) # Reapply the f2 offset from earlier f2_offset += f2_offset_mod # Add the offset of the current fragment2, to give us our overall position in the f2-sequence f2_offset += _c1_infix_offsets[frags[1]][0] # Set this as the global offset to be manipulated by the prefix step offset = f2_offset # Divide by the current prefix's run length, this is now how many iterations of the full 3037 we should have passed over # Also remember the current offset's position within a prefix run offset, offset_mod = divmod(offset, _get_prefix_run_length(frags[0])) # Now multiply by the total run length (3037) to get the actual offset of this run offset *= pgdata.cx_prefix_total_run_length # Add the infixes/suffix's position within this prefix's part of the overall prefix run offset += offset_mod # Add the base position of this prefix within the run offset += _prefix_offsets[frags[0]][0] # Whew! return offset