INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Submission to remove a role acceptance request. | def delete_roles_request(request):
"""Submission to remove a role acceptance request."""
uuid_ = request.matchdict['uuid']
posted_roles = request.json
with db_connect() as db_conn:
with db_conn.cursor() as cursor:
remove_role_requests(cursor, uuid_, posted_roles)
resp = request... |
Returns the ACL for the given content identified by uuid. | def get_acl(request):
"""Returns the ACL for the given content identified by ``uuid``."""
uuid_ = request.matchdict['uuid']
with db_connect() as db_conn:
with db_conn.cursor() as cursor:
cursor.execute("""\
SELECT TRUE FROM document_controls WHERE uuid = %s""", (uuid_,))
try... |
Submission to create an ACL. | def post_acl_request(request):
"""Submission to create an ACL."""
uuid_ = request.matchdict['uuid']
posted = request.json
permissions = [(x['uid'], x['permission'],) for x in posted]
with db_connect() as db_conn:
with db_conn.cursor() as cursor:
cursor.execute("""\
SELECT TRUE F... |
Submission to remove an ACL. | 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:
with db_conn.cursor() as cursor:
remove_acl(cursor, uuid_, permi... |
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. | 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... |
Given a dbapi cursor lookup all the api keys and their information. | 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 =... |
Configuration include fuction for this module | 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 po... |
Expands all environment variables in a settings dictionary. | def expandvars_dict(settings):
"""Expands all environment variables in a settings dictionary."""
return dict(
(key, os.path.expandvars(value))
for key, value in settings.iteritems()
) |
\ Used to optionally initialize the Sentry service with this app. See https:// docs. sentry. io/ platforms/ python/ pyramid/ | def initialize_sentry_integration(): # pragma: no cover
"""\
Used to optionally initialize the Sentry service with this app.
See https://docs.sentry.io/platforms/python/pyramid/
"""
# This function is not under coverage because it is boilerplate
# from the Sentry documentation.
try:
... |
A function task decorator used in place of | 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
celery_app.task(**kwargs)(obj)
venusian.attach(wrapped, callback)
... |
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. | 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 on the celery app to be
used for making the regis... |
Process post - publication events coming out of the database. | 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::t... |
Given an archive URI parse to a split ident - hash. | def parse_archive_uri(uri):
"""Given an archive URI, parse to a split ident-hash."""
parsed = urlparse(uri)
path = parsed.path.rstrip('/').split('/')
ident_hash = path[-1]
ident_hash = unquote(ident_hash)
return ident_hash |
Declaration of routing | 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'... |
Declaration of routes that can be browsed by users. | 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_... |
Declare all routes. | 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 `... |
Returns a list of includes to be given to cnxepub. collation. collate. | 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.g... |
Given a Binder as binder bake the contents and persist those changes alongside the published content. | 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=rec... |
Arguments: differential_dfs ( dict or pandas. DataFrame ): python dict of names to pandas dataframes or a single dataframe indexed by gene symbols which must have columns named log2FC and qval. title ( str ): The title of the plot ( to be embedded in the html ). scripts_mode ( str ): Choose from [ CDN directory inline ... | def volcano(differential_dfs, title='Axial Volcano Plot', scripts_mode="CDN", data_mode="directory",
organism="human", q_value_column_name="q", log2FC_column_name="logFC",
output_dir=".", filename="volcano.html", version=this_version):
"""
Arguments:
differential_dfs (dict or pan... |
Arguments: genes_by_samples_matrix ( pandas. DataFrame ): dataframe indexed by genes columns are samples sample_attributes ( pandas. DataFrame ): dataframe indexed by samples columns are sample attributes ( e. g. classes ) title ( str ): The title of the plot ( to be embedded in the html ). scripts_mode ( str ): Choose... | def heatmap(genes_by_samples_matrix, sample_attributes, title='Axial Heatmap', scripts_mode="CDN", data_mode="directory",
organism="human", separate_zscore_by=["system"],
output_dir=".", filename="heatmap.html", version=this_version):
"""
Arguments:
genes_by_samples_matrix (panda... |
Arguments: networkx_graph ( networkx. Graph ): any instance of networkx. Graph title ( str ): The title of the plot ( to be embedded in the html ). scripts_mode ( str ): Choose from [ CDN directory inline ]: | def graph(networkx_graph, title='Axial Graph Visualization', scripts_mode="CDN", data_mode="directory",
output_dir=".", filename="graph.html", version=this_version):
"""
Arguments:
networkx_graph (networkx.Graph): any instance of networkx.Graph
title (str): The title of the plot (to be... |
Function to supply a database connection object. | 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 = psycopg2.connect(connection_string, **kwargs)
try:
with db_conn:
... |
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. | 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_argcoun... |
Translates a role type ( a value found in cnxepub. ATTRIBUTED_ROLE_KEYS ) to a database compatible value for role_types. | def _role_type_to_db_type(type_):
"""Translates a role type (a value found in
``cnxepub.ATTRIBUTED_ROLE_KEYS``) to a database compatible
value for ``role_types``.
"""
with db_connect() as db_conn:
with db_conn.cursor() as cursor:
cursor.execute("""\
WITH unnested_role_types AS (
... |
Given a model s metadata iterate over the roles. Return values are the role identifier and role type as a tuple. | 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':
... |
Update or insert records for pending license acceptors. | def upsert_pending_licensors(cursor, document_id):
"""Update or insert records for pending license acceptors."""
cursor.execute("""\
SELECT "uuid", "metadata"
FROM pending_documents
WHERE id = %s""", (document_id,))
uuid_, metadata = cursor.fetchone()
acceptors = set([uid for uid, type_ in _dissect_role... |
Update or insert records for pending document role acceptance. | def upsert_pending_roles(cursor, document_id):
"""Update or insert records for pending document role acceptance."""
cursor.execute("""\
SELECT "uuid", "metadata"
FROM pending_documents
WHERE id = %s""", (document_id,))
uuid_, metadata = cursor.fetchone()
acceptors = set([(uid, _role_type_to_db_type(typ... |
Obtain the licenses in a dictionary form keyed by url. | 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", "version", "name", "url", "is_valid_for_publicati... |
Given the model check the license is one valid for publication. | 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 KeyError:
raise exceptions.MissingRequiredMetadata('license_url')
try:
license = li... |
Given the model check that all the metadata role values have valid information in them and any required metadata fields contain values. | def _validate_roles(model):
"""Given the model, check that all the metadata role values
have valid information in them and any required metadata fields
contain values.
"""
required_roles = (ATTRIBUTED_ROLE_KEYS[0], ATTRIBUTED_ROLE_KEYS[4],)
for role_key in ATTRIBUTED_ROLE_KEYS:
try:
... |
Given a database cursor and model check the derived - from value accurately points to content in the archive. The value can be nothing or must point to existing content. | def _validate_derived_from(cursor, model):
"""Given a database cursor and model, check the derived-from
value accurately points to content in the archive.
The value can be nothing or must point to existing content.
"""
derived_from_uri = model.metadata.get('derived_from_uri')
if derived_from_uri... |
Give a database cursor and model check the subjects against the subject vocabulary. | def _validate_subjects(cursor, model):
"""Give a database cursor and model, check the subjects against
the subject vocabulary.
"""
subject_vocab = [term[0] for term in acquire_subject_vocabulary(cursor)]
subjects = model.metadata.get('subjects', [])
invalid_subjects = [s for s in subjects if s n... |
Validates the model using a series of checks on bits of the data. | def validate_model(cursor, model):
"""Validates the model using a series of checks on bits of the data."""
# Check the license is one valid for publication.
_validate_license(model)
_validate_roles(model)
# Other required metadata includes: title, summary
required_metadata = ('title', 'summary'... |
Check the given publisher of this publication given by publication_id is allowed to publish the content given by uuid. | def is_publication_permissible(cursor, publication_id, uuid_):
"""Check the given publisher of this publication given
by ``publication_id`` is allowed to publish the content given
by ``uuid``.
"""
# Check the publishing user has permission to publish
cursor.execute("""\
SELECT 't'::boolean
FROM
... |
Adds a model ( binder or document ) that is awaiting publication to the database. | def add_pending_model(cursor, publication_id, model):
"""Adds a model (binder or document) that is awaiting publication
to the database.
"""
# FIXME Too much happening here...
assert isinstance(model, (cnxepub.Document, cnxepub.Binder,)), type(model)
uri = model.get_uri('cnx-archive')
if ur... |
Lookup a document by id and version. | def lookup_document_pointer(ident_hash, cursor):
"""Lookup a document by id and version."""
id, version = split_ident_hash(ident_hash, split_version=True)
stmt = "SELECT name FROM modules WHERE uuid = %s"
args = [id]
if version and version[0] is not None:
operator = version[1] is None and 'i... |
Updates the pending model s content. This is a secondary step not in add_pending_model because content reference resolution requires the identifiers as they will appear in the end publication. | def add_pending_model_content(cursor, publication_id, model):
"""Updates the pending model's content.
This is a secondary step not in ``add_pending_model, because
content reference resolution requires the identifiers as they
will appear in the end publication.
"""
cursor.execute("""\
SEL... |
Given a publication exception set the publication as failed and append the failure message to the publication record. | def set_publication_failure(cursor, exc):
"""Given a publication exception, set the publication as failed and
append the failure message to the publication record.
"""
publication_id = exc.publication_id
if publication_id is None:
raise ValueError("Exception must have a ``publication_id`` va... |
Adds a publication entry and makes each item a pending document. | def add_publication(cursor, epub, epub_file, is_pre_publication=False):
"""Adds a publication entry and makes each item
a pending document.
"""
publisher = epub[0].metadata['publisher']
publish_message = epub[0].metadata['publication_message']
epub_binary = psycopg2.Binary(epub_file.read())
... |
Check the aggregate state on the pending document. | def _check_pending_document_license_state(cursor, document_id):
"""Check the aggregate state on the pending document."""
cursor.execute("""\
SELECT BOOL_AND(accepted IS TRUE)
FROM
pending_documents AS pd,
license_acceptances AS la
WHERE
pd.id = %s
AND
pd.uuid = la.uuid""",
(document... |
Check the aggregate state on the pending document. | def _check_pending_document_role_state(cursor, document_id):
"""Check the aggregate state on the pending document."""
cursor.execute("""\
SELECT BOOL_AND(accepted IS TRUE)
FROM
role_acceptances AS ra,
pending_documents as pd
WHERE
pd.id = %s
AND
pd.uuid = ra.uuid""",
(document_id,))... |
Update the state of the document s state values. | def _update_pending_document_state(cursor, document_id, is_license_accepted,
are_roles_accepted):
"""Update the state of the document's state values."""
args = (bool(is_license_accepted), bool(are_roles_accepted),
document_id,)
cursor.execute("""\
UPDATE pendin... |
Checks to see if the publication contains any revised models. Revised in this context means that it is a new version of an existing piece of content. | def is_revision_publication(publication_id, cursor):
"""Checks to see if the publication contains any revised models.
Revised in this context means that it is a new version of an
existing piece of content.
"""
cursor.execute("""\
SELECT 't'::boolean FROM modules
WHERE uuid IN (SELECT uuid
... |
Invoked to poke at the publication to update and acquire its current state. This is used to persist the publication to archive. | def poke_publication_state(publication_id, cursor):
"""Invoked to poke at the publication to update and acquire its current
state. This is used to persist the publication to archive.
"""
cursor.execute("""\
SELECT "state", "state_messages", "is_pre_publication", "publisher"
FROM publications
WHERE id = ... |
Check the publication s current state. | def check_publication_state(publication_id):
"""Check the publication's current state."""
with db_connect() as db_conn:
with db_conn.cursor() as cursor:
cursor.execute("""\
SELECT "state", "state_messages"
FROM publications
WHERE id = %s""", (publication_id,))
publication_state, ... |
Given a tree parse to a set of models | def _node_to_model(tree_or_item, metadata=None, parent=None,
lucent_id=cnxepub.TRANSLUCENT_BINDER_ID):
"""Given a tree, parse to a set of models"""
if 'contents' in tree_or_item:
# It is a binder.
tree = tree_or_item
binder = cnxepub.TranslucentBinder(metadata=tree)
... |
Reassemble a Binder object coming out of the database. | def _reassemble_binder(id, tree, metadata):
"""Reassemble a Binder object coming out of the database."""
binder = cnxepub.Binder(id, metadata=metadata)
for item in tree['contents']:
node = _node_to_model(item, parent=binder)
if node.metadata['title'] != item['title']:
binder.set_... |
Given a publication id as publication_id write the documents to the * Connexions Archive *. | def publish_pending(cursor, publication_id):
"""Given a publication id as ``publication_id``,
write the documents to the *Connexions Archive*.
"""
cursor.execute("""\
WITH state_update AS (
UPDATE publications SET state = 'Publishing' WHERE id = %s
)
SELECT publisher, publication_message
FROM publicat... |
Accept or deny the document license for the publication ( publication_id ) and user ( at user_id ) for the documents ( listed by id as document_ids ). | def accept_publication_license(cursor, publication_id, user_id,
document_ids, is_accepted=False):
"""Accept or deny the document license for the publication
(``publication_id``) and user (at ``user_id``)
for the documents (listed by id as ``document_ids``).
"""
cursor... |
Accept or deny the document role attribution for the publication ( publication_id ) and user ( at user_id ) for the documents ( listed by id as document_ids ). | def accept_publication_role(cursor, publication_id, user_id,
document_ids, is_accepted=False):
"""Accept or deny the document role attribution for the publication
(``publication_id``) and user (at ``user_id``)
for the documents (listed by id as ``document_ids``).
"""
cur... |
Given a uuid and list of roles ( user identifiers ) create a license acceptance entry. If has_accepted is supplied it will be used to assign an acceptance value to all listed uids. | def upsert_license_requests(cursor, uuid_, roles):
"""Given a ``uuid`` and list of ``roles`` (user identifiers)
create a license acceptance entry. If ``has_accepted`` is supplied,
it will be used to assign an acceptance value to all listed ``uids``.
"""
if not isinstance(roles, (list, set, tuple,)):... |
Given a uuid and list of uids ( user identifiers ) remove the identified users license acceptance entries. | def remove_license_requests(cursor, uuid_, uids):
"""Given a ``uuid`` and list of ``uids`` (user identifiers)
remove the identified users' license acceptance entries.
"""
if not isinstance(uids, (list, set, tuple,)):
raise TypeError("``uids`` is an invalid type: {}".format(type(uids)))
acce... |
Given a uuid and list of dicts containing the uid and role for creating a role acceptance entry. The roles dict can optionally contain a has_accepted value which will default to true. | def upsert_role_requests(cursor, uuid_, roles):
"""Given a ``uuid`` and list of dicts containing the ``uid`` and
``role`` for creating a role acceptance entry. The ``roles`` dict
can optionally contain a ``has_accepted`` value, which will default
to true.
"""
if not isinstance(roles, (list, set,... |
Given a uuid and list of dicts containing the uid ( user identifiers ) and role for removal of the identified users role acceptance entries. | def remove_role_requests(cursor, uuid_, roles):
"""Given a ``uuid`` and list of dicts containing the ``uid``
(user identifiers) and ``role`` for removal of the identified
users' role acceptance entries.
"""
if not isinstance(roles, (list, set, tuple,)):
raise TypeError("``roles`` is an inval... |
Given a uuid and a set of permissions given as a tuple of uid and permission upsert them into the database. | def upsert_acl(cursor, uuid_, permissions):
"""Given a ``uuid`` and a set of permissions given as a
tuple of ``uid`` and ``permission``, upsert them into the database.
"""
if not isinstance(permissions, (list, set, tuple,)):
raise TypeError("``permissions`` is an invalid type: {}"
... |
Given a uuid and a set of permissions given as a tuple of uid and permission remove these entries from the database. | def remove_acl(cursor, uuid_, permissions):
"""Given a ``uuid`` and a set of permissions given as a tuple
of ``uid`` and ``permission``, remove these entries from the database.
"""
if not isinstance(permissions, (list, set, tuple,)):
raise TypeError("``permissions`` is an invalid type: {}"
... |
Upsert s user info into the database. The model contains the user info as part of the role values. | def _upsert_persons(cursor, person_ids, lookup_func):
"""Upsert's user info into the database.
The model contains the user info as part of the role values.
"""
person_ids = list(set(person_ids)) # cleanse data
# Check for existing records to update.
cursor.execute("SELECT personid from persons... |
Upsert s user info into the database. The model contains the user info as part of the role values. | def _upsert_users(cursor, user_ids, lookup_func):
"""Upsert's user info into the database.
The model contains the user info as part of the role values.
"""
user_ids = list(set(user_ids)) # cleanse data
# Check for existing records to update.
cursor.execute("SELECT username from users where use... |
Given a set of user identifiers ( user_ids ) upsert them into the database after checking accounts for the latest information. | def upsert_users(cursor, user_ids):
"""Given a set of user identifiers (``user_ids``),
upsert them into the database after checking accounts for
the latest information.
"""
accounts = get_current_registry().getUtility(IOpenstaxAccounts)
def lookup_profile(username):
profile = accounts.g... |
Notify all users about their role and/ or license acceptance for a piece of content associated with the given document_id. | def notify_users(cursor, document_id):
"""Notify all users about their role and/or license acceptance
for a piece of content associated with the given ``document_id``.
"""
return
registry = get_current_registry()
accounts = registry.getUtility(IOpenstaxAccounts)
cursor.execute("""\
SELECT l... |
This sets the post - publication state in the database. | def set_post_publications_state(cursor, module_ident, state_name,
state_message=''): # pragma: no cover
"""This sets the post-publication state in the database."""
cursor.execute("""\
INSERT INTO post_publications
(module_ident, state, state_message)
VALUES (%s, %s, %s)""", ... |
This updates the module s state in the database. | def update_module_state(cursor, module_ident,
state_name, recipe): # pragma: no cover
"""This updates the module's state in the database."""
cursor.execute("""\
UPDATE modules
SET stateid = (
SELECT stateid FROM modulestates WHERE statename = %s
), recipe = %s, baked = now() WHERE m... |
Return the list of publications that need moderation. | def get_moderation(request):
"""Return the list of publications that need moderation."""
with db_connect() as db_conn:
with db_conn.cursor() as cursor:
cursor.execute("""\
SELECT row_to_json(combined_rows) FROM (
SELECT id, created, publisher, publication_message,
(select array_ag... |
Configures the session manager | def includeme(config):
"""Configures the session manager"""
settings = config.registry.settings
session_factory = SignedCookieSessionFactory(settings['session_key'])
config.set_session_factory(session_factory) |
Returns a dictionary of all unique print_styles and their latest tag revision and recipe_type. | def admin_print_styles(request):
"""
Returns a dictionary of all unique print_styles, and their latest tag,
revision, and recipe_type.
"""
styles = []
# This fetches all recipes that have been used to successfully bake a
# current book plus all default recipes that have not yet been used
... |
Returns all books with any version of the given print style. | def admin_print_styles_single(request):
""" Returns all books with any version of the given print style.
Returns the print_style, recipe type, num books using the print_style,
along with a dictionary of the book, author, revision date, recipe,
tag of the print_style, and a link to the content.
"""
... |
Return the list of API keys. | def get_api_keys(request):
"""Return the list of API keys."""
with db_connect() as db_conn:
with db_conn.cursor() as cursor:
cursor.execute("""\
SELECT row_to_json(combined_rows) FROM (
SELECT id, key, name, groups FROM api_keys
) AS combined_rows""")
api_keys = [x[0] for x in ... |
Creates SQL to get info on baking books filtered from GET request. | def get_baking_statuses_sql(get_request):
""" Creates SQL to get info on baking books filtered from GET request.
All books that have ever attempted to bake will be retured if they
pass the filters in the GET request.
If a single book has been requested to bake multiple times there will
be a row for... |
Returns a dictionary with the states and info of baking books and the filters from the GET request to pre - populate the form. | def admin_content_status(request):
"""
Returns a dictionary with the states and info of baking books,
and the filters from the GET request to pre-populate the form.
"""
statement, sql_args = get_baking_statuses_sql(request.GET)
states = []
status_filters = request.params.getall('status_filt... |
Returns a dictionary with all the past baking statuses of a single book. | def admin_content_status_single(request):
"""
Returns a dictionary with all the past baking statuses of a single book.
"""
uuid = request.matchdict['uuid']
try:
UUID(uuid)
except ValueError:
raise httpexceptions.HTTPBadRequest(
'{} is not a valid uuid'.format(uuid))
... |
Retriggers baking for a given book. | def admin_content_status_single_POST(request):
""" Retriggers baking for a given book. """
args = admin_content_status_single(request)
title = args['title']
if args['current_state'] == 'SUCCESS':
args['response'] = title + ' is not stale, no need to bake'
return args
with db_connect... |
Inserts the optional roles if values for the optional roles exist. | def _insert_optional_roles(cursor, model, ident):
"""Inserts the optional roles if values for the optional roles
exist.
"""
optional_roles = [
# (<metadata-attr>, <db-role-id>,),
('translators', 4,),
('editors', 5,),
]
for attr, role_id in optional_roles:
roles = ... |
Insert a module with the given metadata. | def _insert_metadata(cursor, model, publisher, message):
"""Insert a module with the given ``metadata``."""
params = model.metadata.copy()
params['publisher'] = publisher
params['publication_message'] = message
params['_portal_type'] = _model_to_portaltype(model)
params['summary'] = str(cnxepub... |
Return the SHA1 hash of the given a file - like object as file. This will seek the file back to 0 when it s finished. | def _get_file_sha1(file):
"""Return the SHA1 hash of the given a file-like object as ``file``.
This will seek the file back to 0 when it's finished.
"""
bits = file.read()
file.seek(0)
h = hashlib.new('sha1', bits).hexdigest()
return h |
Upsert the file and media_type into the files table. Returns the fileid and sha1 of the upserted file. | def _insert_file(cursor, file, media_type):
"""Upsert the ``file`` and ``media_type`` into the files table.
Returns the ``fileid`` and ``sha1`` of the upserted file.
"""
resource_hash = _get_file_sha1(file)
cursor.execute("SELECT fileid FROM files WHERE sha1 = %s",
(resource_hash... |
Insert a resource into the modules_files table. This will create a new file entry or associates an existing one. | def _insert_resource_file(cursor, module_ident, resource):
"""Insert a resource into the modules_files table. This will
create a new file entry or associates an existing one.
"""
with resource.open() as file:
fileid, _ = _insert_file(cursor, file, resource.media_type)
# Is this file legitim... |
Inserts a binder tree into the archive. | def _insert_tree(cursor, tree, parent_id=None, index=0, is_collated=False):
"""Inserts a binder tree into the archive."""
if isinstance(tree, dict):
if tree['id'] == 'subcol':
document_id = None
title = tree['title']
else:
cursor.execute("""\
SELEC... |
Publishes the model and return its ident_hash. | def publish_model(cursor, model, publisher, message):
"""Publishes the ``model`` and return its ident_hash."""
publishers = publisher
if isinstance(publishers, list) and len(publishers) > 1:
raise ValueError("Only one publisher is allowed. '{}' "
"were given: {}"
... |
Publishes the model and return its ident_hash. | def publish_composite_model(cursor, model, parent_model, publisher, message):
"""Publishes the ``model`` and return its ident_hash."""
if not (isinstance(model, CompositeDocument) or
(isinstance(model, Binder) and
model.metadata.get('type') == 'composite-chapter')):
raise Val... |
Publish a given module s collated content in the context of the parent_model. Note the model s content is expected to already have the collated content. This will just persist that content to the archive. | def publish_collated_document(cursor, model, parent_model):
"""Publish a given `module`'s collated content in the context of
the `parent_model`. Note, the model's content is expected to already
have the collated content. This will just persist that content to
the archive.
"""
html = bytes(cnxep... |
Publish a given collated tree ( containing newly added CompositeDocument objects and number inforation ) alongside the original tree. | def publish_collated_tree(cursor, tree):
"""Publish a given collated `tree` (containing newly added
`CompositeDocument` objects and number inforation)
alongside the original tree.
"""
tree = _insert_tree(cursor, tree, is_collated=True)
return tree |
Republish the Binders that share Documents in the publication context. This needs to be given all the models in the publication context. | def republish_binders(cursor, models):
"""Republish the Binders that share Documents in the publication context.
This needs to be given all the models in the publication context."""
documents = set([])
binders = set([])
history_mapping = {} # <previous-ident-hash>: <current-ident-hash>
if not i... |
Get the previous publication of the given publication as an ident - hash. | def get_previous_publication(cursor, ident_hash):
"""Get the previous publication of the given
publication as an ident-hash.
"""
cursor.execute("""\
WITH contextual_module AS (
SELECT uuid, module_ident
FROM modules
WHERE ident_hash(uuid, major_version, minor_version) = %s)
SELECT ident_hash(m.uui... |
Bump to the next version of the given content identified by uuid. Returns the next available version as a version tuple containing major and minor version. If is_minor_bump is True the version will minor bump. That is 1. 2 becomes 1. 3 in the case of Collections. And 2 becomes 3 for Modules regardless of this option. | def bump_version(cursor, uuid, is_minor_bump=False):
"""Bump to the next version of the given content identified
by ``uuid``. Returns the next available version as a version tuple,
containing major and minor version.
If ``is_minor_bump`` is ``True`` the version will minor bump. That is
1.2 becomes 1... |
Republish the collection identified as ident_hash with the given version. | def republish_collection(cursor, ident_hash, version):
"""Republish the collection identified as ``ident_hash`` with
the given ``version``.
"""
if not isinstance(version, (list, tuple,)):
split_version = version.split('.')
if len(split_version) == 1:
split_version.append(None... |
Create a new tree for the collection based on the old tree but with new document ids | def rebuild_collection_tree(cursor, ident_hash, history_map):
"""Create a new tree for the collection based on the old tree but with
new document ids
"""
collection_tree_sql = """\
WITH RECURSIVE t(nodeid, parent_id, documentid, title, childorder, latest,
ident_hash, path) AS (
SELECT... |
Accept a publication request at form value epub | def publish(request):
"""Accept a publication request at form value 'epub'"""
if 'epub' not in request.POST:
raise httpexceptions.HTTPBadRequest("Missing EPUB in POST body.")
is_pre_publication = asbool(request.POST.get('pre-publication'))
epub_upload = request.POST['epub'].file
try:
... |
Lookup publication state | def get_publication(request):
"""Lookup publication state"""
publication_id = request.matchdict['id']
state, messages = check_publication_state(publication_id)
response_data = {
'publication': publication_id,
'state': state,
'messages': messages,
}
return response_data |
This produces JSON data for a user ( at uid ) to view the license ( s ) they have accepted or will need to accept for a publication ( at id ). | def get_accept_license(request):
"""This produces JSON data for a user (at ``uid``) to view the license(s)
they have accepted or will need to accept for a publication (at ``id``).
"""
publication_id = request.matchdict['id']
user_id = request.matchdict['uid']
# FIXME Is this an active publicati... |
Allows the user ( at uid ) to accept the license ( s ) for a publication ( at id ). | def post_accept_license(request):
"""Allows the user (at ``uid``) to accept the license(s) for
a publication (at ``id``).
"""
publication_id = request.matchdict['id']
uid = request.matchdict['uid']
# TODO Verify the accepting user is the one making the request.
# They could be authenti... |
Invoke the baking process - trigger post - publication | def bake_content(request):
"""Invoke the baking process - trigger post-publication"""
ident_hash = request.matchdict['ident_hash']
try:
id, version = split_ident_hash(ident_hash)
except IdentHashError:
raise httpexceptions.HTTPNotFound()
if not version:
raise httpexceptions.... |
Configures the caching manager | def includeme(config):
"""Configures the caching manager"""
global cache_manager
settings = config.registry.settings
cache_manager = CacheManager(**parse_cache_config_options(settings)) |
A factory for creating a Postgres Notification Event ( an object inheriting from cnxpublishing. events. PGNotifyEvent ) given notif a psycopg2. extensions. Notify object. | def create_pg_notify_event(notif):
"""A factory for creating a Postgres Notification Event
(an object inheriting from `cnxpublishing.events.PGNotifyEvent`)
given `notif`, a `psycopg2.extensions.Notify` object.
"""
# TODO Lookup registered events via getAllUtilitiesRegisteredFor
# for class... |
Method for adding mapping definitions: param type_from: source type: param type_to: target type: param mapping: dictionary of mapping definitions in a form { target_property_name lambda function from rhe source }: return: None | def create_map(self, type_from, type_to, mapping=None):
"""Method for adding mapping definitions
:param type_from: source type
:param type_to: target type
:param mapping: dictionary of mapping definitions in a form {'target_property_name',
lambda function f... |
Method for creating target object instance: param from_obj: source object to be mapped from: param to_type: target type: param ignore_case: if set to true ignores attribute case when performing the mapping: param allow_none: if set to true returns None if the source object is None ; otherwise throws an exception: param... | def map(self, from_obj, to_type, ignore_case=False, allow_none=False, excluded=None):
"""Method for creating target object instance
:param from_obj: source object to be mapped from
:param to_type: target type
:param ignore_case: if set to true, ignores attribute case when performin... |
Gets the value from the key. If the key doesn t exist the default value is returned otherwise None. | def get(self, key, default=_sentinel):
"""
Gets the value from the key.
If the key doesn't exist, the default value is returned, otherwise None.
:param key: The key
:param default: The default value
:return: The value
"""
tup = self._data.get(key.lower())... |
Removes the specified key and returns the corresponding value. If key is not found the default is returned if given otherwise KeyError is raised. | def pop(self, key, default=_sentinel):
"""
Removes the specified key and returns the corresponding value.
If key is not found, the default is returned if given, otherwise KeyError is raised.
:param key: The key
:param default: The default value
:return: The value
... |
Iterate reversal points in the series. | def reversals(series, left=False, right=False):
"""Iterate reversal points in the series.
A reversal point is a point in the series at which the first derivative
changes sign. Reversal is undefined at the first (last) point because the
derivative before (after) this point is undefined. The first and th... |
Decorator for extract_cycles | def _sort_lows_and_highs(func):
"Decorator for extract_cycles"
@functools.wraps(func)
def wrapper(*args, **kwargs):
for low, high, mult in func(*args, **kwargs):
if low < high:
yield low, high, mult
else:
yield high, low, mult
return wrappe... |
Iterate cycles in the series. | def extract_cycles(series, left=False, right=False):
"""Iterate cycles in the series.
Parameters
----------
series : iterable sequence of numbers
left: bool, optional
If True, treat the first point in the series as a reversal.
right: bool, optional
If True, treat the last point ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.