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