_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q271200 | AsyncSatel.close | test | def close(self):
"""Stop monitoring and close connection."""
_LOGGER.debug("Closing...")
| python | {
"resource": ""
} |
q271201 | PostgresContentsManager.purge_db | test | def purge_db(self):
"""
Clear all matching our user_id.
"""
with | python | {
"resource": ""
} |
q271202 | PostgresContentsManager.guess_type | test | def guess_type(self, path, allow_directory=True):
"""
Guess the type of a file.
If allow_directory is False, don't consider the possibility that the
file is a directory.
"""
if path.endswith('.ipynb'):
| python | {
"resource": ""
} |
q271203 | PostgresContentsManager.get_file_id | test | def get_file_id(self, path):
"""
Get the id of a file in the database. This function is specific to
this implementation of ContentsManager and is not in the base class.
"""
with self.engine.begin() as db:
| python | {
"resource": ""
} |
q271204 | PostgresContentsManager._get_notebook | test | def _get_notebook(self, path, content, format):
"""
Get a notebook from the database.
"""
with self.engine.begin() as db:
try:
record = get_file(
db,
self.user_id,
path,
| python | {
"resource": ""
} |
q271205 | PostgresContentsManager._notebook_model_from_db | test | def _notebook_model_from_db(self, record, content):
"""
Build a notebook model from database record.
"""
path = to_api_path(record['parent_name'] + record['name'])
model = base_model(path)
model['type'] = 'notebook'
model['last_modified'] = model['created'] = record['created_at']
if content:
| python | {
"resource": ""
} |
q271206 | PostgresContentsManager._get_directory | test | def _get_directory(self, path, content, format):
"""
Get a directory from the database.
"""
with self.engine.begin() as db:
try:
record = get_directory(
db, self.user_id, path, content
)
except NoSuchDirectory:
if self.file_exists(path):
# TODO: It's awkward/expensive to have to check this to
| python | {
"resource": ""
} |
q271207 | PostgresContentsManager._convert_file_records | test | def _convert_file_records(self, file_records):
"""
Apply _notebook_model_from_db or _file_model_from_db to each entry
in file_records, depending on the result of `guess_type`.
"""
for record in file_records:
type_ = self.guess_type(record['name'], allow_directory=False)
if type_ == 'notebook':
| python | {
"resource": ""
} |
q271208 | PostgresContentsManager._directory_model_from_db | test | def _directory_model_from_db(self, record, content):
"""
Build a directory model from database directory record.
"""
model = base_directory_model(to_api_path(record['name']))
if content:
model['format'] = 'json'
model['content'] = list(
chain(
self._convert_file_records(record['files']),
| python | {
"resource": ""
} |
q271209 | PostgresContentsManager._file_model_from_db | test | def _file_model_from_db(self, record, content, format):
"""
Build a file model from database record.
"""
# TODO: Most of this is shared with _notebook_model_from_db.
path = to_api_path(record['parent_name'] + record['name'])
model = base_model(path)
model['type'] = 'file'
model['last_modified'] = model['created'] = record['created_at']
| python | {
"resource": ""
} |
q271210 | PostgresContentsManager._save_notebook | test | def _save_notebook(self, db, model, path):
"""
Save a notebook.
Returns a validation message.
"""
nb_contents = from_dict(model['content'])
self.check_and_sign(nb_contents, path)
save_file(
db,
self.user_id,
path,
writes_base64(nb_contents),
self.crypto.encrypt,
| python | {
"resource": ""
} |
q271211 | PostgresContentsManager._save_file | test | def _save_file(self, db, model, path):
"""
Save a non-notebook file.
"""
save_file(
db,
| python | {
"resource": ""
} |
q271212 | PostgresContentsManager.rename_file | test | def rename_file(self, old_path, path):
"""
Rename object from old_path to path.
NOTE: This method is unfortunately named on the base class. It
actually moves a file or a directory.
"""
with self.engine.begin() as db:
try:
if self.file_exists(old_path):
rename_file(db, self.user_id, old_path, path)
elif self.dir_exists(old_path):
rename_directory(db, self.user_id, old_path, path)
| python | {
"resource": ""
} |
q271213 | PostgresContentsManager.delete_file | test | def delete_file(self, path):
"""
Delete object corresponding to path.
"""
if self.file_exists(path):
self._delete_non_directory(path)
| python | {
"resource": ""
} |
q271214 | ensure_db_user | test | def ensure_db_user(db, user_id):
"""
Add a new user if they don't already exist.
"""
with ignore_unique_violation():
| python | {
"resource": ""
} |
q271215 | purge_user | test | def purge_user(db, user_id):
"""
Delete a user and all of their resources.
"""
db.execute(files.delete().where(
files.c.user_id == user_id
))
db.execute(directories.delete().where(
| python | {
"resource": ""
} |
q271216 | create_directory | test | def create_directory(db, user_id, api_path):
"""
Create a directory.
"""
name = from_api_dirname(api_path)
if name == '/':
parent_name = null()
parent_user_id = null()
else:
# Convert '/foo/bar/buzz/' -> '/foo/bar/'
parent_name = name[:name.rindex('/', 0, -1) + 1]
parent_user_id = user_id
db.execute( | python | {
"resource": ""
} |
q271217 | _is_in_directory | test | def _is_in_directory(table, user_id, db_dirname):
"""
Return a WHERE clause that matches entries in a directory.
Parameterized on table because this clause is re-used between files and
directories.
| python | {
"resource": ""
} |
q271218 | delete_directory | test | def delete_directory(db, user_id, api_path):
"""
Delete a directory.
"""
db_dirname = from_api_dirname(api_path)
try:
result = db.execute(
directories.delete().where(
and_(
directories.c.user_id == user_id,
directories.c.name == db_dirname,
)
)
)
except IntegrityError as error:
| python | {
"resource": ""
} |
q271219 | _dir_exists | test | def _dir_exists(db, user_id, db_dirname):
"""
Internal implementation of dir_exists.
Expects a db-style path name.
"""
return db.execute(
select(
[func.count(directories.c.name)],
).where(
| python | {
"resource": ""
} |
q271220 | files_in_directory | test | def files_in_directory(db, user_id, db_dirname):
"""
Return files in a directory.
"""
fields = _file_default_fields()
rows = db.execute(
select(
fields,
).where(
_is_in_directory(files, user_id, db_dirname),
).order_by(
files.c.user_id,
| python | {
"resource": ""
} |
q271221 | directories_in_directory | test | def directories_in_directory(db, user_id, db_dirname):
"""
Return subdirectories of a directory.
"""
fields = _directory_default_fields()
rows = db.execute(
select(
fields,
| python | {
"resource": ""
} |
q271222 | _file_where | test | def _file_where(user_id, api_path):
"""
Return a WHERE clause matching the given API path and user_id.
"""
directory, name = split_api_filepath(api_path)
return and_(
| python | {
"resource": ""
} |
q271223 | _select_file | test | def _select_file(user_id, api_path, fields, limit):
"""
Return a SELECT statement that returns the latest N versions of a file.
"""
query = select(fields).where(
_file_where(user_id, api_path),
| python | {
"resource": ""
} |
q271224 | _file_default_fields | test | def _file_default_fields():
"""
Default fields returned by a file query.
"""
return [
| python | {
"resource": ""
} |
q271225 | _get_file | test | def _get_file(db, user_id, api_path, query_fields, decrypt_func):
"""
Get file data for the given user_id, path, and query_fields. The
query_fields parameter specifies which database fields should be
included in the returned file data.
"""
result = db.execute(
_select_file(user_id, api_path, query_fields, limit=1),
).first()
| python | {
"resource": ""
} |
q271226 | get_file | test | def get_file(db, user_id, api_path, include_content, decrypt_func):
"""
Get file data for the given user_id and path.
Include content only if include_content=True.
"""
query_fields = _file_default_fields()
| python | {
"resource": ""
} |
q271227 | get_file_id | test | def get_file_id(db, user_id, api_path):
"""
Get the value in the 'id' column for the file with the given
| python | {
"resource": ""
} |
q271228 | file_exists | test | def file_exists(db, user_id, path):
"""
Check if a file exists.
"""
try:
get_file(
db,
user_id,
path,
include_content=False,
| python | {
"resource": ""
} |
q271229 | rename_directory | test | def rename_directory(db, user_id, old_api_path, new_api_path):
"""
Rename a directory.
"""
old_db_path = from_api_dirname(old_api_path)
new_db_path = from_api_dirname(new_api_path)
if old_db_path == '/':
raise RenameRoot('Renaming the root directory is not permitted.')
# Overwriting existing directories is disallowed.
if _dir_exists(db, user_id, new_db_path):
raise DirectoryExists(new_api_path)
# Set this foreign key constraint to deferred so it's not violated
# when we run the first statement to update the name of the directory.
db.execute('SET CONSTRAINTS '
'pgcontents.directories_parent_user_id_fkey DEFERRED')
# Update name column for the directory that's being renamed
db.execute(
directories.update().where(
and_(
directories.c.user_id == user_id,
directories.c.name == old_db_path,
)
).values(
name=new_db_path,
)
)
# Update the name and parent_name of any descendant directories. Do
# this in a single statement so the | python | {
"resource": ""
} |
q271230 | save_file | test | def save_file(db, user_id, path, content, encrypt_func, max_size_bytes):
"""
Save a file.
TODO: Update-then-insert is probably cheaper than insert-then-update.
"""
content = preprocess_incoming_content(
content,
encrypt_func,
max_size_bytes,
)
directory, name = split_api_filepath(path)
with db.begin_nested() as savepoint:
try:
res = db.execute(
files.insert().values(
name=name,
user_id=user_id,
parent_name=directory,
content=content,
)
)
except IntegrityError as error:
# The file already exists, so overwrite its content with the newer
# version.
| python | {
"resource": ""
} |
q271231 | generate_files | test | def generate_files(engine, crypto_factory, min_dt=None, max_dt=None,
logger=None):
"""
Create a generator of decrypted files.
Files are yielded in ascending order of their timestamp.
This function selects all current notebooks (optionally, falling within a
datetime range), decrypts them, and returns a generator yielding dicts,
each containing a decoded notebook and metadata including the user,
filepath, and timestamp.
Parameters
----------
engine : SQLAlchemy.engine
Engine encapsulating database connections.
crypto_factory : function[str -> Any]
A function from user_id to an object providing the interface required
by PostgresContentsManager.crypto. Results of this will be used for
| python | {
"resource": ""
} |
q271232 | purge_remote_checkpoints | test | def purge_remote_checkpoints(db, user_id):
"""
Delete all database records for the given user_id.
"""
db.execute(
| python | {
"resource": ""
} |
q271233 | generate_checkpoints | test | def generate_checkpoints(engine, crypto_factory, min_dt=None, max_dt=None,
logger=None):
"""
Create a generator of decrypted remote checkpoints.
Checkpoints are yielded in ascending order of their timestamp.
This function selects all notebook checkpoints (optionally, falling within
a datetime range), decrypts them, and returns a generator yielding dicts,
each containing a decoded notebook and metadata including the user,
filepath, and timestamp.
Parameters
----------
engine : SQLAlchemy.engine
Engine encapsulating database connections.
crypto_factory : function[str -> Any]
A function from user_id to an object providing the interface required
by PostgresContentsManager.crypto. Results of this will be used for
| python | {
"resource": ""
} |
q271234 | _generate_notebooks | test | def _generate_notebooks(table, timestamp_column,
engine, crypto_factory, min_dt, max_dt, logger):
"""
See docstrings for `generate_files` and `generate_checkpoints`.
Parameters
----------
table : SQLAlchemy.Table
Table to fetch notebooks from, `files` or `remote_checkpoints.
timestamp_column : SQLAlchemy.Column
`table`'s column storing timestamps, `created_at` or `last_modified`.
engine : SQLAlchemy.engine
Engine encapsulating database connections.
crypto_factory : function[str -> Any]
A function from user_id to an object providing the interface required
by PostgresContentsManager.crypto. Results of this will be used for
decryption of the selected notebooks.
min_dt : datetime.datetime
Minimum last modified datetime at which a file will be included.
max_dt : datetime.datetime
Last modified datetime at and after which a file will be excluded.
logger : Logger
"""
where_conds = []
if min_dt is not None:
where_conds.append(timestamp_column >= min_dt)
if max_dt is not None:
where_conds.append(timestamp_column < max_dt)
if table is files:
# Only select files that are notebooks
where_conds.append(files.c.name.like(u'%.ipynb'))
# Query for notebooks satisfying the conditions.
query = select([table]).order_by(timestamp_column)
for cond in where_conds:
query = query.where(cond)
result = engine.execute(query)
# Decrypt each notebook and yield the result.
for nb_row in result:
try:
# The decrypt function depends on the user
| python | {
"resource": ""
} |
q271235 | reencrypt_row_content | test | def reencrypt_row_content(db,
table,
row_id,
decrypt_func,
encrypt_func,
logger):
"""
Re-encrypt a row from ``table`` with ``id`` of ``row_id``.
"""
q = (select([table.c.content])
.with_for_update()
.where(table.c.id == row_id))
| python | {
"resource": ""
} |
q271236 | reencrypt_user_content | test | def reencrypt_user_content(engine,
user_id,
old_decrypt_func,
new_encrypt_func,
logger):
"""
Re-encrypt all of the files and checkpoints for a single user.
"""
logger.info("Begin re-encryption for user %s", user_id)
with engine.begin() as db:
# NOTE: Doing both of these operations in one transaction depends for
# correctness on the fact that the creation of new checkpoints always
# involves writing new data into the database from Python, rather than
# simply copying data inside the DB.
# If we change checkpoint creation so that it does an in-database copy,
# then we need to split this transaction to ensure that
# file-reencryption is complete before checkpoint-reencryption starts.
# If that doesn't happen, it will be possible for a user to create a
# new checkpoint in a transaction that hasn't seen the completed
# file-reencryption process, but we might not see that checkpoint here,
# which means that we would never update the content of that checkpoint
# to the new encryption key.
logger.info("Re-encrypting files for %s", user_id)
for (file_id,) in select_file_ids(db, user_id):
| python | {
"resource": ""
} |
q271237 | derive_single_fernet_key | test | def derive_single_fernet_key(password, user_id):
"""
Convert a secret key and a user ID into an encryption key to use with a
``cryptography.fernet.Fernet``.
Taken from
https://cryptography.io/en/latest/fernet/#using-passwords-with-fernet
Parameters
----------
password : unicode
ascii-encodable key to derive
user_id : unicode
ascii-encodable user_id to use as salt
| python | {
"resource": ""
} |
q271238 | derive_fallback_fernet_keys | test | def derive_fallback_fernet_keys(passwords, user_id):
"""
Derive a list of per-user Fernet keys from a list of master keys and a
username.
If a None is encountered in ``passwords``, it is forwarded.
Parameters
----------
passwords : list[unicode]
List of ascii-encodable keys to derive.
user_id : unicode or None
| python | {
"resource": ""
} |
q271239 | single_password_crypto_factory | test | def single_password_crypto_factory(password):
"""
Create and return a function suitable for passing as a crypto_factory to
``pgcontents.utils.sync.reencrypt_all_users``
The factory here returns a | python | {
"resource": ""
} |
q271240 | memoize_single_arg | test | def memoize_single_arg(f):
"""
Decorator memoizing a single-argument function
"""
memo = {}
@wraps(f)
def memoized_f(arg):
try:
return memo[arg]
| python | {
"resource": ""
} |
q271241 | _get_name | test | def _get_name(column_like):
"""
Get the name from a column-like SQLAlchemy expression.
Works for Columns and Cast expressions.
"""
if isinstance(column_like, Column):
| python | {
"resource": ""
} |
q271242 | to_dict_no_content | test | def to_dict_no_content(fields, row):
"""
Convert a SQLAlchemy row that does not contain a 'content' field to a dict.
If row is None, return None.
Raises AssertionError if there is a field named 'content' in ``fields``.
"""
| python | {
"resource": ""
} |
q271243 | to_dict_with_content | test | def to_dict_with_content(fields, row, decrypt_func):
"""
Convert a SQLAlchemy row that contains a 'content' field to a dict.
``decrypt_func`` will be applied to the ``content`` field of the row.
If row is None, return None.
Raises AssertionError if there is no field named 'content' in ``fields``.
"""
assert(len(fields) == len(row))
field_names = list(map(_get_name, | python | {
"resource": ""
} |
q271244 | PostgresCheckpoints.create_notebook_checkpoint | test | def create_notebook_checkpoint(self, nb, path):
"""Create a checkpoint of the current state of a notebook
Returns a checkpoint_id for the new checkpoint.
"""
b64_content = writes_base64(nb)
with self.engine.begin() as db:
return save_remote_checkpoint(
| python | {
"resource": ""
} |
q271245 | PostgresCheckpoints.create_file_checkpoint | test | def create_file_checkpoint(self, content, format, path):
"""Create a checkpoint of the current state of a file
Returns a checkpoint_id for the new checkpoint.
"""
try:
b64_content = to_b64(content, format)
| python | {
"resource": ""
} |
q271246 | PostgresCheckpoints.delete_checkpoint | test | def delete_checkpoint(self, checkpoint_id, path):
"""delete a checkpoint for a file"""
with | python | {
"resource": ""
} |
q271247 | PostgresCheckpoints.get_checkpoint_content | test | def get_checkpoint_content(self, checkpoint_id, path):
"""Get the content of a checkpoint."""
with self.engine.begin() as db:
return get_remote_checkpoint(
db,
| python | {
"resource": ""
} |
q271248 | PostgresCheckpoints.list_checkpoints | test | def list_checkpoints(self, path):
"""Return a list of checkpoints for a given file"""
with self.engine.begin() as db:
| python | {
"resource": ""
} |
q271249 | PostgresCheckpoints.rename_all_checkpoints | test | def rename_all_checkpoints(self, old_path, new_path):
"""Rename all checkpoints for old_path to new_path."""
with self.engine.begin() as | python | {
"resource": ""
} |
q271250 | PostgresCheckpoints.delete_all_checkpoints | test | def delete_all_checkpoints(self, path):
"""Delete all checkpoints for the given | python | {
"resource": ""
} |
q271251 | PostgresCheckpoints.purge_db | test | def purge_db(self):
"""
Purge all database records for the current user.
"""
| python | {
"resource": ""
} |
q271252 | _resolve_path | test | def _resolve_path(path, manager_dict):
"""
Resolve a path based on a dictionary of manager prefixes.
Returns a triple of (prefix, manager, manager_relative_path).
"""
path = normalize_api_path(path)
parts = path.split('/')
# Try to find a sub-manager for the first subdirectory.
mgr = manager_dict.get(parts[0])
if mgr is not None:
return parts[0], mgr, '/'.join(parts[1:])
| python | {
"resource": ""
} |
q271253 | _apply_prefix | test | def _apply_prefix(prefix, model):
"""
Prefix all path entries in model with the given prefix.
"""
if not isinstance(model, dict):
raise TypeError("Expected dict for model, got %s" % type(model))
# We get unwanted leading/trailing slashes if prefix or model['path'] are
# '', both of which are legal values.
model['path'] = '/'.join((prefix, model['path'])).strip('/')
if model['type'] in ('notebook', 'file'):
| python | {
"resource": ""
} |
q271254 | path_dispatch1 | test | def path_dispatch1(mname, returns_model):
"""
Decorator for methods that accept path as a first argument.
"""
def _wrapper(self, *args, **kwargs):
path, args = _get_arg('path', args, kwargs)
prefix, mgr, mgr_path = _resolve_path(path, self.managers)
| python | {
"resource": ""
} |
q271255 | path_dispatch_kwarg | test | def path_dispatch_kwarg(mname, path_default, returns_model):
"""
Parameterized decorator for methods that accept path as a second
argument.
"""
def _wrapper(self, path=path_default, **kwargs):
prefix, mgr, mgr_path = _resolve_path(path, self.managers)
| python | {
"resource": ""
} |
q271256 | path_dispatch_old_new | test | def path_dispatch_old_new(mname, returns_model):
"""
Decorator for methods accepting old_path and new_path.
"""
def _wrapper(self, old_path, new_path, *args, **kwargs):
old_prefix, old_mgr, old_mgr_path = _resolve_path(
old_path, self.managers
)
new_prefix, new_mgr, new_mgr_path = _resolve_path(
new_path, self.managers,
)
if old_mgr is not new_mgr:
# TODO: Consider supporting this via get+delete+save.
raise HTTPError(
400,
"Can't move files between backends ({old} -> {new})".format(
old=old_path,
new=new_path,
)
) | python | {
"resource": ""
} |
q271257 | HybridContentsManager._managers_changed | test | def _managers_changed(self, name, old, new):
"""
Strip slashes from directories before updating.
"""
for key in new:
if '/' in key:
raise ValueError(
| python | {
"resource": ""
} |
q271258 | HybridContentsManager.get | test | def get(self, path, content=True, type=None, format=None):
"""
Special case handling for listing root dir.
"""
path = normalize_api_path(path)
if path:
return self.__get(path, content=content, type=type, format=format)
if not content:
return base_directory_model('')
extra_content = self._extra_root_dirs()
rm = self.root_manager
if rm is None:
root_model = base_directory_model('')
root_model.update(
format='json',
| python | {
"resource": ""
} |
q271259 | normalize_api_path | test | def normalize_api_path(api_path):
"""
Resolve paths with '..' to normalized paths, raising an error if the final
result is outside root.
"""
normalized = posixpath.normpath(api_path.strip('/'))
if normalized | python | {
"resource": ""
} |
q271260 | split_api_filepath | test | def split_api_filepath(path):
"""
Split an API file path into directory and name.
"""
parts = path.rsplit('/', 1)
if len(parts) == 1:
name = parts[0]
dirname = '/'
else: | python | {
"resource": ""
} |
q271261 | writes_base64 | test | def writes_base64(nb, version=NBFORMAT_VERSION):
"""
Write a notebook as base64.
""" | python | {
"resource": ""
} |
q271262 | reads_base64 | test | def reads_base64(nb, as_version=NBFORMAT_VERSION):
"""
Read a notebook from base64.
"""
| python | {
"resource": ""
} |
q271263 | _decode_unknown_from_base64 | test | def _decode_unknown_from_base64(path, bcontent):
"""
Decode base64 data of unknown format.
Attempts to interpret data as utf-8, falling back to | python | {
"resource": ""
} |
q271264 | from_b64 | test | def from_b64(path, bcontent, format):
"""
Decode base64 content for a file.
format:
If 'text', the contents will be decoded as UTF-8.
If 'base64', do nothing.
If not specified, try to decode as UTF-8, and fall back to base64
Returns a triple of decoded_content, format, and mimetype.
"""
decoders = {
'base64': lambda path, bcontent: (bcontent.decode('ascii'), 'base64'),
'text': _decode_text_from_base64,
None: _decode_unknown_from_base64,
}
try:
content, real_format = decoders[format](path, bcontent)
except HTTPError:
# Pass through HTTPErrors, since we intend for them to bubble all the
# way back to | python | {
"resource": ""
} |
q271265 | prefix_dirs | test | def prefix_dirs(path):
"""
Return an iterable of all prefix directories of path, descending from root.
"""
_dirname = posixpath.dirname
path = path.strip('/')
| python | {
"resource": ""
} |
q271266 | outside_root_to_404 | test | def outside_root_to_404(fn):
"""
Decorator for converting PathOutsideRoot errors to 404s.
"""
@wraps(fn)
def wrapped(*args, **kwargs):
| python | {
"resource": ""
} |
q271267 | create_user | test | def create_user(db_url, user):
"""
Create a user.
"""
PostgresCheckpoints(
| python | {
"resource": ""
} |
q271268 | _separate_dirs_files | test | def _separate_dirs_files(models):
"""
Split an iterable of models into a list of file paths and a list of
directory paths.
"""
dirs = []
files = []
for model in models:
if model['type'] == 'directory':
| python | {
"resource": ""
} |
q271269 | walk_dirs | test | def walk_dirs(mgr, dirs):
"""
Recursive helper for walk.
"""
for directory in dirs:
children = mgr.get(
directory,
content=True,
type='directory',
)['content']
dirs, files = map(sorted, _separate_dirs_files(children))
| python | {
"resource": ""
} |
q271270 | walk_files | test | def walk_files(mgr):
"""
Iterate over all files visible to ``mgr``.
"""
| python | {
"resource": ""
} |
q271271 | walk_files_with_content | test | def walk_files_with_content(mgr):
"""
Iterate over the contents of all files visible to ``mgr``.
"""
for _, _, files in walk(mgr):
| python | {
"resource": ""
} |
q271272 | reencrypt_all_users | test | def reencrypt_all_users(engine,
old_crypto_factory,
new_crypto_factory,
logger):
"""
Re-encrypt data for all users.
This function is idempotent, meaning that it should be possible to apply
the same re-encryption process multiple times without having any effect on
the database. Idempotency is achieved by first attempting to decrypt with
the old crypto and falling back to the new crypto on failure.
An important consequence of this strategy is that **decrypting** a database
is not supported with this function, because ``NoEncryption.decrypt``
always succeeds. To decrypt an already-encrypted database, use
``unencrypt_all_users`` instead.
It is, however, possible to perform an initial encryption of a database by
passing a function returning a ``NoEncryption`` as ``old_crypto_factory``.
Parameters
----------
engine : SQLAlchemy.engine
Engine encapsulating database connections.
old_crypto_factory : function[str -> Any]
A function from user_id to an object providing the interface required
by PostgresContentsManager.crypto. Results of this will be used for
decryption of existing database content.
new_crypto_factory : function[str -> Any]
A function from user_id to an object providing the interface required
by PostgresContentsManager.crypto. Results of this will be used for
re-encryption | python | {
"resource": ""
} |
q271273 | reencrypt_single_user | test | def reencrypt_single_user(engine, user_id, old_crypto, new_crypto, logger):
"""
Re-encrypt all files and checkpoints for a single user.
"""
# Use FallbackCrypto so that we're re-entrant if we halt partway through.
crypto = FallbackCrypto([new_crypto, old_crypto])
| python | {
"resource": ""
} |
q271274 | unencrypt_all_users | test | def unencrypt_all_users(engine, old_crypto_factory, logger):
"""
Unencrypt data for all users.
Parameters
----------
engine : SQLAlchemy.engine
Engine encapsulating database connections.
old_crypto_factory : function[str -> Any]
A function from user_id to an object providing the interface required
by PostgresContentsManager.crypto. Results of this will be used for
decryption of existing database content.
logger : logging.Logger, optional
| python | {
"resource": ""
} |
q271275 | unencrypt_single_user | test | def unencrypt_single_user(engine, user_id, old_crypto, logger):
"""
Unencrypt all files and checkpoints for a single user.
"""
reencrypt_user_content(
engine=engine,
user_id=user_id,
| python | {
"resource": ""
} |
q271276 | temp_alembic_ini | test | def temp_alembic_ini(alembic_dir_location, sqlalchemy_url):
"""
Temporarily write an alembic.ini file for use with alembic migration
scripts.
"""
with TemporaryDirectory() as tempdir:
alembic_ini_filename = join(tempdir, 'temp_alembic.ini')
with open(alembic_ini_filename, 'w') as f:
f.write(
| python | {
"resource": ""
} |
q271277 | upgrade | test | def upgrade(db_url, revision):
"""
Upgrade the given database to revision.
"""
with temp_alembic_ini(ALEMBIC_DIR_LOCATION, db_url) as alembic_ini:
| python | {
"resource": ""
} |
q271278 | ContentSerializer.sanitize_block | test | def sanitize_block(self, block):
"""Santizes the data for the given block.
If block has a matching embed serializer, use the `to_internal_value` method."""
embed_type = block.get('type', None)
data = block.get('data', {})
| python | {
"resource": ""
} |
q271279 | ContentSerializer.queue_instance | test | def queue_instance(self, embed_type, data):
"""Queue an instance to be fetched from the database."""
serializer = self.serializers.get(embed_type, None)
if serializer is None:
return
| python | {
"resource": ""
} |
q271280 | ContentSerializer.load_instances | test | def load_instances(self, embed_type, ids):
"""Fetch all queued instances of type `embed_type`, save results
to `self.instances`"""
serializer = self.serializers.get(embed_type, None)
| python | {
"resource": ""
} |
q271281 | ContentSerializer.insert_instance | test | def insert_instance(self, block):
"""Insert a fetched instance into embed block."""
embed_type = block.get('type', None)
data = block.get('data', {})
serializer = self.serializers.get(embed_type, None)
| python | {
"resource": ""
} |
q271282 | ContentSerializer.load_data | test | def load_data(self):
"""Load data in bulk for each embed block."""
for embed_type in self.ids.keys():
| python | {
"resource": ""
} |
q271283 | ZoneSerializer.validate | test | def validate(self, data):
"""Perform validation of the widget data"""
from dispatch.theme import ThemeManager
errors = {}
if data.get('widget') is not None:
try:
widget = ThemeManager.Widgets.get(data['widget'])
except WidgetNotFound as e:
errors['widget'] = str(e)
else:
for field in widget.fields:
field_data = data['data'].get(field.name)
if field_data is not None:
try:
field.validate(field_data)
| python | {
"resource": ""
} |
q271284 | admin | test | def admin(request):
"""Render HTML entry point for manager app."""
context = {
'api_url': settings.API_URL,
'app_js_bundle': 'manager-%s.js' % dispatch.__version__,
| python | {
"resource": ""
} |
q271285 | Template.to_json | test | def to_json(self):
"""Return JSON representation for this template"""
result = {}
for field in self.fields:
| python | {
"resource": ""
} |
q271286 | DispatchModelSerializer.hide_authenticated_fields | test | def hide_authenticated_fields(self):
"""Hides authenticated_fields if request context is missing or
user is not authenticated"""
authenticated_fields = getattr(self.Meta, 'authenticated_fields', [])
| python | {
"resource": ""
} |
q271287 | DispatchModelSerializer.exclude_fields | test | def exclude_fields(self):
"""Excludes fields that are included in the queryparameters"""
request = self.context.get('request')
if request:
exclude = request.query_params.get('exclude', None)
if exclude is None: return
| python | {
"resource": ""
} |
q271288 | PublishableManager.get | test | def get(self, *args, **kwargs):
"""Get the latest article with the given primary key."""
if 'pk' in kwargs:
kwargs['parent'] = kwargs['pk']
kwargs['head'] = True
del kwargs['pk']
"""If the url requested includes the querystring parameters 'version' and 'preview_id',
get the article with the specified version and preview_id.
Otherwise, get the published version of the article.
"""
if 'request' in kwargs:
request = kwargs['request']
version = request.GET.get('version', None)
| python | {
"resource": ""
} |
q271289 | ArticleViewSet.get_queryset | test | def get_queryset(self):
"""Optionally restricts the returned articles by filtering against a `topic`
query parameter in the URL."""
# Get base queryset from DispatchPublishableMixin
queryset = self.get_publishable_queryset()
# Optimize queries by prefetching related data
queryset = queryset \
.select_related('featured_image', 'featured_video', 'topic', 'section', 'subsection') \
.prefetch_related(
'tags',
'featured_image__image__authors',
'authors'
)
queryset = queryset.order_by('-updated_at')
q = self.request.query_params.get('q', None)
section = self.request.query_params.get('section', None)
| python | {
"resource": ""
} |
q271290 | PageViewSet.get_queryset | test | def get_queryset(self):
"""Only display unpublished content to authenticated users, filter by
query parameter if present."""
# Get base queryset from DispatchPublishableMixin
queryset = self.get_publishable_queryset()
queryset = queryset.order_by('-updated_at')
# Optionally filter by | python | {
"resource": ""
} |
q271291 | NullBooleanField.get_attribute | test | def get_attribute(self, instance):
"""Overrides the default get_attribute method to convert None | python | {
"resource": ""
} |
q271292 | validate_widget | test | def validate_widget(widget):
"""Checks that the given widget contains the required fields"""
if not has_valid_id(widget):
raise InvalidWidget("%s must contain a valid 'id' attribute" % widget.__name__)
if not has_valid_name(widget):
raise InvalidWidget("%s must contain a valid 'name' attribute" % widget.__name__)
if not has_valid_template(widget):
raise InvalidWidget("%s | python | {
"resource": ""
} |
q271293 | validate_zone | test | def validate_zone(zone):
"""Checks that the given zone contains the required fields"""
if not has_valid_id(zone):
raise | python | {
"resource": ""
} |
q271294 | is_valid_uuid | test | def is_valid_uuid(id):
"""Return True if id is a valid UUID, False otherwise."""
if not isinstance(id, basestring):
return False
try:
| python | {
"resource": ""
} |
q271295 | User.get_permissions | test | def get_permissions(self):
"""Returns the user's permissions."""
permissions = ''
| python | {
"resource": ""
} |
q271296 | User.modify_permissions | test | def modify_permissions(self, permissions):
"""Modify the user's permissions."""
group = Group.objects.get(name='Admin')
if permissions == 'admin':
| python | {
"resource": ""
} |
q271297 | AuthorValidator | test | def AuthorValidator(data):
"""Raise a ValidationError if data does not match the author format."""
if not isinstance(data, list):
# Convert single instance to a list
data = [data]
for author in data:
if 'person' not in author:
raise ValidationError('An author must contain a person.')
| python | {
"resource": ""
} |
q271298 | Zone.save | test | def save(self, validated_data):
"""Save widget data for this zone."""
(zone, created) = ZoneModel.objects.get_or_create(zone_id=self.id)
zone.widget_id = validated_data['widget']
zone.data = validated_data['data']
# Call widget before-save hook on nested widgets
for key in list(zone.data.keys()):
if isinstance(zone.data[key], dict) and ('id' in zone.data[key].keys()) and | python | {
"resource": ""
} |
q271299 | Widget.get_data | test | def get_data(self):
"""Returns data from each field."""
result = {}
for field in self.fields:
| python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.