Search is not available for this dataset
text stringlengths 75 104k |
|---|
async def monitor_status(self, alarm_status_callback=None,
zone_changed_callback=None,
output_changed_callback=None):
"""Start monitoring of the alarm status.
Send command to satel integra to start sending updates. Read in a
loop and cal... |
def close(self):
"""Stop monitoring and close connection."""
_LOGGER.debug("Closing...")
self.closed = True
if self.connected:
self._writer.close() |
def purge_db(self):
"""
Clear all matching our user_id.
"""
with self.engine.begin() as db:
purge_user(db, self.user_id) |
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'):
return 'notebook'
elif allow_directory and self.d... |
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:
try:
file_id = get_file_id(db, self.user_id, p... |
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,
content,
... |
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'] = reco... |
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:
... |
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=Fals... |
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(
cha... |
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'] ... |
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,
w... |
def _save_file(self, db, model, path):
"""
Save a non-notebook file.
"""
save_file(
db,
self.user_id,
path,
to_b64(model['content'], model.get('format', None)),
self.crypto.encrypt,
self.max_file_size_bytes,
... |
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(... |
def delete_file(self, path):
"""
Delete object corresponding to path.
"""
if self.file_exists(path):
self._delete_non_directory(path)
elif self.dir_exists(path):
self._delete_directory(path)
else:
self.no_such_entity(path) |
def preprocess_incoming_content(content, encrypt_func, max_size_bytes):
"""
Apply preprocessing steps to file/notebook content that we're going to
write to the database.
Applies ``encrypt_func`` to ``content`` and checks that the result is
smaller than ``max_size_bytes``.
"""
encrypted = en... |
def ensure_db_user(db, user_id):
"""
Add a new user if they don't already exist.
"""
with ignore_unique_violation():
db.execute(
users.insert().values(id=user_id),
) |
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(
directories.c.user_id == user_id
))
db.execute(users.delete().where(
users.c.id == ... |
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]... |
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.
"""
return and_(
table.c.parent_name == db_dirname,
table.c.user_id == user_id,
... |
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.nam... |
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(
and_(
directories.c.user_id == user_id,
... |
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,
... |
def directories_in_directory(db, user_id, db_dirname):
"""
Return subdirectories of a directory.
"""
fields = _directory_default_fields()
rows = db.execute(
select(
fields,
).where(
_is_in_directory(directories, user_id, db_dirname),
)
)
return... |
def get_directory(db, user_id, api_dirname, content):
"""
Return the names of all files/directories that are direct children of
api_dirname.
If content is False, return a bare model containing just a database-style
name.
"""
db_dirname = from_api_dirname(api_dirname)
if not _dir_exists(... |
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_(
files.c.name == name,
files.c.user_id == user_id,
files.c.parent_name == directory,
) |
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),
).order_by(
_file_creation_order(),
)
if limit is not None:
query = query.... |
def _file_default_fields():
"""
Default fields returned by a file query.
"""
return [
files.c.name,
files.c.created_at,
files.c.parent_name,
] |
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_... |
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()
if include_content:
query_fields.append(files.c.content)
return _get_file(db... |
def get_file_id(db, user_id, api_path):
"""
Get the value in the 'id' column for the file with the given
user_id and path.
"""
return _get_file(
db,
user_id,
api_path,
[files.c.id],
unused_decrypt_func,
)['id'] |
def delete_file(db, user_id, api_path):
"""
Delete a file.
TODO: Consider making this a soft delete.
"""
result = db.execute(
files.delete().where(
_file_where(user_id, api_path)
)
)
rowcount = result.rowcount
if not rowcount:
raise NoSuchFile(api_pa... |
def file_exists(db, user_id, path):
"""
Check if a file exists.
"""
try:
get_file(
db,
user_id,
path,
include_content=False,
decrypt_func=unused_decrypt_func,
)
return True
except NoSuchFile:
return False |
def rename_file(db, user_id, old_api_path, new_api_path):
"""
Rename a file.
"""
# Overwriting existing files is disallowed.
if file_exists(db, user_id, new_api_path):
raise FileExists(new_api_path)
old_dir, old_name = split_api_filepath(old_api_path)
new_dir, new_name = split_api_... |
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.')
# Overwritin... |
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... |
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), decry... |
def purge_remote_checkpoints(db, user_id):
"""
Delete all database records for the given user_id.
"""
db.execute(
remote_checkpoints.delete().where(
remote_checkpoints.c.user_id == user_id,
)
) |
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 w... |
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_chec... |
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.cont... |
def select_file_ids(db, user_id):
"""
Get all file ids for a user.
"""
return list(
db.execute(
select([files.c.id])
.where(files.c.user_id == user_id)
)
) |
def select_remote_checkpoint_ids(db, user_id):
"""
Get all file ids for a user.
"""
return list(
db.execute(
select([remote_checkpoints.c.id])
.where(remote_checkpoints.c.user_id == user_id)
)
) |
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... |
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
... |
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 deri... |
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 ``FernetEncryption`` that uses a key derived
from ``password`` and salted with the supplied user_id.
... |
def memoize_single_arg(f):
"""
Decorator memoizing a single-argument function
"""
memo = {}
@wraps(f)
def memoized_f(arg):
try:
return memo[arg]
except KeyError:
result = memo[arg] = f(arg)
return result
return memoized_f |
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):
return column_like.name
elif isinstance(column_like, Cast):
return column_like.clause.name |
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``.
"""
assert(len(fields) == len(row))
field_names = list(map(_get_name, ... |
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``.... |
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(
... |
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)
except ValueError as e:
self.do_400(str(e))
... |
def delete_checkpoint(self, checkpoint_id, path):
"""delete a checkpoint for a file"""
with self.engine.begin() as db:
return delete_single_remote_checkpoint(
db, self.user_id, path, checkpoint_id,
) |
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,
self.user_id,
path,
checkpoint_id,
self.crypto.decry... |
def list_checkpoints(self, path):
"""Return a list of checkpoints for a given file"""
with self.engine.begin() as db:
return list_remote_checkpoints(db, self.user_id, path) |
def rename_all_checkpoints(self, old_path, new_path):
"""Rename all checkpoints for old_path to new_path."""
with self.engine.begin() as db:
return move_remote_checkpoints(
db,
self.user_id,
old_path,
new_path,
) |
def delete_all_checkpoints(self, path):
"""Delete all checkpoints for the given path."""
with self.engine.begin() as db:
delete_remote_checkpoints(db, self.user_id, path) |
def purge_db(self):
"""
Purge all database records for the current user.
"""
with self.engine.begin() as db:
purge_remote_checkpoints(db, self.user_id) |
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 = m... |
def _get_arg(argname, args, kwargs):
"""
Get an argument, either from kwargs or from the first entry in args.
Raises a TypeError if argname not in kwargs and len(args) == 0.
Mutates kwargs in place if the value is found in kwargs.
"""
try:
return kwargs.pop(argname), args
except Key... |
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 whic... |
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)
result = getattr(mgr, mname)(m... |
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)
result = getattr(mgr, mname)(pat... |
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, n... |
def _managers_changed(self, name, old, new):
"""
Strip slashes from directories before updating.
"""
for key in new:
if '/' in key:
raise ValueError(
"Expected directory names w/o slashes. Got [%s]" % key
)
self... |
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_d... |
def delete(self, path):
"""
Ensure that roots of our managers can't be deleted. This should be
enforced by https://github.com/ipython/ipython/pull/8168, but rogue
implementations might override this behavior.
"""
path = normalize_api_path(path)
if path in self.ma... |
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 == '.':
normalized = ''
elif normalized.startswith('..'):
raise Path... |
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:
name = parts[1]
dirname = parts[0] + '/'
return from_api_dirname(dirname), name |
def writes_base64(nb, version=NBFORMAT_VERSION):
"""
Write a notebook as base64.
"""
return b64encode(writes(nb, version=version).encode('utf-8')) |
def reads_base64(nb, as_version=NBFORMAT_VERSION):
"""
Read a notebook from base64.
"""
try:
return reads(b64decode(nb).decode('utf-8'), as_version=as_version)
except Exception as e:
raise CorruptedFile(e) |
def _decode_unknown_from_base64(path, bcontent):
"""
Decode base64 data of unknown format.
Attempts to interpret data as utf-8, falling back to ascii on failure.
"""
content = b64decode(bcontent)
try:
return (content.decode('utf-8'), 'text')
except UnicodeError:
pass
ret... |
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.
... |
def prefix_dirs(path):
"""
Return an iterable of all prefix directories of path, descending from root.
"""
_dirname = posixpath.dirname
path = path.strip('/')
out = []
while path != '':
path = _dirname(path)
out.append(path)
return reversed(out) |
def outside_root_to_404(fn):
"""
Decorator for converting PathOutsideRoot errors to 404s.
"""
@wraps(fn)
def wrapped(*args, **kwargs):
try:
return fn(*args, **kwargs)
except PathOutsideRoot as e:
raise HTTPError(404, "Path outside root: [%s]" % e.args[0])
... |
def create_user(db_url, user):
"""
Create a user.
"""
PostgresCheckpoints(
db_url=db_url,
user_id=user,
create_user_on_startup=True,
) |
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':
dirs.append(model['path'])
else:
files.append(mode... |
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))
yield directory, d... |
def walk_files(mgr):
"""
Iterate over all files visible to ``mgr``.
"""
for dir_, subdirs, files in walk_files(mgr):
for file_ in files:
yield file_ |
def walk_files_with_content(mgr):
"""
Iterate over the contents of all files visible to ``mgr``.
"""
for _, _, files in walk(mgr):
for f in files:
yield mgr.get(f, content=True) |
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 ti... |
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])
reencrypt_user_content(
... |
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... |
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,
old_decrypt_func=old_crypto.decrypt,
new_encrypt_func=lambda s: s,
logger=logger,... |
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:
... |
def upgrade(db_url, revision):
"""
Upgrade the given database to revision.
"""
with temp_alembic_ini(ALEMBIC_DIR_LOCATION, db_url) as alembic_ini:
subprocess.check_call(
['alembic', '-c', alembic_ini, 'upgrade', revision]
) |
def get_author_string(self, links=False):
saved_args = locals()
saved_args = saved_args['links']
"""Returns list of authors as a comma-separated
string (with 'and' before last author)."""
def format_author(author):
if links and author.person.slug:
ret... |
def get_author_type_string(self):
"""Returns list of authors as a comma-separated string
sorted by author type (with 'and' before last author)."""
authorTypeString = ''
aStringA = ''
aStringB = ''
aStringC = ''
aStringD = ''
authors = dict((k, list(v)) f... |
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', {})
serializer = self.serializers.get(embed_type, None)
... |
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
instance_id = serializer.get_id(data)
if embed_type not in self.ids:
... |
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)
if serializer is None:
return
self.instances[embed_type] = serializer.fetch(ids) |
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)
if serializer is None:
return block
try:
in... |
def load_data(self):
"""Load data in bulk for each embed block."""
for embed_type in self.ids.keys():
self.load_instances(embed_type, self.ids[embed_type]) |
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:
... |
def admin(request):
"""Render HTML entry point for manager app."""
context = {
'api_url': settings.API_URL,
'app_js_bundle': 'manager-%s.js' % dispatch.__version__,
'app_css_bundle': 'manager-%s.css' % dispatch.__version__
}
return render_to_response('manager/index.html', co... |
def to_json(self):
"""Return JSON representation for this template"""
result = {}
for field in self.fields:
result[field.name] = field.to_json(self.data.get(field.name))
return result |
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', [])
if not self.is_authenticated():
for field in authenticated_fields:
... |
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
excluded_fields = exclude... |
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 'previ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.