def reraise_dbapi_error(): exc_info = sys.exc_info() import jpype if isinstance(exc_info[1], jpype._jexception.JavaException): if issubclass(exc_info[1].__javaclass__, jpype.java.sql.SQLException): exc_type = DatabaseError else: exc_type = Error else: exc_type = exc_info[0] reraise(exc_type, exc_info[1], exc_info[2])
def fuzzy_search(self, value, threshold=80, scorer=None): try: with warnings.catch_warnings(): warnings.simplefilter("ignore") from fuzzywuzzy import process from fuzzywuzzy import fuzz except ImportError: reraise(ImportError, "fuzzy search requires 'fuzzywuzzy'"\ " (https://github.com/seatgeek/fuzzywuzzy)") if scorer is None: scorer = fuzz.QRatio match = process.extractOne(value, self.targets, scorer=scorer, score_cutoff=threshold) if match is None: raise IndexError("'%s' not found" % value) LOGGER.debug("'%s' matches '%s' (%d%%)", value, match[0], match[1]) return (self.binary_search(match[0]), match[0], match[1])
def reraise_dbapi_error(): exc_info = sys.exc_info() import jpype value = exc_info[1] if isinstance(exc_info[1], jpype._jexception.JavaException): if issubclass(exc_info[1].__javaclass__, jpype.java.sql.SQLException): args = exc_info[1].args if args: cause = args[0].cause if cause: value = cause.getMessage() else: value = args[0].getMessage() tp = DatabaseError else: tp = Error else: tp = exc_info[0] reraise(tp, value, exc_info[2])
def _drive_request( self, method="get", file_id=None, params=None, data=None, headers=None ): url = "https://www.googleapis.com/drive/v3/files" if file_id: url += "/{}".format(file_id) try: res = self.request(method, url, params=params, json=data) if res.text: return res.json() except APIError as e: if "scopes" in e.response.text: print( "Your credentials don't have Drive API access, ignoring " "drive specific functionality (Note this includes searching " "spreadsheets by name)" ) return {} else: reraise(e)
def modeller(*args, **kwargs): """Create coarse-grain model from universe selection. Parameters ---------- args kwargs Returns ------- A coarse-grain model """ models = kwargs.pop("model", [ "ncsc", ]) models = [_.upper() for _ in models] try: if "ENM" in models: logger.warning( "ENM model detected. All other models are being ignored.") universe = _MODELS["ENM"](*args, **kwargs) return universe except Exception as e: logger.exception( "An error occurred while trying to create the universe.") reraise(e) try: # remove rmax and rmin as it is used only in ENM kwargs.pop("rmin") kwargs.pop("rmax") universe = [_MODELS[model](*args, **kwargs) for model in models] except KeyError: msg = ("{0} is not an available model. " "Please try {1}".format(models, viewkeys(_MODELS))) logger.exception(msg) raise_with_traceback(KeyError(msg)) else: universe = Merge(*universe) if len(universe) > 1 else universe[0] return universe
def get_creds(user="******", config=None, scope=default_scope, creds_dir=None, save=True): """Get google google.auth.credentials.Credentials for the given user. If the user doesn't have previous creds, they will go through the OAuth flow to get new credentials which will be saved for later use. Credentials will be saved in config['creds_dir'], if this value is not set, then they will be stored in a folder named ``creds`` in the default config dir (either ~/.config/gspread_pandas or $GSPREAD_PANDAS_CONFIG_DIR) Alternatively, it will get credentials from a service account. Parameters ---------- user : str Unique key indicating user's credentials. This is not necessary when using a ServiceAccount and will be ignored (Default value = "default") config : dict Optional, dict with "client_id", "client_secret", and "redirect_uris" keys for OAuth or "type", "client_email", "private_key", "private_key_id", and "client_id" for a Service Account. If None is passed, it will call :meth:`get_config() <get_config>` (Default value = None) creds_dir : str Optional, directory to load and store creds from/in. If None, it will use the ``creds`` subdirectory in the default config location. (Default value = None) scope : list Optional, scope to use for Google Auth (Default value = default_scope) Returns ------- google.auth.credentials.Credentials Google credentials that can be used with gspread """ config = config or get_config() try: if "private_key_id" in config: return SACredentials.from_service_account_info(config, scopes=scope) if not isinstance(user, basestring): raise ConfigException( "Need to provide a user key as a string if not using a service account" ) if creds_dir is None: creds_dir = get_config_dir() / "creds" creds_file = creds_dir / user if Path(creds_file).exists(): # need to convert Path to string for python 2.7 return OAuthCredentials.from_authorized_user_file(str(creds_file)) flow = InstalledAppFlow.from_client_config( config, scope, redirect_uri="urn:ietf:wg:oauth:2.0:oob") creds = flow.run_console() if save: creds_data = { "refresh_token": creds.refresh_token, "token_uri": creds.token_uri, "client_id": creds.client_id, "client_secret": creds.client_secret, "scopes": creds.scopes, } ensure_path(creds_dir) creds_file.write_text(decode(json.dumps(creds_data))) return creds except Exception: exc_info = sys.exc_info() if "exc_info" in locals(): reraise(ConfigException, *exc_info[1:])
def save(slotname, extra_info='', mutate_flag=False): """ :doc: loadsave :args: (filename, extra_info='') Saves the game state to a save slot. `filename` A string giving the name of a save slot. Despite the variable name, this corresponds only loosely to filenames. `extra_info` An additional string that should be saved to the save file. Usually, this is the value of :var:`save_name`. :func:`renpy.take_screenshot` should be called before this function. """ if mutate_flag: renpy.python.mutate_flag = False roots = renpy.game.log.freeze(None) if renpy.config.save_dump: save_dump(roots, renpy.game.log) logf = io.BytesIO() try: dump((roots, renpy.game.log), logf) except: t, e, tb = sys.exc_info() if mutate_flag: reraise(t, e, tb) try: bad = find_bad_reduction(roots, renpy.game.log) except: reraise(t, e, tb) if bad is None: reraise(t, e, tb) e.args = (e.args[0] + ' (perhaps {})'.format(bad), ) + e.args[1:] reraise(t, e, tb) if mutate_flag and renpy.python.mutate_flag: raise SaveAbort() screenshot = renpy.game.interface.get_screenshot() json = { "_save_name": extra_info, "_renpy_version": list(renpy.version_tuple), "_version": renpy.config.version } for i in renpy.config.save_json_callbacks: i(json) json = json_dumps(json) sr = SaveRecord(screenshot, extra_info, json, logf.getvalue()) location.save(slotname, sr) location.scan() clear_slot(slotname)
def run(self, node=None): """ Executes as many nodes as possible in the current context. If the node argument is given, starts executing from that node. Otherwise, looks up the node given in self.current, and executes from there. """ self.exception_handler = None self.abnormal = True if node is None: node = renpy.game.script.lookup(self.current) developer = renpy.config.developer tracing = sys.gettrace() is not None # Is this the first time through the loop? first = True while node: if node.name == self.come_from_name: self.come_from_name = None node = self.call(self.come_from_label, return_site=node.name) self.make_dynamic([ "_return", "_begin_rollback" ]) renpy.store._begin_rollback = False this_node = node type_node_name = type(node).__name__ renpy.plog(1, "--- start {} ({}:{})", type_node_name, node.filename, node.linenumber) self.current = node.name self.last_abnormal = self.abnormal self.abnormal = False self.defer_rollback = None if renpy.config.line_log: ll_entry = LineLogEntry(node.filename, node.linenumber, node, self.last_abnormal) if ll_entry not in self.line_log: self.line_log.append(ll_entry) if not renpy.store._begin_rollback: update_rollback = False force_rollback = False elif first or self.force_checkpoint or (node.rollback == "force"): update_rollback = True force_rollback = True elif not renpy.config.all_nodes_rollback and (node.rollback == "never"): update_rollback = False force_rollback = False else: update_rollback = True force_rollback = False # Force a new rollback to start to match things in the forward log. if renpy.game.log.forward and renpy.game.log.forward[0][0] == node.name: update_rollback = True force_rollback = True first = False if update_rollback: if self.rollback and renpy.game.log: renpy.game.log.begin(force=force_rollback) if self.rollback and self.force_checkpoint: renpy.game.log.force_checkpoint = True self.force_checkpoint = False self.seen = False renpy.test.testexecution.take_name(self.current) try: try: check_infinite_loop() if tracing: self.report_coverage(node) renpy.game.exception_info = "While running game code:" self.next_node = None renpy.plog(2, " before execute {} ({}:{})", type_node_name, node.filename, node.linenumber) node.execute() renpy.plog(2, " after execute {} ({}:{})", type_node_name, node.filename, node.linenumber) if developer and self.next_node: self.check_stacks() except renpy.game.CONTROL_EXCEPTIONS as e: # An exception ends the current translation. self.translate_interaction = None raise except Exception as e: self.translate_interaction = None exc_info = sys.exc_info() short, full, traceback_fn = renpy.error.report_exception(e, editor=False) try: handled = False if self.exception_handler is not None: self.exception_handler(short, full, traceback_fn) handled = True elif renpy.config.exception_handler is not None: handled = renpy.config.exception_handler(short, full, traceback_fn) if not handled: if renpy.display.error.report_exception(short, full, traceback_fn): raise except renpy.game.CONTROL_EXCEPTIONS as ce: raise ce except Exception as ce: reraise(exc_info[0], exc_info[1], exc_info[2]) node = self.next_node except renpy.game.JumpException as e: node = renpy.game.script.lookup(e.args[0]) self.abnormal = True except renpy.game.CallException as e: if e.from_current: return_site = getattr(node, "statement_start", node).name else: if self.next_node is None: raise Exception("renpy.call can't be used when the next node is undefined.") return_site = self.next_node.name node = self.call(e.label, return_site=return_site) self.abnormal = True renpy.store._args = e.args renpy.store._kwargs = e.kwargs if self.seen: renpy.game.persistent._seen_ever[self.current] = True # @UndefinedVariable renpy.game.seen_session[self.current] = True renpy.plog(2, " end {} ({}:{})", type_node_name, this_node.filename, this_node.linenumber) if self.rollback and renpy.game.log: renpy.game.log.complete()