def pg_type_info(typ): value = None if isinstance(typ, dict): value = typ["value"] typ = typ["type"] data = py_types.get(typ) if data == None: raise NotSupportedError("type %r not mapped to pg type" % typ) # permit the type data to be determined by the value, if provided inspect_func = data.get("inspect") if value != None and inspect_func != None: data = inspect_func(value) type_oid = data.get("typeoid") if type_oid == None: raise InternalError("type %r has no type_oid" % typ) elif type_oid == -1: # special case: NULL values return type_oid, 0 # prefer bin, but go with whatever exists if data.get("bin_out"): format = 1 elif data.get("txt_out"): format = 0 else: raise InternalError("no conversion fuction for type %r" % typ) return type_oid, format
def __init__(self, y=0, x=0): if not isinstance(y, int) or not isinstance(x, int): raise InternalError("Point expected two integers (y,x)") self.y = y self.x = x self.normalise()
def __init__(self, where=None, color=curses.A_REVERSE): if not isinstance(where, Rect): raise InternalError('Expected \'where\' to be a Rect') self.where = where self.color = color
def moveto(where=Point(0, 0)): if not isinstance(where, Point): raise InternalError('Expected \'where\' to be a Point') if where: self.where.move(where)
def unwrap(self, depth=1): if isinstance(self.inner, TypePointer): return self.inner.unwrap(depth + 1) elif isinstance(self.inner, TypePrim): return f'{self.inner.kind}{depth * "$"}' else: raise InternalError('pointer to something other than primary type')
def pg_value(value, fc, **kwargs): typ = type(value) data = py_types.get(typ) if data == None: raise NotSupportedError("type %r not mapped to pg type" % typ) # permit the type conversion to be determined by the value, if provided inspect_func = data.get("inspect") if value != None and inspect_func != None: data = inspect_func(value) # special case: NULL values if data.get("typeoid") == -1: return None if fc == 0: func = data.get("txt_out") elif fc == 1: func = data.get("bin_out") else: raise InternalError("unrecognized format code %r" % fc) if func == None: raise NotSupportedError("type %r, format code %r not supported" % (typ, fc)) return func(value, **kwargs)
class Executioner(Backend): def create_context(self, ccache=None, client_ip=None): """ client_ip: The IP address of the remote client. """ if ccache is not None: os.environ["KRB5CCNAME"] = ccache if self.env.in_server: self.Backend.ldap2.connect(ccache=ccache) else: self.Backend.rpcclient.connect(verbose=self.env.verbose, fallback=self.env.fallback, delegate=self.env.delegate) if client_ip is not None: setattr(context, "client_ip", client_ip) def destroy_context(self): destroy_context() def execute(self, _name, *args, **options): error = None try: if _name not in self.Command: raise CommandError(name=_name) result = self.Command[_name](*args, **options) except PublicError, e: error = e except StandardError, e: self.exception( 'non-public: %s: %s', e.__class__.__name__, str(e) ) error = InternalError()
def wrapped(*args, **kwargs): try: resp = viewfunc(*args, **kwargs) return resp except Error as e: return e.resp except Exception: traceback.print_exc() return InternalError().resp
def add_children(self, *children): for child in children: if not child: pass # ignore elif type(child) == list: for ch in child: self.add_children(ch) elif isinstance(child, Node): child.parent = self else: raise InternalError('bad child')
def timeout(self, milliseconds): scr = self.screen if type(milliseconds) != int: raise InternalError('timeout expected integer milliseconds') self.timeout = milliseconds if not debug and scr: scr.timeout(milliseconds)
def print(self, title, obj): if isinstance(obj, Node): self.print_node(title, obj) elif isinstance(obj, list): self.print_array(title, obj) elif isinstance(obj, Token): self.print_token(title, obj) elif not obj: self.print_single(title, 'NULL') else: raise InternalError(f'bad argument {obj.__class__.__name__}')
def check_types(self): if self.lit.type == 'LIT_INT': return TYPE_INT elif self.lit.type == 'LIT_FLOAT': return TYPE_FLOAT elif self.lit.type in ['KW_TRUE', 'KW_FALSE']: return TYPE_BOOL elif self.lit.type == 'LIT_CHAR': return TYPE_CHAR elif self.lit.type == 'LIT_STR': return TYPE_STRING else: raise InternalError('Bad ExprLit token')
def py_type_info(description): type_oid = description['type_oid'] data = pg_types.get(type_oid) if data == None: raise NotSupportedError("type oid %r not mapped to py type" % type_oid) # prefer bin, but go with whatever exists if data.get("bin_in"): format = 1 elif data.get("txt_in"): format = 0 else: raise InternalError("no conversion fuction for type oid %r" % type_oid) return format
def wrapped(*args, **kwargs): try: resp = viewfunc(*args, **kwargs) if not resp: return '' elif isinstance(resp, dict): return json.dumps(resp) else: return resp except Error as e: return e.resp except Exception: traceback.print_exc() return InternalError().resp
def unify(type_0, type_1): # def unify_types(type_0, type_1, token=None): # todo error? if not type_0 or not type_1: return 0 elif type_0.__class__ != type_1.__class__: return 1 # cia jau zinome kad klases sutampa (TypePrim?) elif isinstance(type_0, TypePointer) and isinstance(type_1, TypePointer): return unify(type_0.inner, type_1.inner) elif isinstance(type_0, TypePrim) and isinstance(type_1, TypePrim): if type_0.kind != type_1.kind: return 2 else: return 0 else: raise InternalError('unreachable')
def do_register(username, password): validate_username(username) validate_password(password) if dbutil.get_user(username): raise Error('user already exists') salt = generate_salt() hashed_password = hash_password(password, salt) user = { 'username': username, 'ctime': utc_now_as_str(), 'salt': salt, 'hashed_password': hashed_password, } if not dbutil.create_user(user): raise InternalError() return token_response(dbutil.get_user_for_token(username))
def check_types(self): target_type = None # todo jei exprunary nebutinai targetnode type if self.target_node: target_type = self.lhs.check_types() # target_type = @target.type # print(target_type.inner.kind) value_type = self.value.check_types( ) # jis visada kazkoks bus, nereik tikrint kasd jis su void bus # todo return? # target_node jau prisyreme vardu rez metu # unifyt_types(@target_node&.type, value_type) # cia jei target_type nera, tai nil paduoti, ir viduj jau error gausim if target_type: if self.op != "EQUALS" and not target_type.is_arithmetic(): semantic_error3( f'cannot perform arithmetic assign operation with this type: {target_type.kind}', self.lhs.name) unify_types(target_type, value_type, self.value.get_token()) else: raise InternalError("no target type")
# # __main__ # #--- if __name__ == '__main__': if 1: if len(sys.argv) == 2: tinfo = terminfo(sys.argv[1]) elif len(sys.argv) == 1: tinfo = terminfo() else: print( InternalError("Expected only 1 argument, got %d" % (len(sys.argv) - 1))) sys.exit(1) # Display tinfo... print('\n\nterminfo for %s...' % tinfo['termname']) keys = list(tinfo.keys()) keys.sort() maxkey = 0 for key in keys: maxkey = max(maxkey, len(key)) for key in keys: val = tinfo[key] vallen = 0 if type(val) != str else len(val) print(' %s:%s (%d) = %s' %
def terminfo(termname=os.environ['TERM']): lines = os.popen('infocmp -1 -E %s' % repr(termname)).read().split('\n') if 'infocmp: ' in lines[0]: raise InternalError(lines[0]) # Strip leading and trailing spaces from lines... for lineno in range(0, len(lines)): line = lines[lineno].strip() if line.endswith(','): line = line[:-1] lines[lineno] = line tinfo = {} c_name = '' for lineno in range(0, len(lines)): line = lines[lineno] # Handle ..._alias_data if '_alias_data[]' in line: lookfor = 'static char ' pos1 = line.find(lookfor) + len(lookfor) pos2 = line.find('_alias_data') c_name = line[pos1:pos2] pos1 = line.find('[] = "') + 6 pos2 = line.find('";') alias_data = line[pos1:pos2] tinfo['alias_data'] = alias_data tinfo['termname'] = termname tinfo['c_name'] = c_name continue if not c_name: continue # Handle escape formats... lookfor = 'static char ' + c_name + '_s_' pos1 = line.find(lookfor) if pos1 >= 0: line = line[pos1 + len(lookfor):] pos2 = line.find('[] =') key = line[:pos2] pos3 = pos2 + 5 pos4 = line.find('";') evalstr = line[pos3:pos4 + 1] val = eval(evalstr) tinfo[key] = val continue # Handle boolean and numeric values... if '/*' in line and '*/' in line: pos1 = line.find(': ') + 2 pos2 = line[pos1:].find(' ') + pos1 key = line[pos1:pos2] pos1 = line.find('*/') + 2 line = line[pos1:] pos2 = line.find(',') + pos1 val = line[:pos2] while val and val[0] in ' \t': val = val[1:] if val == 'ABSENT_NUMERIC': continue elif val == 'FALSE': val = False elif val == 'TRUE': val = True elif isInt(val): val = int(val) else: raise InternalError('Unexpected format at line %d: %s' % (lineno + 1, repr(line))) tinfo[key] = val continue # Finished if we've got to the pointers... if 'static char * ' in line: break return DotDict(tinfo)
def resolve_names(self, scope): # raise NotImplementedError.new raise InternalError( f'resolve names not implemented for: {self.__class__.__name__}')
def check_types(self): # raise NotImplementedError raise InternalError( f'check_types not implemented for {self.__class__}')
textui, console, help, show_mappings, ) def run(api): error = None try: (options, argv) = api.bootstrap_with_global_options(context='cli') for klass in cli_plugins: api.register(klass) api.load_plugins() api.finalize() if not 'config_loaded' in api.env: raise NotConfiguredError() sys.exit(api.Backend.cli.run(argv)) except KeyboardInterrupt: print '' api.log.info('operation aborted') except PublicError, e: error = e except StandardError, e: api.log.exception('%s: %s', e.__class__.__name__, str(e)) error = InternalError() if error is not None: assert isinstance(error, PublicError) api.log.error(error.strerror) sys.exit(error.rval)