_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q261800 | extract_names | validation | def extract_names(source):
"""Extract names from a function definition
Looks for a function definition in the source.
Only the first function definition is examined.
Returns:
a list names(identifiers) used in the body of the function
excluding function parameters.
"""
if source is None:
return None
source = dedent(source)
funcdef = find_funcdef(source)
params = extract_params(source)
names = []
if isinstance(funcdef, ast.FunctionDef):
stmts = funcdef.body
elif isinstance(funcdef, ast.Lambda):
stmts = [funcdef.body]
else:
raise ValueError("must not happen")
for stmt in stmts:
for node in ast.walk(stmt):
if isinstance(node, ast.Name):
if node.id not in names and node.id not in params:
names.append(node.id)
return names | python | {
"resource": ""
} |
q261801 | is_funcdef | validation | def is_funcdef(src):
"""True if src is a function definition"""
module_node = ast.parse(dedent(src))
if len(module_node.body) == 1 and isinstance(
module_node.body[0], ast.FunctionDef
):
return True
else:
return False | python | {
"resource": ""
} |
q261802 | remove_decorator | validation | def remove_decorator(source: str):
"""Remove decorators from function definition"""
lines = source.splitlines()
atok = asttokens.ASTTokens(source, parse=True)
for node in ast.walk(atok.tree):
if isinstance(node, ast.FunctionDef):
break
if node.decorator_list:
deco_first = node.decorator_list[0]
deco_last = node.decorator_list[-1]
line_first = atok.tokens[deco_first.first_token.index - 1].start[0]
line_last = atok.tokens[deco_last.last_token.index + 1].start[0]
lines = lines[:line_first - 1] + lines[line_last:]
return "\n".join(lines) + "\n" | python | {
"resource": ""
} |
q261803 | replace_funcname | validation | def replace_funcname(source: str, name: str):
"""Replace function name"""
lines = source.splitlines()
atok = asttokens.ASTTokens(source, parse=True)
for node in ast.walk(atok.tree):
if isinstance(node, ast.FunctionDef):
break
i = node.first_token.index
for i in range(node.first_token.index, node.last_token.index):
if (atok.tokens[i].type == token.NAME
and atok.tokens[i].string == "def"):
break
lineno, col_begin = atok.tokens[i + 1].start
lineno_end, col_end = atok.tokens[i + 1].end
assert lineno == lineno_end
lines[lineno-1] = (
lines[lineno-1][:col_begin] + name + lines[lineno-1][col_end:]
)
return "\n".join(lines) + "\n" | python | {
"resource": ""
} |
q261804 | has_lambda | validation | def has_lambda(src):
"""True if only one lambda expression is included"""
module_node = ast.parse(dedent(src))
lambdaexp = [node for node in ast.walk(module_node)
if isinstance(node, ast.Lambda)]
return bool(lambdaexp) | python | {
"resource": ""
} |
q261805 | Formula._reload | validation | def _reload(self, module=None):
"""Reload the source function from the source module.
**Internal use only**
Update the source function of the formula.
This method is used to updated the underlying formula
when the source code of the module in which the source function
is read from is modified.
If the formula was not created from a module, an error is raised.
If ``module_`` is not given, the source module of the formula is
reloaded. If ``module_`` is given and matches the source module,
then the module_ is used without being reloaded.
If ``module_`` is given and does not match the source module of
the formula, an error is raised.
Args:
module_: A ``ModuleSource`` object
Returns:
self
"""
if self.module is None:
raise RuntimeError
elif module is None:
import importlib
module = ModuleSource(importlib.reload(module))
elif module.name != self.module:
raise RuntimeError
if self.name in module.funcs:
func = module.funcs[self.name]
self.__init__(func=func)
else:
self.__init__(func=NULL_FORMULA)
return self | python | {
"resource": ""
} |
q261806 | get_description | validation | def get_description():
"""Get long description from README."""
with open(path.join(here, 'README.rst'), 'r') as f:
data = f.read()
return data | python | {
"resource": ""
} |
q261807 | CellsView.to_frame | validation | def to_frame(self, *args):
"""Convert the cells in the view into a DataFrame object.
If ``args`` is not given, this method returns a DataFrame that
has an Index or a MultiIndex depending of the number of
cells parameters and columns each of which corresponds to each
cells included in the view.
``args`` can be given to calculate cells values and limit the
DataFrame indexes to the given arguments.
The cells in this view may have different number of parameters,
but parameters shared among multiple cells
must appear in the same position in all the parameter lists.
For example,
Having ``foo()``, ``bar(x)`` and ``baz(x, y=1)`` is okay
because the shared parameter ``x`` is always the first parameter,
but this method does not work if the view has ``quz(x, z=2, y=1)``
cells in addition to the first three cells, because ``y`` appears
in different positions.
Args:
args(optional): multiple arguments,
or an iterator of arguments to the cells.
"""
if sys.version_info < (3, 6, 0):
from collections import OrderedDict
impls = OrderedDict()
for name, obj in self.items():
impls[name] = obj._impl
else:
impls = get_impls(self)
return _to_frame_inner(impls, args) | python | {
"resource": ""
} |
q261808 | StaticSpace.new_cells | validation | def new_cells(self, name=None, formula=None):
"""Create a cells in the space.
Args:
name: If omitted, the model is named automatically ``CellsN``,
where ``N`` is an available number.
func: The function to define the formula of the cells.
Returns:
The new cells.
"""
# Outside formulas only
return self._impl.new_cells(name, formula).interface | python | {
"resource": ""
} |
q261809 | StaticSpace.import_funcs | validation | def import_funcs(self, module):
"""Create a cells from a module."""
# Outside formulas only
newcells = self._impl.new_cells_from_module(module)
return get_interfaces(newcells) | python | {
"resource": ""
} |
q261810 | BaseSpaceImpl.get_object | validation | def get_object(self, name):
"""Retrieve an object by a dotted name relative to the space."""
parts = name.split(".")
child = parts.pop(0)
if parts:
return self.spaces[child].get_object(".".join(parts))
else:
return self._namespace_impl[child] | python | {
"resource": ""
} |
q261811 | BaseSpaceImpl._get_dynamic_base | validation | def _get_dynamic_base(self, bases_):
"""Create or get the base space from a list of spaces
if a direct base space in `bases` is dynamic, replace it with
its base.
"""
bases = tuple(
base.bases[0] if base.is_dynamic() else base for base in bases_
)
if len(bases) == 1:
return bases[0]
elif len(bases) > 1:
return self.model.get_dynamic_base(bases)
else:
RuntimeError("must not happen") | python | {
"resource": ""
} |
q261812 | BaseSpaceImpl._new_dynspace | validation | def _new_dynspace(
self,
name=None,
bases=None,
formula=None,
refs=None,
arguments=None,
source=None,
):
"""Create a new dynamic root space."""
if name is None:
name = self.spacenamer.get_next(self.namespace)
if name in self.namespace:
raise ValueError("Name '%s' already exists." % name)
if not is_valid_name(name):
raise ValueError("Invalid name '%s'." % name)
space = RootDynamicSpaceImpl(
parent=self,
name=name,
formula=formula,
refs=refs,
source=source,
arguments=arguments,
)
space.is_derived = False
self._set_space(space)
if bases: # i.e. not []
dynbase = self._get_dynamic_base(bases)
space._dynbase = dynbase
dynbase._dynamic_subs.append(space)
return space | python | {
"resource": ""
} |
q261813 | BaseSpaceImpl.get_dynspace | validation | def get_dynspace(self, args, kwargs=None):
"""Create a dynamic root space
Called from interface methods
"""
node = get_node(self, *convert_args(args, kwargs))
key = node[KEY]
if key in self.param_spaces:
return self.param_spaces[key]
else:
last_self = self.system.self
self.system.self = self
try:
space_args = self.eval_formula(node)
finally:
self.system.self = last_self
if space_args is None:
space_args = {"bases": [self]} # Default
else:
if "bases" in space_args:
bases = get_impls(space_args["bases"])
if isinstance(bases, StaticSpaceImpl):
space_args["bases"] = [bases]
elif bases is None:
space_args["bases"] = [self] # Default
else:
space_args["bases"] = bases
else:
space_args["bases"] = [self]
space_args["arguments"] = node_get_args(node)
space = self._new_dynspace(**space_args)
self.param_spaces[key] = space
space.inherit(clear_value=False)
return space | python | {
"resource": ""
} |
q261814 | StaticSpaceImpl.set_attr | validation | def set_attr(self, name, value):
"""Implementation of attribute setting
``space.name = value`` by user script
Called from ``Space.__setattr__``
"""
if not is_valid_name(name):
raise ValueError("Invalid name '%s'" % name)
if name in self.namespace:
if name in self.refs:
if name in self.self_refs:
self.new_ref(name, value)
else:
raise KeyError("Ref '%s' cannot be changed" % name)
elif name in self.cells:
if self.cells[name].is_scalar():
self.cells[name].set_value((), value)
else:
raise AttributeError("Cells '%s' is not a scalar." % name)
else:
raise ValueError
else:
self.new_ref(name, value) | python | {
"resource": ""
} |
q261815 | StaticSpaceImpl.del_attr | validation | def del_attr(self, name):
"""Implementation of attribute deletion
``del space.name`` by user script
Called from ``StaticSpace.__delattr__``
"""
if name in self.namespace:
if name in self.cells:
self.del_cells(name)
elif name in self.spaces:
self.del_space(name)
elif name in self.refs:
self.del_ref(name)
else:
raise RuntimeError("Must not happen")
else:
raise KeyError("'%s' not found in Space '%s'" % (name, self.name)) | python | {
"resource": ""
} |
q261816 | StaticSpaceImpl.del_space | validation | def del_space(self, name):
"""Delete a space."""
if name not in self.spaces:
raise ValueError("Space '%s' does not exist" % name)
if name in self.static_spaces:
space = self.static_spaces[name]
if space.is_derived:
raise ValueError(
"%s has derived spaces" % repr(space.interface)
)
else:
self.static_spaces.del_item(name)
self.model.spacegraph.remove_node(space)
self.inherit()
self.model.spacegraph.update_subspaces(self)
# TODO: Destroy space
elif name in self.dynamic_spaces:
# TODO: Destroy space
self.dynamic_spaces.del_item(name)
else:
raise ValueError("Derived cells cannot be deleted") | python | {
"resource": ""
} |
q261817 | StaticSpaceImpl.del_cells | validation | def del_cells(self, name):
"""Implementation of cells deletion
``del space.name`` where name is a cells, or
``del space.cells['name']``
"""
if name in self.cells:
cells = self.cells[name]
self.cells.del_item(name)
self.inherit()
self.model.spacegraph.update_subspaces(self)
elif name in self.dynamic_spaces:
cells = self.dynamic_spaces.pop(name)
self.dynamic_spaces.set_update()
else:
raise KeyError("Cells '%s' does not exist" % name)
NullImpl(cells) | python | {
"resource": ""
} |
q261818 | cellsiter_to_dataframe | validation | def cellsiter_to_dataframe(cellsiter, args, drop_allna=True):
"""Convert multiple cells to a frame.
If args is an empty sequence, all values are included.
If args is specified, cellsiter must have shareable parameters.
Args:
cellsiter: A mapping from cells names to CellsImpl objects.
args: A sequence of arguments
"""
from modelx.core.cells import shareable_parameters
if len(args):
indexes = shareable_parameters(cellsiter)
else:
indexes = get_all_params(cellsiter.values())
result = None
for cells in cellsiter.values():
df = cells_to_dataframe(cells, args)
if drop_allna and df.isnull().all().all():
continue # Ignore all NA or empty
if df.index.names != [None]:
if isinstance(df.index, pd.MultiIndex):
if _pd_ver < (0, 20):
df = _reset_naindex(df)
df = df.reset_index()
missing_params = set(indexes) - set(df)
for params in missing_params:
df[params] = np.nan
if result is None:
result = df
else:
try:
result = pd.merge(result, df, how="outer")
except MergeError:
# When no common column exists, i.e. all cells are scalars.
result = pd.concat([result, df], axis=1)
except ValueError:
# When common columns are not coercible (numeric vs object),
# Make the numeric column object type
cols = set(result.columns) & set(df.columns)
for col in cols:
# When only either of them has object dtype
if (
len(
[
str(frame[col].dtype)
for frame in (result, df)
if str(frame[col].dtype) == "object"
]
)
== 1
):
if str(result[col].dtype) == "object":
frame = df
else:
frame = result
frame[[col]] = frame[col].astype("object")
# Try again
result = pd.merge(result, df, how="outer")
if result is None:
return pd.DataFrame()
else:
return result.set_index(indexes) if indexes else result | python | {
"resource": ""
} |
q261819 | cells_to_series | validation | def cells_to_series(cells, args):
"""Convert a CellImpl into a Series.
`args` must be a sequence of argkeys.
`args` can be longer or shorter then the number of cell's parameters.
If shorter, then defaults are filled if any, else raise error.
If longer, then redundant args are ignored.
"""
paramlen = len(cells.formula.parameters)
is_multidx = paramlen > 1
if len(cells.data) == 0:
data = {}
indexes = None
elif paramlen == 0: # Const Cells
data = list(cells.data.values())
indexes = [np.nan]
else:
if len(args) > 0:
defaults = tuple(
param.default
for param in cells.formula.signature.parameters.values()
)
updated_args = []
for arg in args:
if len(arg) > paramlen:
arg = arg[:paramlen]
elif len(arg) < paramlen:
arg += defaults[len(arg) :]
updated_args.append(arg)
items = [
(arg, cells.data[arg])
for arg in updated_args
if arg in cells.data
]
else:
items = [(key, value) for key, value in cells.data.items()]
if not is_multidx: # Peel 1-element tuple
items = [(key[0], value) for key, value in items]
if len(items) == 0:
indexes, data = None, {}
else:
indexes, data = zip(*items)
if is_multidx:
indexes = pd.MultiIndex.from_tuples(indexes)
result = pd.Series(data=data, name=cells.name, index=indexes)
if indexes is not None and any(i is not np.nan for i in indexes):
result.index.names = list(cells.formula.parameters)
return result | python | {
"resource": ""
} |
q261820 | DependencyGraph.clear_obj | validation | def clear_obj(self, obj):
""""Remove all nodes with `obj` and their descendants."""
obj_nodes = self.get_nodes_with(obj)
removed = set()
for node in obj_nodes:
if self.has_node(node):
removed.update(self.clear_descendants(node))
return removed | python | {
"resource": ""
} |
q261821 | DependencyGraph.get_nodes_with | validation | def get_nodes_with(self, obj):
"""Return nodes with `obj`."""
result = set()
if nx.__version__[0] == "1":
nodes = self.nodes_iter()
else:
nodes = self.nodes
for node in nodes:
if node[OBJ] == obj:
result.add(node)
return result | python | {
"resource": ""
} |
q261822 | DependencyGraph.add_path | validation | def add_path(self, nodes, **attr):
"""In replacement for Deprecated add_path method"""
if nx.__version__[0] == "1":
return super().add_path(nodes, **attr)
else:
return nx.add_path(self, nodes, **attr) | python | {
"resource": ""
} |
q261823 | Model.rename | validation | def rename(self, name):
"""Rename the model itself"""
self._impl.system.rename_model(new_name=name, old_name=self.name) | python | {
"resource": ""
} |
q261824 | ModelImpl.rename | validation | def rename(self, name):
"""Rename self. Must be called only by its system."""
if is_valid_name(name):
if name not in self.system.models:
self.name = name
return True # Rename success
else: # Model name already exists
return False
else:
raise ValueError("Invalid name '%s'." % name) | python | {
"resource": ""
} |
q261825 | ModelImpl.clear_descendants | validation | def clear_descendants(self, source, clear_source=True):
"""Clear values and nodes calculated from `source`."""
removed = self.cellgraph.clear_descendants(source, clear_source)
for node in removed:
del node[OBJ].data[node[KEY]] | python | {
"resource": ""
} |
q261826 | ModelImpl.clear_obj | validation | def clear_obj(self, obj):
"""Clear values and nodes of `obj` and their dependants."""
removed = self.cellgraph.clear_obj(obj)
for node in removed:
del node[OBJ].data[node[KEY]] | python | {
"resource": ""
} |
q261827 | ModelImpl.get_object | validation | def get_object(self, name):
"""Retrieve an object by a dotted name relative to the model."""
parts = name.split(".")
space = self.spaces[parts.pop(0)]
if parts:
return space.get_object(".".join(parts))
else:
return space | python | {
"resource": ""
} |
q261828 | ModelImpl.get_dynamic_base | validation | def get_dynamic_base(self, bases: tuple):
"""Create of get a base space for a tuple of bases"""
try:
return self._dynamic_bases_inverse[bases]
except KeyError:
name = self._dynamic_base_namer.get_next(self._dynamic_bases)
base = self._new_space(name=name)
self.spacegraph.add_space(base)
self._dynamic_bases[name] = base
self._dynamic_bases_inverse[bases] = base
base.add_bases(bases)
return base | python | {
"resource": ""
} |
q261829 | SpaceGraph.check_mro | validation | def check_mro(self, bases):
"""Check if C3 MRO is possible with given bases"""
try:
self.add_node("temp")
for base in bases:
nx.DiGraph.add_edge(self, base, "temp")
result = self.get_mro("temp")[1:]
finally:
self.remove_node("temp")
return result | python | {
"resource": ""
} |
q261830 | get_command_names | validation | def get_command_names():
"""
Returns a list of command names supported
"""
ret = []
for f in os.listdir(COMMAND_MODULE_PATH):
if os.path.isfile(os.path.join(COMMAND_MODULE_PATH, f)) and f.endswith(COMMAND_MODULE_SUFFIX):
ret.append(f[:-len(COMMAND_MODULE_SUFFIX)])
return ret | python | {
"resource": ""
} |
q261831 | get | validation | def get(vals, key, default_val=None):
"""
Returns a dictionary value
"""
val = vals
for part in key.split('.'):
if isinstance(val, dict):
val = val.get(part, None)
if val is None:
return default_val
else:
return default_val
return val | python | {
"resource": ""
} |
q261832 | parse_option_settings | validation | def parse_option_settings(option_settings):
"""
Parses option_settings as they are defined in the configuration file
"""
ret = []
for namespace, params in list(option_settings.items()):
for key, value in list(params.items()):
ret.append((namespace, key, value))
return ret | python | {
"resource": ""
} |
q261833 | parse_env_config | validation | def parse_env_config(config, env_name):
"""
Parses an environment config
"""
all_env = get(config, 'app.all_environments', {})
env = get(config, 'app.environments.' + str(env_name), {})
return merge_dict(all_env, env) | python | {
"resource": ""
} |
q261834 | create_archive | validation | def create_archive(directory, filename, config={}, ignore_predicate=None, ignored_files=['.git', '.svn']):
"""
Creates an archive from a directory and returns
the file that was created.
"""
with zipfile.ZipFile(filename, 'w', compression=zipfile.ZIP_DEFLATED) as zip_file:
root_len = len(os.path.abspath(directory))
# create it
out("Creating archive: " + str(filename))
for root, dirs, files in os.walk(directory, followlinks=True):
archive_root = os.path.abspath(root)[root_len + 1:]
for f in files:
fullpath = os.path.join(root, f)
archive_name = os.path.join(archive_root, f)
# ignore the file we're creating
if filename in fullpath:
continue
# ignored files
if ignored_files is not None:
for name in ignored_files:
if fullpath.endswith(name):
out("Skipping: " + str(name))
continue
# do predicate
if ignore_predicate is not None:
if not ignore_predicate(archive_name):
out("Skipping: " + str(archive_name))
continue
out("Adding: " + str(archive_name))
zip_file.write(fullpath, archive_name, zipfile.ZIP_DEFLATED)
return filename | python | {
"resource": ""
} |
q261835 | add_config_files_to_archive | validation | def add_config_files_to_archive(directory, filename, config={}):
"""
Adds configuration files to an existing archive
"""
with zipfile.ZipFile(filename, 'a') as zip_file:
for conf in config:
for conf, tree in list(conf.items()):
if 'yaml' in tree:
content = yaml.dump(tree['yaml'], default_flow_style=False)
else:
content = tree.get('content', '')
out("Adding file " + str(conf) + " to archive " + str(filename))
file_entry = zipfile.ZipInfo(conf)
file_entry.external_attr = tree.get('permissions', 0o644) << 16
zip_file.writestr(file_entry, content)
return filename | python | {
"resource": ""
} |
q261836 | EbsHelper.swap_environment_cnames | validation | def swap_environment_cnames(self, from_env_name, to_env_name):
"""
Swaps cnames for an environment
"""
self.ebs.swap_environment_cnames(source_environment_name=from_env_name,
destination_environment_name=to_env_name) | python | {
"resource": ""
} |
q261837 | EbsHelper.upload_archive | validation | def upload_archive(self, filename, key, auto_create_bucket=True):
"""
Uploads an application archive version to s3
"""
try:
bucket = self.s3.get_bucket(self.aws.bucket)
if ((
self.aws.region != 'us-east-1' and self.aws.region != 'eu-west-1') and bucket.get_location() != self.aws.region) or (
self.aws.region == 'us-east-1' and bucket.get_location() != '') or (
self.aws.region == 'eu-west-1' and bucket.get_location() != 'eu-west-1'):
raise Exception("Existing bucket doesn't match region")
except S3ResponseError:
bucket = self.s3.create_bucket(self.aws.bucket, location=self.aws.region)
def __report_upload_progress(sent, total):
if not sent:
sent = 0
if not total:
total = 0
out("Uploaded " + str(sent) + " bytes of " + str(total) \
+ " (" + str(int(float(max(1, sent)) / float(total) * 100)) + "%)")
# upload the new version
k = Key(bucket)
k.key = self.aws.bucket_path + key
k.set_metadata('time', str(time()))
k.set_contents_from_filename(filename, cb=__report_upload_progress, num_cb=10) | python | {
"resource": ""
} |
q261838 | EbsHelper.application_exists | validation | def application_exists(self):
"""
Returns whether or not the given app_name exists
"""
response = self.ebs.describe_applications(application_names=[self.app_name])
return len(response['DescribeApplicationsResponse']['DescribeApplicationsResult']['Applications']) > 0 | python | {
"resource": ""
} |
q261839 | EbsHelper.create_environment | validation | def create_environment(self, env_name, version_label=None,
solution_stack_name=None, cname_prefix=None, description=None,
option_settings=None, tier_name='WebServer', tier_type='Standard', tier_version='1.1'):
"""
Creates a new environment
"""
out("Creating environment: " + str(env_name) + ", tier_name:" + str(tier_name) + ", tier_type:" + str(tier_type))
self.ebs.create_environment(self.app_name, env_name,
version_label=version_label,
solution_stack_name=solution_stack_name,
cname_prefix=cname_prefix,
description=description,
option_settings=option_settings,
tier_type=tier_type,
tier_name=tier_name,
tier_version=tier_version) | python | {
"resource": ""
} |
q261840 | EbsHelper.environment_exists | validation | def environment_exists(self, env_name):
"""
Returns whether or not the given environment exists
"""
response = self.ebs.describe_environments(application_name=self.app_name, environment_names=[env_name],
include_deleted=False)
return len(response['DescribeEnvironmentsResponse']['DescribeEnvironmentsResult']['Environments']) > 0 \
and response['DescribeEnvironmentsResponse']['DescribeEnvironmentsResult']['Environments'][0][
'Status'] != 'Terminated' | python | {
"resource": ""
} |
q261841 | EbsHelper.get_environments | validation | def get_environments(self):
"""
Returns the environments
"""
response = self.ebs.describe_environments(application_name=self.app_name, include_deleted=False)
return response['DescribeEnvironmentsResponse']['DescribeEnvironmentsResult']['Environments'] | python | {
"resource": ""
} |
q261842 | EbsHelper.update_environment | validation | def update_environment(self, environment_name, description=None, option_settings=[], tier_type=None, tier_name=None,
tier_version='1.0'):
"""
Updates an application version
"""
out("Updating environment: " + str(environment_name))
messages = self.ebs.validate_configuration_settings(self.app_name, option_settings,
environment_name=environment_name)
messages = messages['ValidateConfigurationSettingsResponse']['ValidateConfigurationSettingsResult']['Messages']
ok = True
for message in messages:
if message['Severity'] == 'error':
ok = False
out("[" + message['Severity'] + "] " + str(environment_name) + " - '" \
+ message['Namespace'] + ":" + message['OptionName'] + "': " + message['Message'])
self.ebs.update_environment(
environment_name=environment_name,
description=description,
option_settings=option_settings,
tier_type=tier_type,
tier_name=tier_name,
tier_version=tier_version) | python | {
"resource": ""
} |
q261843 | EbsHelper.environment_name_for_cname | validation | def environment_name_for_cname(self, env_cname):
"""
Returns an environment name for the given cname
"""
envs = self.get_environments()
for env in envs:
if env['Status'] != 'Terminated' \
and 'CNAME' in env \
and env['CNAME'] \
and env['CNAME'].lower().startswith(env_cname.lower() + '.'):
return env['EnvironmentName']
return None | python | {
"resource": ""
} |
q261844 | EbsHelper.deploy_version | validation | def deploy_version(self, environment_name, version_label):
"""
Deploys a version to an environment
"""
out("Deploying " + str(version_label) + " to " + str(environment_name))
self.ebs.update_environment(environment_name=environment_name, version_label=version_label) | python | {
"resource": ""
} |
q261845 | EbsHelper.get_versions | validation | def get_versions(self):
"""
Returns the versions available
"""
response = self.ebs.describe_application_versions(application_name=self.app_name)
return response['DescribeApplicationVersionsResponse']['DescribeApplicationVersionsResult']['ApplicationVersions'] | python | {
"resource": ""
} |
q261846 | EbsHelper.create_application_version | validation | def create_application_version(self, version_label, key):
"""
Creates an application version
"""
out("Creating application version " + str(version_label) + " for " + str(key))
self.ebs.create_application_version(self.app_name, version_label,
s3_bucket=self.aws.bucket, s3_key=self.aws.bucket_path+key) | python | {
"resource": ""
} |
q261847 | EbsHelper.delete_unused_versions | validation | def delete_unused_versions(self, versions_to_keep=10):
"""
Deletes unused versions
"""
# get versions in use
environments = self.ebs.describe_environments(application_name=self.app_name, include_deleted=False)
environments = environments['DescribeEnvironmentsResponse']['DescribeEnvironmentsResult']['Environments']
versions_in_use = []
for env in environments:
versions_in_use.append(env['VersionLabel'])
# get all versions
versions = self.ebs.describe_application_versions(application_name=self.app_name)
versions = versions['DescribeApplicationVersionsResponse']['DescribeApplicationVersionsResult'][
'ApplicationVersions']
versions = sorted(versions, reverse=True, key=functools.cmp_to_key(lambda x, y: (x['DateCreated'] > y['DateCreated']) - (x['DateCreated'] < y['DateCreated'])))
# delete versions in use
for version in versions[versions_to_keep:]:
if version['VersionLabel'] in versions_in_use:
out("Not deleting " + version["VersionLabel"] + " because it is in use")
else:
out("Deleting unused version: " + version["VersionLabel"])
self.ebs.delete_application_version(application_name=self.app_name,
version_label=version['VersionLabel'])
sleep(2) | python | {
"resource": ""
} |
q261848 | EbsHelper.describe_events | validation | def describe_events(self, environment_name, next_token=None, start_time=None):
"""
Describes events from the given environment
"""
events = self.ebs.describe_events(
application_name=self.app_name,
environment_name=environment_name,
next_token=next_token,
start_time=start_time + 'Z')
return (events['DescribeEventsResponse']['DescribeEventsResult']['Events'], events['DescribeEventsResponse']['DescribeEventsResult']['NextToken']) | python | {
"resource": ""
} |
q261849 | add_arguments | validation | def add_arguments(parser):
"""
adds arguments for the swap urls command
"""
parser.add_argument('-o', '--old-environment', help='Old environment name', required=True)
parser.add_argument('-n', '--new-environment', help='New environment name', required=True) | python | {
"resource": ""
} |
q261850 | execute | validation | def execute(helper, config, args):
"""
Swaps old and new URLs.
If old_environment was active, new_environment will become the active environment
"""
old_env_name = args.old_environment
new_env_name = args.new_environment
# swap C-Names
out("Assuming that {} is the currently active environment...".format(old_env_name))
out("Swapping environment cnames: {} will become active, {} will become inactive.".format(new_env_name,
old_env_name))
helper.swap_environment_cnames(old_env_name, new_env_name)
helper.wait_for_environments([old_env_name, new_env_name], status='Ready', include_deleted=False) | python | {
"resource": ""
} |
q261851 | execute | validation | def execute(helper, config, args):
"""
dump command dumps things
"""
env = parse_env_config(config, args.environment)
option_settings = env.get('option_settings', {})
settings = parse_option_settings(option_settings)
for setting in settings:
out(str(setting)) | python | {
"resource": ""
} |
q261852 | execute | validation | def execute(helper, config, args):
"""
The init command
"""
# check to see if the application exists
if not helper.application_exists():
helper.create_application(get(config, 'app.description'))
else:
out("Application "+get(config, 'app.app_name')+" exists")
# create environments
environment_names = []
environments_to_wait_for_green = []
for env_name, env_config in list(get(config, 'app.environments').items()):
environment_names.append(env_name)
env_config = parse_env_config(config, env_name)
if not helper.environment_exists(env_name):
option_settings = parse_option_settings(env_config.get('option_settings', {}))
helper.create_environment(env_name,
solution_stack_name=env_config.get('solution_stack_name'),
cname_prefix=env_config.get('cname_prefix', None),
description=env_config.get('description', None),
option_settings=option_settings,
tier_name=env_config.get('tier_name'),
tier_type=env_config.get('tier_type'),
tier_version=env_config.get('tier_version'),
version_label=args.version_label)
environments_to_wait_for_green.append(env_name)
else:
out("Environment "+env_name)
# get the environments
environments_to_wait_for_term = []
if args.delete:
environments = helper.get_environments()
for env in environments:
if env['EnvironmentName'] not in environment_names:
if env['Status'] != 'Ready':
out("Unable to delete "+env['EnvironmentName']+" because it's not in status Ready ("+env['Status']+")")
else:
out("Deleting environment: "+env['EnvironmentName'])
helper.delete_environment(env['EnvironmentName'])
environments_to_wait_for_term.append(env['EnvironmentName'])
# wait
if not args.dont_wait and len(environments_to_wait_for_green)>0:
helper.wait_for_environments(environments_to_wait_for_green, status='Ready', include_deleted=False)
if not args.dont_wait and len(environments_to_wait_for_term)>0:
helper.wait_for_environments(environments_to_wait_for_term, status='Terminated', include_deleted=False)
out("Application initialized")
return 0 | python | {
"resource": ""
} |
q261853 | join_phonemes | validation | def join_phonemes(*args):
"""Joins a Hangul letter from Korean phonemes."""
# Normalize arguments as onset, nucleus, coda.
if len(args) == 1:
# tuple of (onset, nucleus[, coda])
args = args[0]
if len(args) == 2:
args += (CODAS[0],)
try:
onset, nucleus, coda = args
except ValueError:
raise TypeError('join_phonemes() takes at most 3 arguments')
offset = (
(ONSETS.index(onset) * NUM_NUCLEUSES + NUCLEUSES.index(nucleus)) *
NUM_CODAS + CODAS.index(coda)
)
return unichr(FIRST_HANGUL_OFFSET + offset) | python | {
"resource": ""
} |
q261854 | execute | validation | def execute(helper, config, args):
"""
Waits for an environment to be healthy
"""
helper.wait_for_environments(args.environment, health=args.health) | python | {
"resource": ""
} |
q261855 | add_arguments | validation | def add_arguments(parser):
"""
Args for the init command
"""
parser.add_argument('-e', '--environment', help='Environment name', required=False, nargs='+')
parser.add_argument('-w', '--dont-wait', help='Skip waiting for the app to be deleted', action='store_true') | python | {
"resource": ""
} |
q261856 | execute | validation | def execute(helper, config, args):
"""
Describes recent events for an environment.
"""
environment_name = args.environment
(events, next_token) = helper.describe_events(environment_name, start_time=datetime.now().isoformat())
# swap C-Names
for event in events:
print(("["+event['Severity']+"] "+event['Message'])) | python | {
"resource": ""
} |
q261857 | execute | validation | def execute(helper, config, args):
"""
Lists solution stacks
"""
out("Available solution stacks")
for stack in helper.list_available_solution_stacks():
out(" "+str(stack))
return 0 | python | {
"resource": ""
} |
q261858 | pick_coda_from_letter | validation | def pick_coda_from_letter(letter):
"""Picks only a coda from a Hangul letter. It returns ``None`` if the
given letter is not Hangul.
"""
try:
__, __, coda = \
split_phonemes(letter, onset=False, nucleus=False, coda=True)
except ValueError:
return None
else:
return coda | python | {
"resource": ""
} |
q261859 | pick_coda_from_decimal | validation | def pick_coda_from_decimal(decimal):
"""Picks only a coda from a decimal."""
decimal = Decimal(decimal)
__, digits, exp = decimal.as_tuple()
if exp < 0:
return DIGIT_CODAS[digits[-1]]
__, digits, exp = decimal.normalize().as_tuple()
index = bisect_right(EXP_INDICES, exp) - 1
if index < 0:
return DIGIT_CODAS[digits[-1]]
else:
return EXP_CODAS[EXP_INDICES[index]] | python | {
"resource": ""
} |
q261860 | deposit_fetcher | validation | def deposit_fetcher(record_uuid, data):
"""Fetch a deposit identifier.
:param record_uuid: Record UUID.
:param data: Record content.
:returns: A :class:`invenio_pidstore.fetchers.FetchedPID` that contains
data['_deposit']['id'] as pid_value.
"""
return FetchedPID(
provider=DepositProvider,
pid_type=DepositProvider.pid_type,
pid_value=str(data['_deposit']['id']),
) | python | {
"resource": ""
} |
q261861 | deposit_minter | validation | def deposit_minter(record_uuid, data):
"""Mint a deposit identifier.
A PID with the following characteristics is created:
.. code-block:: python
{
"object_type": "rec",
"object_uuid": record_uuid,
"pid_value": "<new-pid-value>",
"pid_type": "depid",
}
The following deposit meta information are updated:
.. code-block:: python
deposit['_deposit'] = {
"id": "<new-pid-value>",
"status": "draft",
}
:param record_uuid: Record UUID.
:param data: Record content.
:returns: A :class:`invenio_pidstore.models.PersistentIdentifier` object.
"""
provider = DepositProvider.create(
object_type='rec',
object_uuid=record_uuid,
pid_value=uuid.uuid4().hex,
)
data['_deposit'] = {
'id': provider.pid.pid_value,
'status': 'draft',
}
return provider.pid | python | {
"resource": ""
} |
q261862 | admin_permission_factory | validation | def admin_permission_factory():
"""Factory for creating a permission for an admin `deposit-admin-access`.
If `invenio-access` module is installed, it returns a
:class:`invenio_access.permissions.DynamicPermission` object.
Otherwise, it returns a :class:`flask_principal.Permission` object.
:returns: Permission instance.
"""
try:
pkg_resources.get_distribution('invenio-access')
from invenio_access.permissions import DynamicPermission as Permission
except pkg_resources.DistributionNotFound:
from flask_principal import Permission
return Permission(action_admin_access) | python | {
"resource": ""
} |
q261863 | create_blueprint | validation | def create_blueprint(endpoints):
"""Create Invenio-Deposit-UI blueprint.
See: :data:`invenio_deposit.config.DEPOSIT_RECORDS_UI_ENDPOINTS`.
:param endpoints: List of endpoints configuration.
:returns: The configured blueprint.
"""
from invenio_records_ui.views import create_url_rule
blueprint = Blueprint(
'invenio_deposit_ui',
__name__,
static_folder='../static',
template_folder='../templates',
url_prefix='',
)
@blueprint.errorhandler(PIDDeletedError)
def tombstone_errorhandler(error):
"""Render tombstone page."""
return render_template(
current_app.config['DEPOSIT_UI_TOMBSTONE_TEMPLATE'],
pid=error.pid,
record=error.record or {},
), 410
for endpoint, options in (endpoints or {}).items():
options = deepcopy(options)
options.pop('jsonschema', None)
options.pop('schemaform', None)
blueprint.add_url_rule(**create_url_rule(endpoint, **options))
@blueprint.route('/deposit')
@login_required
def index():
"""List user deposits."""
return render_template(current_app.config['DEPOSIT_UI_INDEX_TEMPLATE'])
@blueprint.route('/deposit/new')
@login_required
def new():
"""Create new deposit."""
deposit_type = request.values.get('type')
return render_template(
current_app.config['DEPOSIT_UI_NEW_TEMPLATE'],
record={'_deposit': {'id': None}},
jsonschema=current_deposit.jsonschemas[deposit_type],
schemaform=current_deposit.schemaforms[deposit_type],
)
return blueprint | python | {
"resource": ""
} |
q261864 | default_view_method | validation | def default_view_method(pid, record, template=None):
"""Default view method.
Sends ``record_viewed`` signal and renders template.
"""
record_viewed.send(
current_app._get_current_object(),
pid=pid,
record=record,
)
deposit_type = request.values.get('type')
return render_template(
template,
pid=pid,
record=record,
jsonschema=current_deposit.jsonschemas[deposit_type],
schemaform=current_deposit.schemaforms[deposit_type],
) | python | {
"resource": ""
} |
q261865 | DepositProvider.create | validation | def create(cls, object_type=None, object_uuid=None, **kwargs):
"""Create a new deposit identifier.
:param object_type: The object type (Default: ``None``)
:param object_uuid: The object UUID (Default: ``None``)
:param kwargs: It contains the pid value.
"""
assert 'pid_value' in kwargs
kwargs.setdefault('status', cls.default_status)
return super(DepositProvider, cls).create(
object_type=object_type, object_uuid=object_uuid, **kwargs) | python | {
"resource": ""
} |
q261866 | extract_actions_from_class | validation | def extract_actions_from_class(record_class):
"""Extract actions from class."""
for name in dir(record_class):
method = getattr(record_class, name, None)
if method and getattr(method, '__deposit_action__', False):
yield method.__name__ | python | {
"resource": ""
} |
q261867 | check_oauth2_scope | validation | def check_oauth2_scope(can_method, *myscopes):
"""Base permission factory that check OAuth2 scope and can_method.
:param can_method: Permission check function that accept a record in input
and return a boolean.
:param myscopes: List of scopes required to permit the access.
:returns: A :class:`flask_principal.Permission` factory.
"""
def check(record, *args, **kwargs):
@require_api_auth()
@require_oauth_scopes(*myscopes)
def can(self):
return can_method(record)
return type('CheckOAuth2Scope', (), {'can': can})()
return check | python | {
"resource": ""
} |
q261868 | can_elasticsearch | validation | def can_elasticsearch(record):
"""Check if a given record is indexed.
:param record: A record object.
:returns: If the record is indexed returns `True`, otherwise `False`.
"""
search = request._methodview.search_class()
search = search.get_record(str(record.id))
return search.count() == 1 | python | {
"resource": ""
} |
q261869 | create_error_handlers | validation | def create_error_handlers(blueprint):
"""Create error handlers on blueprint."""
blueprint.errorhandler(PIDInvalidAction)(create_api_errorhandler(
status=403, message='Invalid action'
))
records_rest_error_handlers(blueprint) | python | {
"resource": ""
} |
q261870 | create_blueprint | validation | def create_blueprint(endpoints):
"""Create Invenio-Deposit-REST blueprint.
See: :data:`invenio_deposit.config.DEPOSIT_REST_ENDPOINTS`.
:param endpoints: List of endpoints configuration.
:returns: The configured blueprint.
"""
blueprint = Blueprint(
'invenio_deposit_rest',
__name__,
url_prefix='',
)
create_error_handlers(blueprint)
for endpoint, options in (endpoints or {}).items():
options = deepcopy(options)
if 'files_serializers' in options:
files_serializers = options.get('files_serializers')
files_serializers = {mime: obj_or_import_string(func)
for mime, func in files_serializers.items()}
del options['files_serializers']
else:
files_serializers = {}
if 'record_serializers' in options:
serializers = options.get('record_serializers')
serializers = {mime: obj_or_import_string(func)
for mime, func in serializers.items()}
else:
serializers = {}
file_list_route = options.pop(
'file_list_route',
'{0}/files'.format(options['item_route'])
)
file_item_route = options.pop(
'file_item_route',
'{0}/files/<path:key>'.format(options['item_route'])
)
options.setdefault('search_class', DepositSearch)
search_class = obj_or_import_string(options['search_class'])
# records rest endpoints will use the deposit class as record class
options.setdefault('record_class', Deposit)
record_class = obj_or_import_string(options['record_class'])
# backward compatibility for indexer class
options.setdefault('indexer_class', None)
for rule in records_rest_url_rules(endpoint, **options):
blueprint.add_url_rule(**rule)
search_class_kwargs = {}
if options.get('search_index'):
search_class_kwargs['index'] = options['search_index']
if options.get('search_type'):
search_class_kwargs['doc_type'] = options['search_type']
ctx = dict(
read_permission_factory=obj_or_import_string(
options.get('read_permission_factory_imp')
),
create_permission_factory=obj_or_import_string(
options.get('create_permission_factory_imp')
),
update_permission_factory=obj_or_import_string(
options.get('update_permission_factory_imp')
),
delete_permission_factory=obj_or_import_string(
options.get('delete_permission_factory_imp')
),
record_class=record_class,
search_class=partial(search_class, **search_class_kwargs),
default_media_type=options.get('default_media_type'),
)
deposit_actions = DepositActionResource.as_view(
DepositActionResource.view_name.format(endpoint),
serializers=serializers,
pid_type=options['pid_type'],
ctx=ctx,
)
blueprint.add_url_rule(
'{0}/actions/<any({1}):action>'.format(
options['item_route'],
','.join(extract_actions_from_class(record_class)),
),
view_func=deposit_actions,
methods=['POST'],
)
deposit_files = DepositFilesResource.as_view(
DepositFilesResource.view_name.format(endpoint),
serializers=files_serializers,
pid_type=options['pid_type'],
ctx=ctx,
)
blueprint.add_url_rule(
file_list_route,
view_func=deposit_files,
methods=['GET', 'POST', 'PUT'],
)
deposit_file = DepositFileResource.as_view(
DepositFileResource.view_name.format(endpoint),
serializers=files_serializers,
pid_type=options['pid_type'],
ctx=ctx,
)
blueprint.add_url_rule(
file_item_route,
view_func=deposit_file,
methods=['GET', 'PUT', 'DELETE'],
)
return blueprint | python | {
"resource": ""
} |
q261871 | DepositActionResource.post | validation | def post(self, pid, record, action):
"""Handle deposit action.
After the action is executed, a
:class:`invenio_deposit.signals.post_action` signal is sent.
Permission required: `update_permission_factory`.
:param pid: Pid object (from url).
:param record: Record object resolved from the pid.
:param action: The action to execute.
"""
record = getattr(record, action)(pid=pid)
db.session.commit()
# Refresh the PID and record metadata
db.session.refresh(pid)
db.session.refresh(record.model)
post_action.send(current_app._get_current_object(), action=action,
pid=pid, deposit=record)
response = self.make_response(pid, record,
202 if action == 'publish' else 201)
endpoint = '.{0}_item'.format(pid.pid_type)
location = url_for(endpoint, pid_value=pid.pid_value, _external=True)
response.headers.extend(dict(Location=location))
return response | python | {
"resource": ""
} |
q261872 | DepositFilesResource.get | validation | def get(self, pid, record):
"""Get files.
Permission required: `read_permission_factory`.
:param pid: Pid object (from url).
:param record: Record object resolved from the pid.
:returns: The files.
"""
return self.make_response(obj=record.files, pid=pid, record=record) | python | {
"resource": ""
} |
q261873 | DepositFilesResource.post | validation | def post(self, pid, record):
"""Handle POST deposit files.
Permission required: `update_permission_factory`.
:param pid: Pid object (from url).
:param record: Record object resolved from the pid.
"""
# load the file
uploaded_file = request.files['file']
# file name
key = secure_filename(
request.form.get('name') or uploaded_file.filename
)
# check if already exists a file with this name
if key in record.files:
raise FileAlreadyExists()
# add it to the deposit
record.files[key] = uploaded_file.stream
record.commit()
db.session.commit()
return self.make_response(
obj=record.files[key].obj, pid=pid, record=record, status=201) | python | {
"resource": ""
} |
q261874 | DepositFilesResource.put | validation | def put(self, pid, record):
"""Handle the sort of the files through the PUT deposit files.
Expected input in body PUT:
.. code-block:: javascript
[
{
"id": 1
},
{
"id": 2
},
...
}
Permission required: `update_permission_factory`.
:param pid: Pid object (from url).
:param record: Record object resolved from the pid.
:returns: The files.
"""
try:
ids = [data['id'] for data in json.loads(
request.data.decode('utf-8'))]
except KeyError:
raise WrongFile()
record.files.sort_by(*ids)
record.commit()
db.session.commit()
return self.make_response(obj=record.files, pid=pid, record=record) | python | {
"resource": ""
} |
q261875 | DepositFileResource.get | validation | def get(self, pid, record, key, version_id, **kwargs):
"""Get file.
Permission required: `read_permission_factory`.
:param pid: Pid object (from url).
:param record: Record object resolved from the pid.
:param key: Unique identifier for the file in the deposit.
:param version_id: File version. Optional. If no version is provided,
the last version is retrieved.
:returns: the file content.
"""
try:
obj = record.files[str(key)].get_version(version_id=version_id)
return self.make_response(
obj=obj or abort(404), pid=pid, record=record)
except KeyError:
abort(404) | python | {
"resource": ""
} |
q261876 | DepositFileResource.put | validation | def put(self, pid, record, key):
"""Handle the file rename through the PUT deposit file.
Permission required: `update_permission_factory`.
:param pid: Pid object (from url).
:param record: Record object resolved from the pid.
:param key: Unique identifier for the file in the deposit.
"""
try:
data = json.loads(request.data.decode('utf-8'))
new_key = data['filename']
except KeyError:
raise WrongFile()
new_key_secure = secure_filename(new_key)
if not new_key_secure or new_key != new_key_secure:
raise WrongFile()
try:
obj = record.files.rename(str(key), new_key_secure)
except KeyError:
abort(404)
record.commit()
db.session.commit()
return self.make_response(obj=obj, pid=pid, record=record) | python | {
"resource": ""
} |
q261877 | DepositFileResource.delete | validation | def delete(self, pid, record, key):
"""Handle DELETE deposit file.
Permission required: `update_permission_factory`.
:param pid: Pid object (from url).
:param record: Record object resolved from the pid.
:param key: Unique identifier for the file in the deposit.
"""
try:
del record.files[str(key)]
record.commit()
db.session.commit()
return make_response('', 204)
except KeyError:
abort(404, 'The specified object does not exist or has already '
'been deleted.') | python | {
"resource": ""
} |
q261878 | records | validation | def records():
"""Load records."""
import pkg_resources
from dojson.contrib.marc21 import marc21
from dojson.contrib.marc21.utils import create_record, split_blob
from flask_login import login_user, logout_user
from invenio_accounts.models import User
from invenio_deposit.api import Deposit
users = User.query.all()
# pkg resources the demodata
data_path = pkg_resources.resource_filename(
'invenio_records', 'data/marc21/bibliographic.xml'
)
with open(data_path) as source:
with current_app.test_request_context():
indexer = RecordIndexer()
with db.session.begin_nested():
for index, data in enumerate(split_blob(source.read()),
start=1):
login_user(users[index % len(users)])
# do translate
record = marc21.do(create_record(data))
# create record
indexer.index(Deposit.create(record))
logout_user()
db.session.commit() | python | {
"resource": ""
} |
q261879 | location | validation | def location():
"""Load default location."""
d = current_app.config['DATADIR']
with db.session.begin_nested():
Location.query.delete()
loc = Location(name='local', uri=d, default=True)
db.session.add(loc)
db.session.commit() | python | {
"resource": ""
} |
q261880 | _DepositState.jsonschemas | validation | def jsonschemas(self):
"""Load deposit JSON schemas."""
_jsonschemas = {
k: v['jsonschema']
for k, v in self.app.config['DEPOSIT_RECORDS_UI_ENDPOINTS'].items()
if 'jsonschema' in v
}
return defaultdict(
lambda: self.app.config['DEPOSIT_DEFAULT_JSONSCHEMA'], _jsonschemas
) | python | {
"resource": ""
} |
q261881 | _DepositState.schemaforms | validation | def schemaforms(self):
"""Load deposit schema forms."""
_schemaforms = {
k: v['schemaform']
for k, v in self.app.config['DEPOSIT_RECORDS_UI_ENDPOINTS'].items()
if 'schemaform' in v
}
return defaultdict(
lambda: self.app.config['DEPOSIT_DEFAULT_SCHEMAFORM'], _schemaforms
) | python | {
"resource": ""
} |
q261882 | deposit_links_factory | validation | def deposit_links_factory(pid):
"""Factory for record links generation.
The dictionary is formed as:
.. code-block:: python
{
'files': '/url/to/files',
'publish': '/url/to/publish',
'edit': '/url/to/edit',
'discard': '/url/to/discard',
...
}
:param pid: The record PID object.
:returns: A dictionary that contains all the links.
"""
links = default_links_factory(pid)
def _url(name, **kwargs):
"""URL builder."""
endpoint = '.{0}_{1}'.format(
current_records_rest.default_endpoint_prefixes[pid.pid_type],
name,
)
return url_for(endpoint, pid_value=pid.pid_value, _external=True,
**kwargs)
links['files'] = _url('files')
ui_endpoint = current_app.config.get('DEPOSIT_UI_ENDPOINT')
if ui_endpoint is not None:
links['html'] = ui_endpoint.format(
host=request.host,
scheme=request.scheme,
pid_value=pid.pid_value,
)
deposit_cls = Deposit
if 'pid_value' in request.view_args:
deposit_cls = request.view_args['pid_value'].data[1].__class__
for action in extract_actions_from_class(deposit_cls):
links[action] = _url('actions', action=action)
return links | python | {
"resource": ""
} |
q261883 | process_minter | validation | def process_minter(value):
"""Load minter from PIDStore registry based on given value.
:param value: Name of the minter.
:returns: The minter.
"""
try:
return current_pidstore.minters[value]
except KeyError:
raise click.BadParameter(
'Unknown minter {0}. Please use one of {1}.'.format(
value, ', '.join(current_pidstore.minters.keys())
)
) | python | {
"resource": ""
} |
q261884 | process_schema | validation | def process_schema(value):
"""Load schema from JSONSchema registry based on given value.
:param value: Schema path, relative to the directory when it was
registered.
:returns: The schema absolute path.
"""
schemas = current_app.extensions['invenio-jsonschemas'].schemas
try:
return schemas[value]
except KeyError:
raise click.BadParameter(
'Unknown schema {0}. Please use one of:\n {1}'.format(
value, '\n'.join(schemas.keys())
)
) | python | {
"resource": ""
} |
q261885 | json_serializer | validation | def json_serializer(pid, data, *args):
"""Build a JSON Flask response using the given data.
:param pid: The `invenio_pidstore.models.PersistentIdentifier` of the
record.
:param data: The record metadata.
:returns: A Flask response with JSON data.
:rtype: :py:class:`flask.Response`.
"""
if data is not None:
response = Response(
json.dumps(data.dumps()),
mimetype='application/json'
)
else:
response = Response(mimetype='application/json')
return response | python | {
"resource": ""
} |
q261886 | file_serializer | validation | def file_serializer(obj):
"""Serialize a object.
:param obj: A :class:`invenio_files_rest.models.ObjectVersion` instance.
:returns: A dictionary with the fields to serialize.
"""
return {
"id": str(obj.file_id),
"filename": obj.key,
"filesize": obj.file.size,
"checksum": obj.file.checksum,
} | python | {
"resource": ""
} |
q261887 | json_files_serializer | validation | def json_files_serializer(objs, status=None):
"""JSON Files Serializer.
:parma objs: A list of:class:`invenio_files_rest.models.ObjectVersion`
instances.
:param status: A HTTP Status. (Default: ``None``)
:returns: A Flask response with JSON data.
:rtype: :py:class:`flask.Response`.
"""
files = [file_serializer(obj) for obj in objs]
return make_response(json.dumps(files), status) | python | {
"resource": ""
} |
q261888 | index_deposit_after_publish | validation | def index_deposit_after_publish(sender, action=None, pid=None, deposit=None):
"""Index the record after publishing.
.. note:: if the record is not published, it doesn't index.
:param sender: Who send the signal.
:param action: Action executed by the sender. (Default: ``None``)
:param pid: PID object. (Default: ``None``)
:param deposit: Deposit object. (Default: ``None``)
"""
if action == 'publish':
_, record = deposit.fetch_published()
index_record.delay(str(record.id)) | python | {
"resource": ""
} |
q261889 | index | validation | def index(method=None, delete=False):
"""Decorator to update index.
:param method: Function wrapped. (Default: ``None``)
:param delete: If `True` delete the indexed record. (Default: ``None``)
"""
if method is None:
return partial(index, delete=delete)
@wraps(method)
def wrapper(self_or_cls, *args, **kwargs):
"""Send record for indexing."""
result = method(self_or_cls, *args, **kwargs)
try:
if delete:
self_or_cls.indexer.delete(result)
else:
self_or_cls.indexer.index(result)
except RequestError:
current_app.logger.exception('Could not index {0}.'.format(result))
return result
return wrapper | python | {
"resource": ""
} |
q261890 | preserve | validation | def preserve(method=None, result=True, fields=None):
"""Preserve fields in deposit.
:param method: Function to execute. (Default: ``None``)
:param result: If `True` returns the result of method execution,
otherwise `self`. (Default: ``True``)
:param fields: List of fields to preserve (default: ``('_deposit',)``).
"""
if method is None:
return partial(preserve, result=result, fields=fields)
fields = fields or ('_deposit', )
@wraps(method)
def wrapper(self, *args, **kwargs):
"""Check current deposit status."""
data = {field: self[field] for field in fields if field in self}
result_ = method(self, *args, **kwargs)
replace = result_ if result else self
for field in data:
replace[field] = data[field]
return result_
return wrapper | python | {
"resource": ""
} |
q261891 | Deposit.pid | validation | def pid(self):
"""Return an instance of deposit PID."""
pid = self.deposit_fetcher(self.id, self)
return PersistentIdentifier.get(pid.pid_type,
pid.pid_value) | python | {
"resource": ""
} |
q261892 | Deposit.record_schema | validation | def record_schema(self):
"""Convert deposit schema to a valid record schema."""
schema_path = current_jsonschemas.url_to_path(self['$schema'])
schema_prefix = current_app.config['DEPOSIT_JSONSCHEMAS_PREFIX']
if schema_path and schema_path.startswith(schema_prefix):
return current_jsonschemas.path_to_url(
schema_path[len(schema_prefix):]
) | python | {
"resource": ""
} |
q261893 | Deposit.build_deposit_schema | validation | def build_deposit_schema(self, record):
"""Convert record schema to a valid deposit schema.
:param record: The record used to build deposit schema.
:returns: The absolute URL to the schema or `None`.
"""
schema_path = current_jsonschemas.url_to_path(record['$schema'])
schema_prefix = current_app.config['DEPOSIT_JSONSCHEMAS_PREFIX']
if schema_path:
return current_jsonschemas.path_to_url(
schema_prefix + schema_path
) | python | {
"resource": ""
} |
q261894 | Deposit.fetch_published | validation | def fetch_published(self):
"""Return a tuple with PID and published record."""
pid_type = self['_deposit']['pid']['type']
pid_value = self['_deposit']['pid']['value']
resolver = Resolver(
pid_type=pid_type, object_type='rec',
getter=partial(self.published_record_class.get_record,
with_deleted=True)
)
return resolver.resolve(pid_value) | python | {
"resource": ""
} |
q261895 | Deposit.merge_with_published | validation | def merge_with_published(self):
"""Merge changes with latest published version."""
pid, first = self.fetch_published()
lca = first.revisions[self['_deposit']['pid']['revision_id']]
# ignore _deposit and $schema field
args = [lca.dumps(), first.dumps(), self.dumps()]
for arg in args:
del arg['$schema'], arg['_deposit']
args.append({})
m = Merger(*args)
try:
m.run()
except UnresolvedConflictsException:
raise MergeConflict()
return patch(m.unified_patches, lca) | python | {
"resource": ""
} |
q261896 | Deposit.commit | validation | def commit(self, *args, **kwargs):
"""Store changes on current instance in database and index it."""
return super(Deposit, self).commit(*args, **kwargs) | python | {
"resource": ""
} |
q261897 | Deposit.create | validation | def create(cls, data, id_=None):
"""Create a deposit.
Initialize the follow information inside the deposit:
.. code-block:: python
deposit['_deposit'] = {
'id': pid_value,
'status': 'draft',
'owners': [user_id],
'created_by': user_id,
}
The deposit index is updated.
:param data: Input dictionary to fill the deposit.
:param id_: Default uuid for the deposit.
:returns: The new created deposit.
"""
data.setdefault('$schema', current_jsonschemas.path_to_url(
current_app.config['DEPOSIT_DEFAULT_JSONSCHEMA']
))
if '_deposit' not in data:
id_ = id_ or uuid.uuid4()
cls.deposit_minter(id_, data)
data['_deposit'].setdefault('owners', list())
if current_user and current_user.is_authenticated:
creator_id = int(current_user.get_id())
if creator_id not in data['_deposit']['owners']:
data['_deposit']['owners'].append(creator_id)
data['_deposit']['created_by'] = creator_id
return super(Deposit, cls).create(data, id_=id_) | python | {
"resource": ""
} |
q261898 | Deposit._process_files | validation | def _process_files(self, record_id, data):
"""Snapshot bucket and add files in record during first publishing."""
if self.files:
assert not self.files.bucket.locked
self.files.bucket.locked = True
snapshot = self.files.bucket.snapshot(lock=True)
data['_files'] = self.files.dumps(bucket=snapshot.id)
yield data
db.session.add(RecordsBuckets(
record_id=record_id, bucket_id=snapshot.id
))
else:
yield data | python | {
"resource": ""
} |
q261899 | Deposit._publish_new | validation | def _publish_new(self, id_=None):
"""Publish new deposit.
:param id_: The forced record UUID.
"""
minter = current_pidstore.minters[
current_app.config['DEPOSIT_PID_MINTER']
]
id_ = id_ or uuid.uuid4()
record_pid = minter(id_, self)
self['_deposit']['pid'] = {
'type': record_pid.pid_type,
'value': record_pid.pid_value,
'revision_id': 0,
}
data = dict(self.dumps())
data['$schema'] = self.record_schema
with self._process_files(id_, data):
record = self.published_record_class.create(data, id_=id_)
return record | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.