_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q260900 | Registry.get_providers | validation | def get_providers(self, **kwargs):
'''Get all providers registered.
If keyword `ids` is present, get only the providers with these ids.
If keys `subject` is present, get only the providers that have this subject.
.. code-block:: python
# Get all providers with subject 'biology'
registry.get_providers(subject='biology')
# Get all providers with id 1 or 2
registry.get_providers(ids=[1,2])
# Get all providers with id 1 or 2 and subject 'biology'
registry.get_providers(ids=[1,2], subject='biology']
:param list ids: Only return providers with one of the Ids or :term:`URIs <uri>`.
:param str subject: Only return providers with this subject.
:returns: A list of :class:`providers <skosprovider.providers.VocabularyProvider>`
| python | {
"resource": ""
} |
q260901 | Registry.find | validation | def find(self, query, **kwargs):
'''Launch a query across all or a selection of providers.
.. code-block:: python
# Find anything that has a label of church in any provider.
registry.find({'label': 'church'})
# Find anything that has a label of church with the BUILDINGS provider.
# Attention, this syntax was deprecated in version 0.3.0
registry.find({'label': 'church'}, providers=['BUILDINGS'])
# Find anything that has a label of church with the BUILDINGS provider.
registry.find({'label': 'church'}, providers={'ids': ['BUILDINGS']})
# Find anything that has a label of church with a provider
# marked with the subject 'architecture'.
registry.find({'label': 'church'}, providers={'subject': 'architecture'})
# Find anything that has a label of church in any provider.
# If possible, display the results with a Dutch label.
registry.find({'label': 'church'}, language='nl')
:param dict query: The query parameters that will be passed on to each
:meth:`~skosprovider.providers.VocabularyProvider.find` method of
the selected.
:class:`providers <skosprovider.providers.VocabularyProvider>`.
:param dict providers: Optional. If present, it should be a dictionary.
This dictionary can contain any of the keyword arguments available
to the :meth:`get_providers` method. The query will then only
be passed to the providers | python | {
"resource": ""
} |
q260902 | Registry.get_all | validation | def get_all(self, **kwargs):
'''Get all concepts from all providers.
.. code-block:: python
# get all concepts in all providers.
registry.get_all()
# get all concepts in all providers.
# If possible, display the results with a Dutch label.
registry.get_all(language='nl')
:param string language: Optional. If present, it should be a
:term:`language-tag`. This language-tag is passed on to the
underlying providers and used when selecting the label to display
for each concept.
| python | {
"resource": ""
} |
q260903 | Registry.get_by_uri | validation | def get_by_uri(self, uri):
'''Get a concept or collection by its uri.
Returns a single concept or collection if one exists with this uri.
Returns False otherwise.
:param string uri: The uri to find a concept or collection for.
:raises ValueError: The uri is invalid.
:rtype: :class:`skosprovider.skos.Concept` or
:class:`skosprovider.skos.Collection`
'''
if not is_uri(uri):
raise ValueError('%s is not a valid URI.' % uri)
# Check if there's a provider that's more likely to have the URI
csuris = [csuri | python | {
"resource": ""
} |
q260904 | upload_backend | validation | def upload_backend(index='dev', user=None):
"""
Build the backend and upload it to the remote server at the given index
"""
get_vars()
| python | {
"resource": ""
} |
q260905 | update_backend | validation | def update_backend(use_pypi=False, index='dev', build=True, user=None, version=None):
"""
Install the backend from the given devpi index at the given version on the target host and restart the service.
If version is None, it defaults to the latest version
Optionally, build and upload the application first from local sources. This requires a
full backend development environment on the machine running this command (pyramid etc.)
"""
get_vars()
if value_asbool(build):
upload_backend(index=index, user=user)
with fab.cd('{apphome}'.format(**AV)):
if value_asbool(use_pypi):
command = 'bin/pip install --upgrade briefkasten'
else: | python | {
"resource": ""
} |
q260906 | VocabularyProvider._sort | validation | def _sort(self, concepts, sort=None, language='any', reverse=False):
'''
Returns a sorted version of a list of concepts. Will leave the original
list unsorted.
:param list concepts: A list of concepts and collections.
:param string sort: What to sort on: `id`, `label` or `sortlabel`
:param string language: Language to use when sorting on `label` or
| python | {
"resource": ""
} |
q260907 | Client.update | validation | async def update(self) -> None:
"""Force update of alarm status and zones"""
_LOGGER.debug("Requesting state update from server (S00, S14)")
await asyncio.gather(
# List unsealed Zones
| python | {
"resource": ""
} |
q260908 | Client._update_loop | validation | async def _update_loop(self) -> None:
"""Schedule a state update to keep the connection alive"""
await asyncio.sleep(self._update_interval)
while not self._closed:
| python | {
"resource": ""
} |
q260909 | BELNamespaceManagerMixin._iterate_namespace_models | validation | def _iterate_namespace_models(self, **kwargs) -> Iterable:
"""Return an iterator over the models to be converted to the namespace."""
return tqdm(
| python | {
"resource": ""
} |
q260910 | BELNamespaceManagerMixin._get_default_namespace | validation | def _get_default_namespace(self) -> Optional[Namespace]:
"""Get the reference BEL namespace if it exists."""
| python | {
"resource": ""
} |
q260911 | BELNamespaceManagerMixin._make_namespace | validation | def _make_namespace(self) -> Namespace:
"""Make a namespace."""
namespace = Namespace(
name=self._get_namespace_name(),
keyword=self._get_namespace_keyword(),
url=self._get_namespace_url(),
version=str(time.asctime()),
)
self.session.add(namespace)
| python | {
"resource": ""
} |
q260912 | BELNamespaceManagerMixin._get_old_entry_identifiers | validation | def _get_old_entry_identifiers(namespace: Namespace) -> Set[NamespaceEntry]:
"""Convert a PyBEL generalized namespace entries to a set.
Default to using the identifier, but can be overridden to use the name | python | {
"resource": ""
} |
q260913 | BELNamespaceManagerMixin._update_namespace | validation | def _update_namespace(self, namespace: Namespace) -> None:
"""Update an already-created namespace.
Note: Only call this if namespace won't be none!
"""
old_entry_identifiers = self._get_old_entry_identifiers(namespace)
new_count = 0
skip_count = 0
for model in self._iterate_namespace_models():
if self._get_identifier(model) in old_entry_identifiers:
continue
entry = self._create_namespace_entry_from_model(model, namespace=namespace)
if entry is None or entry.name is None:
skip_count | python | {
"resource": ""
} |
q260914 | BELNamespaceManagerMixin.add_namespace_to_graph | validation | def add_namespace_to_graph(self, graph: BELGraph) -> Namespace:
"""Add this manager's namespace to the graph."""
namespace = self.upload_bel_namespace()
graph.namespace_url[namespace.keyword] = namespace.url
| python | {
"resource": ""
} |
q260915 | BELNamespaceManagerMixin._add_annotation_to_graph | validation | def _add_annotation_to_graph(self, graph: BELGraph) -> None:
"""Add this manager as an annotation to the graph."""
if 'bio2bel' not in graph.annotation_list:
| python | {
"resource": ""
} |
q260916 | BELNamespaceManagerMixin.upload_bel_namespace | validation | def upload_bel_namespace(self, update: bool = False) -> Namespace:
"""Upload the namespace to the PyBEL database.
:param update: Should the namespace be updated first?
"""
if not self.is_populated():
self.populate()
namespace = self._get_default_namespace()
if namespace | python | {
"resource": ""
} |
q260917 | BELNamespaceManagerMixin.drop_bel_namespace | validation | def drop_bel_namespace(self) -> Optional[Namespace]:
"""Remove the default namespace if it exists."""
namespace = self._get_default_namespace()
if namespace is not None:
| python | {
"resource": ""
} |
q260918 | BELNamespaceManagerMixin.write_bel_namespace | validation | def write_bel_namespace(self, file: TextIO, use_names: bool = False) -> None:
"""Write as a BEL namespace file."""
if not self.is_populated():
self.populate()
if use_names and not self.has_names:
raise ValueError
values = (
self._get_namespace_name_to_encoding(desc='writing names')
if use_names else
self._get_namespace_identifier_to_encoding(desc='writing identifiers')
| python | {
"resource": ""
} |
q260919 | BELNamespaceManagerMixin.write_bel_annotation | validation | def write_bel_annotation(self, file: TextIO) -> None:
"""Write as a BEL annotation file."""
if not self.is_populated():
self.populate()
values = self._get_namespace_name_to_encoding(desc='writing names')
write_annotation(
| python | {
"resource": ""
} |
q260920 | BELNamespaceManagerMixin.write_bel_namespace_mappings | validation | def write_bel_namespace_mappings(self, file: TextIO, **kwargs) -> None:
"""Write a BEL namespace mapping file."""
| python | {
"resource": ""
} |
q260921 | BELNamespaceManagerMixin.write_directory | validation | def write_directory(self, directory: str) -> bool:
"""Write a BEL namespace for identifiers, names, name hash, and mappings to the given directory."""
current_md5_hash = self.get_namespace_hash()
md5_hash_path = os.path.join(directory, f'{self.module_name}.belns.md5')
if not os.path.exists(md5_hash_path):
old_md5_hash = None
else:
with open(md5_hash_path) as file:
old_md5_hash = file.read().strip()
if old_md5_hash == current_md5_hash:
return False
with open(os.path.join(directory, f'{self.module_name}.belns'), 'w') as file:
self.write_bel_namespace(file, use_names=False)
with open(md5_hash_path, 'w') as file:
| python | {
"resource": ""
} |
q260922 | BELNamespaceManagerMixin.get_namespace_hash | validation | def get_namespace_hash(self, hash_fn=hashlib.md5) -> str:
"""Get the namespace hash.
Defaults to MD5.
"""
m = hash_fn()
if self.has_names:
items = self._get_namespace_name_to_encoding(desc='getting hash').items()
else:
| python | {
"resource": ""
} |
q260923 | get_long_description | validation | def get_long_description():
"""Get the long_description from the README.rst file. Assume UTF-8 encoding.""" | python | {
"resource": ""
} |
q260924 | dropbox_post_factory | validation | def dropbox_post_factory(request):
"""receives a UUID via the request and returns either a fresh or an existing dropbox
for it"""
try:
max_age = int(request.registry.settings.get('post_token_max_age_seconds'))
except Exception:
max_age = 300
try:
drop_id = parse_post_token(
token=request.matchdict['token'],
secret=request.registry.settings['post_secret'],
max_age=max_age)
except SignatureExpired:
| python | {
"resource": ""
} |
q260925 | dropbox_factory | validation | def dropbox_factory(request):
""" expects the id of an existing dropbox and returns its instance"""
try:
| python | {
"resource": ""
} |
q260926 | dropbox_editor_factory | validation | def dropbox_editor_factory(request):
""" this factory also requires the editor token"""
dropbox = dropbox_factory(request)
| python | {
"resource": ""
} |
q260927 | sanitize_filename | validation | def sanitize_filename(filename):
"""preserve the file ending, but replace the name with a random token """
# TODO: fix broken splitext (it reveals everything of the filename after the first `.` - doh!)
token = generate_drop_id()
| python | {
"resource": ""
} |
q260928 | Dropbox.cleanup | validation | def cleanup(self):
""" ensures that no data leaks from drop after processing by
removing all data except the status file"""
try:
remove(join(self.fs_path, u'message'))
remove(join(self.fs_path, 'dirty.zip.pgp'))
except OSError:
| python | {
"resource": ""
} |
q260929 | Dropbox._create_encrypted_zip | validation | def _create_encrypted_zip(self, source='dirty', fs_target_dir=None):
""" creates a zip file from the drop and encrypts it to the editors.
the encrypted archive is created inside fs_target_dir"""
backup_recipients = [r for r in self.editors if checkRecipient(self.gpg_context, r)]
# this will be handled by watchdog, no need to send for each drop
if not backup_recipients:
self.status = u'500 no valid keys at all'
return self.status
# calculate paths
fs_backup = join(self.fs_path, '%s.zip' % source)
if fs_target_dir is None:
fs_backup_pgp = join(self.fs_path, '%s.zip.pgp' % source)
| python | {
"resource": ""
} |
q260930 | Dropbox._create_archive | validation | def _create_archive(self):
""" creates an encrypted archive of the dropbox outside of the drop directory.
"""
self.status = u'270 creating final encrypted backup of cleansed attachments'
| python | {
"resource": ""
} |
q260931 | Dropbox.size_attachments | validation | def size_attachments(self):
"""returns the number of bytes that the cleansed attachments take up on disk"""
total_size = 0
| python | {
"resource": ""
} |
q260932 | Dropbox.replies | validation | def replies(self):
""" returns a list of strings """
fs_reply_path = join(self.fs_replies_path, 'message_001.txt')
if exists(fs_reply_path):
| python | {
"resource": ""
} |
q260933 | Dropbox.message | validation | def message(self):
""" returns the user submitted text
"""
try:
with open(join(self.fs_path, u'message')) as message_file:
| python | {
"resource": ""
} |
q260934 | Dropbox.fs_dirty_attachments | validation | def fs_dirty_attachments(self):
""" returns a list of absolute paths to the attachements"""
if exists(self.fs_attachment_container):
return [join(self.fs_attachment_container, attachment)
| python | {
"resource": ""
} |
q260935 | Dropbox.fs_cleansed_attachments | validation | def fs_cleansed_attachments(self):
""" returns a list of absolute paths to the cleansed attachements"""
if exists(self.fs_cleansed_attachment_container):
return [join(self.fs_cleansed_attachment_container, attachment)
| python | {
"resource": ""
} |
q260936 | reset_cleansers | validation | def reset_cleansers(confirm=True):
"""destroys all cleanser slaves and their rollback snapshots, as well as the initial master
snapshot - this allows re-running the jailhost deployment to recreate fresh cleansers."""
if value_asbool(confirm) and not yesno("""\nObacht!
This will destroy any existing and or currently running cleanser jails.
Are you sure that you want to continue?"""):
exit("Glad I asked...")
get_vars()
cleanser_count = AV['ploy_cleanser_count']
# make sure no workers interfere:
fab.run('ezjail-admin stop worker')
# stop and nuke the cleanser slaves
for cleanser_index in range(cleanser_count):
cindex = '{:02d}'.format(cleanser_index + 1)
fab.run('ezjail-admin stop cleanser_{cindex}'.format(cindex=cindex))
with fab.warn_only():
fab.run('zfs destroy tank/jails/cleanser_{cindex}@jdispatch_rollback'.format(cindex=cindex))
fab.run('ezjail-admin delete -fw | python | {
"resource": ""
} |
q260937 | reset_jails | validation | def reset_jails(confirm=True, keep_cleanser_master=True):
""" stops, deletes and re-creates all jails.
since the cleanser master is rather large, that one is omitted by default.
"""
if value_asbool(confirm) and not yesno("""\nObacht!
This will destroy all existing and or currently running jails on the host.
Are you sure that you want to | python | {
"resource": ""
} |
q260938 | FlaskMixin._add_admin | validation | def _add_admin(self, app, **kwargs):
"""Add a Flask Admin interface to an application.
:param flask.Flask app: A Flask application
:param kwargs: Keyword arguments are passed through to :class:`flask_admin.Admin`
:rtype: flask_admin.Admin
"""
from flask_admin import Admin
from flask_admin.contrib.sqla import ModelView
| python | {
"resource": ""
} |
q260939 | dropbox_form | validation | def dropbox_form(request):
""" generates a dropbox uid and renders the submission form with a signed version of that id"""
from briefkasten import generate_post_token
token = | python | {
"resource": ""
} |
q260940 | dropbox_fileupload | validation | def dropbox_fileupload(dropbox, request):
""" accepts a single file upload and adds it to the dropbox as attachment"""
attachment = request.POST['attachment']
attached = dropbox.add_attachment(attachment) | python | {
"resource": ""
} |
q260941 | dropbox_submission | validation | def dropbox_submission(dropbox, request):
""" handles the form submission, redirects to the dropbox's status page."""
try:
data = dropbox_schema.deserialize(request.POST)
except Exception:
return HTTPFound(location=request.route_url('dropbox_form'))
# set the message
dropbox.message = data.get('message')
# recognize submission from watchdog
if 'testing_secret' in dropbox.settings:
| python | {
"resource": ""
} |
q260942 | make_obo_getter | validation | def make_obo_getter(data_url: str,
data_path: str,
*,
preparsed_path: Optional[str] = None,
) -> Callable[[Optional[str], bool, bool], MultiDiGraph]:
"""Build a function that handles downloading OBO data and parsing it into a NetworkX object.
:param data_url: The URL of the data
:param data_path: The path where the data should get stored
:param preparsed_path: The optional path to cache a pre-parsed json version
"""
download_function = make_downloader(data_url, data_path)
def get_obo(url: Optional[str] = None, cache: bool = True, force_download: bool = False) -> MultiDiGraph:
"""Download and parse a GO obo file with :mod:`obonet` into a MultiDiGraph.
:param url: The URL (or file path) to download.
:param cache: If true, the data | python | {
"resource": ""
} |
q260943 | belns | validation | def belns(keyword: str, file: TextIO, encoding: Optional[str], use_names: bool):
"""Write as a BEL namespace."""
directory = get_data_dir(keyword)
obo_url = f'http://purl.obolibrary.org/obo/{keyword}.obo'
obo_path = os.path.join(directory, f'{keyword}.obo')
obo_cache_path = os.path.join(directory, f'{keyword}.obo.pickle')
obo_getter = make_obo_getter(obo_url, obo_path, | python | {
"resource": ""
} |
q260944 | belanno | validation | def belanno(keyword: str, file: TextIO):
"""Write as a BEL annotation."""
directory = get_data_dir(keyword)
obo_url = f'http://purl.obolibrary.org/obo/{keyword}.obo'
obo_path = os.path.join(directory, f'{keyword}.obo') | python | {
"resource": ""
} |
q260945 | _store_helper | validation | def _store_helper(model: Action, session: Optional[Session] = None) -> None:
"""Help store an action."""
if session is None:
| python | {
"resource": ""
} |
q260946 | _make_session | validation | def _make_session(connection: Optional[str] = None) -> Session:
"""Make a session."""
if connection is None:
connection = | python | {
"resource": ""
} |
q260947 | create_all | validation | def create_all(engine, checkfirst=True):
"""Create the | python | {
"resource": ""
} |
q260948 | Action.store_populate | validation | def store_populate(cls, resource: str, session: Optional[Session] = None) -> 'Action':
"""Store a "populate" event.
:param resource: The normalized name of the resource to store
Example:
>>> from bio2bel.models import Action
| python | {
"resource": ""
} |
q260949 | Action.store_populate_failed | validation | def store_populate_failed(cls, resource: str, session: Optional[Session] = None) -> 'Action':
"""Store a "populate failed" event.
:param resource: The normalized name of the resource to store
Example:
>>> from bio2bel.models import Action
| python | {
"resource": ""
} |
q260950 | Action.store_drop | validation | def store_drop(cls, resource: str, session: Optional[Session] = None) -> 'Action':
"""Store a "drop" event.
:param resource: The normalized name of the resource to store
Example:
>>> from bio2bel.models import Action
| python | {
"resource": ""
} |
q260951 | Action.ls | validation | def ls(cls, session: Optional[Session] = None) -> List['Action']:
"""Get all actions."""
if session is None:
session = _make_session()
| python | {
"resource": ""
} |
q260952 | Action.count | validation | def count(cls, session: Optional[Session] = None) -> int:
"""Count all actions."""
if session is None:
session = | python | {
"resource": ""
} |
q260953 | get_data_dir | validation | def get_data_dir(module_name: str) -> str:
"""Ensure the appropriate Bio2BEL data directory exists for the given module, then returns the file path.
:param module_name: The name of the module. Ex: 'chembl'
:return: The module's data directory
| python | {
"resource": ""
} |
q260954 | get_module_config_cls | validation | def get_module_config_cls(module_name: str) -> Type[_AbstractModuleConfig]: # noqa: D202
"""Build a module configuration class."""
class ModuleConfig(_AbstractModuleConfig):
NAME = f'bio2bel:{module_name}'
| python | {
"resource": ""
} |
q260955 | get_connection | validation | def get_connection(module_name: str, connection: Optional[str] = None) -> str:
"""Return the SQLAlchemy connection string if it is set.
Order of operations:
1. Return the connection if given as a parameter
2. Check the environment for BIO2BEL_{module_name}_CONNECTION
3. Look in the bio2bel config file for module-specific connection. Create if doesn't exist. Check the
module-specific section for ``connection``
4. Look in the bio2bel module folder for a config file. Don't create if doesn't exist. Check the default section
for ``connection``
5. Check the environment for BIO2BEL_CONNECTION
6. Check the bio2bel config file for default
7. Fall back to standard default cache connection
:param module_name: The name of the module to get the configuration for
| python | {
"resource": ""
} |
q260956 | get_modules | validation | def get_modules() -> Mapping:
"""Get all Bio2BEL modules."""
modules = {}
for entry_point in iter_entry_points(group='bio2bel', name=None):
entry = entry_point.name
try:
modules[entry] = entry_point.load()
except VersionConflict as exc:
log.warning('Version conflict in %s: %s', entry, exc)
continue
| python | {
"resource": ""
} |
q260957 | clear_cache | validation | def clear_cache(module_name: str, keep_database: bool = True) -> None:
"""Clear all downloaded files."""
data_dir = get_data_dir(module_name)
if not os.path.exists(data_dir):
return
for name in os.listdir(data_dir):
if name in {'config.ini', 'cfg.ini'}:
continue
if name | python | {
"resource": ""
} |
q260958 | AbstractManager.drop_all | validation | def drop_all(self, check_first: bool = True):
"""Drop all tables from the database.
:param bool check_first: Defaults to True, only issue DROPs for tables confirmed to be
present in the | python | {
"resource": ""
} |
q260959 | label | validation | def label(labels=[], language='any', sortLabel=False):
'''
Provide a label for a list of labels.
The items in the list of labels are assumed to be either instances of
:class:`Label`, or dicts with at least the key `label` in them. These will
be passed to the :func:`dict_to_label` function.
This method tries to find a label by looking if there's
a pref label for the specified language. If there's no pref label,
it looks for an alt label. It disregards hidden labels.
While matching languages, preference will be given to exact matches. But,
if no exact match is present, an inexact match will be attempted. This might
be because a label in language `nl-BE` is being requested, but only `nl` or
even `nl-NL` is present. Similarly, when requesting `nl`, a label with
language `nl-NL` or even `nl-Latn-NL` will also be considered,
providing no label is present that has an exact match with the
requested language.
If language 'any' was specified, all labels will be considered,
regardless of language.
To find a label without a specified language, pass `None` as language.
If a language or None was specified, and no label could be found, this
method will automatically try to find a label in some other language.
Finally, if no label could be found, None is returned.
:param string language: The preferred language to receive the label in. This
should be a valid IANA language tag.
:param boolean sortLabel: Should sortLabels be considered or not? If True,
| python | {
"resource": ""
} |
q260960 | find_best_label_for_type | validation | def find_best_label_for_type(labels, language, labeltype):
'''
Find the best label for a certain labeltype.
:param list labels: A list of :class:`Label`.
:param str language: An IANA language string, eg. `nl` or `nl-BE`.
:param str labeltype: Type of label to look for, eg. `prefLabel`. | python | {
"resource": ""
} |
q260961 | filter_labels_by_language | validation | def filter_labels_by_language(labels, language, broader=False):
'''
Filter a list of labels, leaving only labels of a certain language.
:param list labels: A list of :class:`Label`.
:param str language: An IANA language string, eg. `nl` or `nl-BE`.
:param boolean broader: When true, will also match `nl-BE` when filtering
on `nl`. When false, only exact matches are considered.
'''
if language == 'any': | python | {
"resource": ""
} |
q260962 | ConceptScheme._sortkey | validation | def _sortkey(self, key='uri', language='any'):
'''
Provide a single sortkey for this conceptscheme.
:param string key: Either `uri`, `label` or `sortlabel`.
:param string language: The preferred language to receive the label in
if key is `label` or `sortlabel`. This should be a valid IANA language tag.
| python | {
"resource": ""
} |
q260963 | _iterate_managers | validation | def _iterate_managers(connection, skip):
"""Iterate over instantiated managers."""
for idx, name, manager_cls in _iterate_manage_classes(skip):
if name in skip:
continue
try:
| python | {
"resource": ""
} |
q260964 | drop | validation | def drop(connection, skip):
"""Drop all."""
for idx, name, manager in _iterate_managers(connection, skip):
| python | {
"resource": ""
} |
q260965 | clear | validation | def clear(skip):
"""Clear all caches."""
for name in sorted(MODULES):
if name in skip:
continue
| python | {
"resource": ""
} |
q260966 | sheet | validation | def sheet(connection, skip, file: TextIO):
"""Generate a summary sheet."""
from tabulate import tabulate
header = ['', 'Name', 'Description', 'Terms', 'Relations']
rows = []
for i, (idx, name, manager) in enumerate(_iterate_managers(connection, skip), start=1):
try:
if not manager.is_populated():
continue
except AttributeError:
click.secho(f'{name} does not implement is_populated', fg='red')
continue
terms, relations = None, None
if isinstance(manager, BELNamespaceManagerMixin):
terms = manager._count_model(manager.namespace_model)
if isinstance(manager, BELManagerMixin):
| python | {
"resource": ""
} |
q260967 | web | validation | def web(connection, host, port):
"""Run a combine web interface."""
from bio2bel.web.application | python | {
"resource": ""
} |
q260968 | actions | validation | def actions(connection):
"""List all actions."""
session = _make_session(connection=connection)
| python | {
"resource": ""
} |
q260969 | BELManagerMixin.count_relations | validation | def count_relations(self) -> int:
"""Count the number of BEL relations generated."""
if self.edge_model is ...:
raise Bio2BELMissingEdgeModelError('edge_edge model is undefined/count_bel_relations is not overridden')
elif isinstance(self.edge_model, list):
| python | {
"resource": ""
} |
q260970 | BELManagerMixin.to_indra_statements | validation | def to_indra_statements(self, *args, **kwargs):
"""Dump as a list of INDRA statements.
:rtype: List[indra.Statement]
| python | {
"resource": ""
} |
q260971 | _convert_coordinatelist | validation | def _convert_coordinatelist(input_obj):
"""convert from 'list' or 'tuple' object to pgmagick.CoordinateList.
:type input_obj: list or tuple
"""
cdl = | python | {
"resource": ""
} |
q260972 | _convert_vpathlist | validation | def _convert_vpathlist(input_obj):
"""convert from 'list' or 'tuple' object to pgmagick.VPathList.
:type input_obj: list or tuple
"""
vpl = pgmagick.VPathList()
for obj in input_obj:
# FIXME
| python | {
"resource": ""
} |
q260973 | Image.get_exif_info | validation | def get_exif_info(self):
"""return exif-tag dict
"""
_dict = {}
for tag in _EXIF_TAGS:
ret = self.img.attribute("EXIF:%s" % tag) | python | {
"resource": ""
} |
q260974 | Draw.bezier | validation | def bezier(self, points):
"""Draw a Bezier-curve.
:param points: ex.) ((5, 5), (6, 6), (7, 7))
:type points: list
"""
coordinates = pgmagick.CoordinateList() | python | {
"resource": ""
} |
q260975 | Draw.scaling | validation | def scaling(self, x, y):
"""Scaling Draw Object
:param x: 0.0 ~ 1.0 | python | {
"resource": ""
} |
q260976 | Draw.stroke_linecap | validation | def stroke_linecap(self, linecap):
"""set to stroke linecap.
:param linecap: 'undefined', 'butt', 'round', 'square'
| python | {
"resource": ""
} |
q260977 | Draw.stroke_linejoin | validation | def stroke_linejoin(self, linejoin):
"""set to stroke linejoin.
:param linejoin: 'undefined', 'miter', 'round', 'bevel'
:type linejoin: str
"""
| python | {
"resource": ""
} |
q260978 | version | validation | def version():
"""Return version string."""
with io.open('pgmagick/_version.py') as input_file:
for line in input_file:
| python | {
"resource": ""
} |
q260979 | delete_license_request | validation | def delete_license_request(request):
"""Submission to remove a license acceptance request."""
uuid_ = request.matchdict['uuid']
posted_uids = [x['uid'] for x in | python | {
"resource": ""
} |
q260980 | delete_roles_request | validation | def delete_roles_request(request):
"""Submission to remove a role acceptance request."""
uuid_ = request.matchdict['uuid']
posted_roles = request.json | python | {
"resource": ""
} |
q260981 | delete_acl_request | validation | def delete_acl_request(request):
"""Submission to remove an ACL."""
uuid_ = request.matchdict['uuid']
posted = request.json
permissions = [(x['uid'], x['permission'],) for x in posted]
with db_connect() as db_conn:
| python | {
"resource": ""
} |
q260982 | processor | validation | def processor(): # pragma: no cover
"""Churns over PostgreSQL notifications on configured channels.
This requires the application be setup and the registry be available.
This function uses the database connection string and a list of
pre configured channels.
"""
registry = get_current_registry()
settings = registry.settings
connection_string = settings[CONNECTION_STRING]
channels = _get_channels(settings)
# Code adapted from
# http://initd.org/psycopg/docs/advanced.html#asynchronous-notifications
with psycopg2.connect(connection_string) as conn:
conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
with conn.cursor() as cursor:
for channel in channels:
cursor.execute('LISTEN {}'.format(channel))
logger.debug('Waiting for notifications on channel "{}"'
.format(channel))
registry.notify(ChannelProcessingStartUpEvent())
rlist = [conn] # wait until ready for reading
wlist = [] # wait until ready for writing
xlist = [] # wait for an "exceptional condition"
timeout | python | {
"resource": ""
} |
q260983 | lookup_api_key_info | validation | def lookup_api_key_info():
"""Given a dbapi cursor, lookup all the api keys and their information."""
info = {}
with db_connect() as conn:
with conn.cursor() as cursor:
cursor.execute(ALL_KEY_INFO_SQL_STMT)
for row in cursor.fetchall():
id, key, name, groups | python | {
"resource": ""
} |
q260984 | includeme | validation | def includeme(config):
"""Configuration include fuction for this module"""
api_key_authn_policy = APIKeyAuthenticationPolicy()
config.include('openstax_accounts')
openstax_authn_policy = config.registry.getUtility(
IOpenstaxAccountsAuthenticationPolicy)
# Set up api & user authentication policies.
policies | python | {
"resource": ""
} |
q260985 | expandvars_dict | validation | def expandvars_dict(settings):
"""Expands all environment variables in a settings dictionary.""" | python | {
"resource": ""
} |
q260986 | task | validation | def task(**kwargs):
"""A function task decorator used in place of ``@celery_app.task``."""
def wrapper(wrapped):
def callback(scanner, name, obj):
celery_app = scanner.config.registry.celery_app
| python | {
"resource": ""
} |
q260987 | _make_celery_app | validation | def _make_celery_app(config):
"""This exposes the celery app. The app is actually created as part
of the configuration. However, this does make the celery app functional
as a stand-alone celery application.
This puts the pyramid configuration object | python | {
"resource": ""
} |
q260988 | post_publication_processing | validation | def post_publication_processing(event, cursor):
"""Process post-publication events coming out of the database."""
module_ident, ident_hash = event.module_ident, event.ident_hash
celery_app = get_current_registry().celery_app
# Check baking is not already queued.
cursor.execute('SELECT result_id::text '
'FROM document_baking_result_associations '
'WHERE module_ident = %s', (module_ident,))
for result in cursor.fetchall():
state = celery_app.AsyncResult(result[0]).state
if state in ('QUEUED', 'STARTED', 'RETRY'):
logger.debug('Already queued module_ident={} ident_hash={}'.format(
module_ident, ident_hash))
return
logger.debug('Queued for processing module_ident={} ident_hash={}'.format(
module_ident, ident_hash))
recipe_ids = _get_recipe_ids(module_ident, cursor)
update_module_state(cursor, module_ident, | python | {
"resource": ""
} |
q260989 | parse_archive_uri | validation | def parse_archive_uri(uri):
"""Given an archive URI, parse to a split ident-hash."""
parsed = urlparse(uri)
path = parsed.path.rstrip('/').split('/') | python | {
"resource": ""
} |
q260990 | declare_api_routes | validation | def declare_api_routes(config):
"""Declaration of routing"""
add_route = config.add_route
add_route('get-content', '/contents/{ident_hash}')
add_route('get-resource', '/resources/{hash}')
# User actions API
add_route('license-request', '/contents/{uuid}/licensors')
add_route('roles-request', '/contents/{uuid}/roles')
add_route('acl-request', '/contents/{uuid}/permissions')
# Publishing API
add_route('publications', '/publications')
add_route('get-publication', '/publications/{id}')
add_route('publication-license-acceptance',
'/publications/{id}/license-acceptances/{uid}')
add_route('publication-role-acceptance',
| python | {
"resource": ""
} |
q260991 | declare_browsable_routes | validation | def declare_browsable_routes(config):
"""Declaration of routes that can be browsed by users."""
# This makes our routes slashed, which is good browser behavior.
config.add_notfound_view(default_exceptionresponse_view,
append_slash=True)
add_route = config.add_route
add_route('admin-index', '/a/')
add_route('admin-moderation', '/a/moderation/')
add_route('admin-api-keys', '/a/api-keys/')
add_route('admin-add-site-messages', '/a/site-messages/',
request_method='GET')
add_route('admin-add-site-messages-POST', '/a/site-messages/',
request_method='POST')
add_route('admin-delete-site-messages', '/a/site-messages/',
request_method='DELETE')
add_route('admin-edit-site-message', '/a/site-messages/{id}/',
| python | {
"resource": ""
} |
q260992 | includeme | validation | def includeme(config):
"""Declare all routes."""
config.include('pyramid_jinja2')
config.add_jinja2_renderer('.html')
config.add_jinja2_renderer('.rss')
config.add_static_view(name='/a/static', path="cnxpublishing:static/")
# Commit the configuration otherwise the jija2_env won't have
# a `globals` assignment.
config.commit()
# Place a few globals in the template environment.
from cnxdb.ident_hash | python | {
"resource": ""
} |
q260993 | _formatter_callback_factory | validation | def _formatter_callback_factory(): # pragma: no cover
"""Returns a list of includes to be given to `cnxepub.collation.collate`.
"""
includes = []
exercise_url_template = '{baseUrl}/api/exercises?q={field}:"{{itemCode}}"'
settings = get_current_registry().settings
exercise_base_url = settings.get('embeddables.exercise.base_url', None)
exercise_matches = [match.split(',', 1) for match in aslist(
settings.get('embeddables.exercise.match', ''), flatten=False)]
exercise_token = settings.get('embeddables.exercise.token', None)
mathml_url = settings.get('mathmlcloud.url', None)
memcache_servers = settings.get('memcache_servers')
if memcache_servers:
memcache_servers = memcache_servers.split()
else:
memcache_servers = None
if exercise_base_url and exercise_matches:
mc_client = None
if memcache_servers:
| python | {
"resource": ""
} |
q260994 | bake | validation | def bake(binder, recipe_id, publisher, message, cursor):
"""Given a `Binder` as `binder`, bake the contents and
persist those changes alongside the published content.
"""
recipe = _get_recipe(recipe_id, cursor)
includes = _formatter_callback_factory()
binder = collate_models(binder, ruleset=recipe, includes=includes)
def flatten_filter(model):
return (isinstance(model, cnxepub.CompositeDocument) or
(isinstance(model, cnxepub.Binder) and
model.metadata.get('type') == 'composite-chapter'))
def only_documents_filter(model):
return isinstance(model, cnxepub.Document) \
and not | python | {
"resource": ""
} |
q260995 | db_connect | validation | def db_connect(connection_string=None, **kwargs):
"""Function to supply a database connection object."""
if connection_string is None:
connection_string = get_current_registry().settings[CONNECTION_STRING]
db_conn = | python | {
"resource": ""
} |
q260996 | with_db_cursor | validation | def with_db_cursor(func):
"""Decorator that supplies a cursor to the function.
This passes in a psycopg2 Cursor as the argument 'cursor'.
It also accepts a cursor if one is given.
"""
@functools.wraps(func)
def wrapped(*args, **kwargs):
if 'cursor' in kwargs or func.func_code.co_argcount == len(args):
return func(*args, **kwargs)
| python | {
"resource": ""
} |
q260997 | _dissect_roles | validation | def _dissect_roles(metadata):
"""Given a model's ``metadata``, iterate over the roles.
Return values are the role identifier and role type as a tuple.
"""
for role_key in cnxepub.ATTRIBUTED_ROLE_KEYS:
for user in metadata.get(role_key, []):
if user['type'] != 'cnx-id':
| python | {
"resource": ""
} |
q260998 | obtain_licenses | validation | def obtain_licenses():
"""Obtain the licenses in a dictionary form, keyed by url."""
with db_connect() as db_conn:
with db_conn.cursor() as cursor:
cursor.execute("""\
SELECT combined_row.url, row_to_json(combined_row) FROM (
SELECT "code", | python | {
"resource": ""
} |
q260999 | _validate_license | validation | def _validate_license(model):
"""Given the model, check the license is one valid for publication."""
license_mapping = obtain_licenses()
try:
license_url = model.metadata['license_url']
except | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.