repository_name stringlengths 5 67 | func_path_in_repository stringlengths 4 234 | func_name stringlengths 0 314 | whole_func_string stringlengths 52 3.87M | language stringclasses 6
values | func_code_string stringlengths 52 3.87M | func_code_tokens listlengths 15 672k | func_documentation_string stringlengths 1 47.2k | func_documentation_tokens listlengths 1 3.92k | split_name stringclasses 1
value | func_code_url stringlengths 85 339 |
|---|---|---|---|---|---|---|---|---|---|---|
PlaidWeb/Publ | publ/rendering.py | render_publ_template | def render_publ_template(template, **kwargs):
""" Render out a template, providing the image function based on the args.
Returns tuple of (rendered text, etag)
"""
text = render_template(
template.filename,
template=template,
image=image_function(
template=template,
category=kwargs.get('category'),
entry=kwargs.get('entry')),
**kwargs
)
return text, caching.get_etag(text) | python | def render_publ_template(template, **kwargs):
""" Render out a template, providing the image function based on the args.
Returns tuple of (rendered text, etag)
"""
text = render_template(
template.filename,
template=template,
image=image_function(
template=template,
category=kwargs.get('category'),
entry=kwargs.get('entry')),
**kwargs
)
return text, caching.get_etag(text) | [
"def",
"render_publ_template",
"(",
"template",
",",
"*",
"*",
"kwargs",
")",
":",
"text",
"=",
"render_template",
"(",
"template",
".",
"filename",
",",
"template",
"=",
"template",
",",
"image",
"=",
"image_function",
"(",
"template",
"=",
"template",
",",... | Render out a template, providing the image function based on the args.
Returns tuple of (rendered text, etag) | [
"Render",
"out",
"a",
"template",
"providing",
"the",
"image",
"function",
"based",
"on",
"the",
"args",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/rendering.py#L116-L131 |
PlaidWeb/Publ | publ/rendering.py | render_error | def render_error(category, error_message, error_codes, exception=None):
""" Render an error page.
Arguments:
category -- The category of the request
error_message -- The message to provide to the error template
error_codes -- The applicable HTTP error code(s). Will usually be an
integer or a list of integers; the HTTP error response will always
be the first error code in the list, and the others are alternates
for looking up the error template to use.
exception -- Any exception that led to this error page
"""
if isinstance(error_codes, int):
error_codes = [error_codes]
error_code = error_codes[0]
template_list = [str(code) for code in error_codes]
template_list.append(str(int(error_code / 100) * 100))
template_list.append('error')
template = map_template(category, template_list)
if template:
return render_publ_template(
template,
_url_root=request.url_root,
category=Category(category),
error={'code': error_code, 'message': error_message},
exception=exception)[0], error_code
# no template found, so fall back to default Flask handler
return flask.abort(error_code) | python | def render_error(category, error_message, error_codes, exception=None):
""" Render an error page.
Arguments:
category -- The category of the request
error_message -- The message to provide to the error template
error_codes -- The applicable HTTP error code(s). Will usually be an
integer or a list of integers; the HTTP error response will always
be the first error code in the list, and the others are alternates
for looking up the error template to use.
exception -- Any exception that led to this error page
"""
if isinstance(error_codes, int):
error_codes = [error_codes]
error_code = error_codes[0]
template_list = [str(code) for code in error_codes]
template_list.append(str(int(error_code / 100) * 100))
template_list.append('error')
template = map_template(category, template_list)
if template:
return render_publ_template(
template,
_url_root=request.url_root,
category=Category(category),
error={'code': error_code, 'message': error_message},
exception=exception)[0], error_code
# no template found, so fall back to default Flask handler
return flask.abort(error_code) | [
"def",
"render_error",
"(",
"category",
",",
"error_message",
",",
"error_codes",
",",
"exception",
"=",
"None",
")",
":",
"if",
"isinstance",
"(",
"error_codes",
",",
"int",
")",
":",
"error_codes",
"=",
"[",
"error_codes",
"]",
"error_code",
"=",
"error_co... | Render an error page.
Arguments:
category -- The category of the request
error_message -- The message to provide to the error template
error_codes -- The applicable HTTP error code(s). Will usually be an
integer or a list of integers; the HTTP error response will always
be the first error code in the list, and the others are alternates
for looking up the error template to use.
exception -- Any exception that led to this error page | [
"Render",
"an",
"error",
"page",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/rendering.py#L135-L167 |
PlaidWeb/Publ | publ/rendering.py | render_exception | def render_exception(error):
""" Catch-all renderer for the top-level exception handler """
_, _, category = str.partition(request.path, '/')
qsize = index.queue_length()
if isinstance(error, http_error.NotFound) and qsize:
response = flask.make_response(render_error(
category, "Site reindex in progress (qs={})".format(qsize), 503))
response.headers['Retry-After'] = qsize
response.headers['Refresh'] = max(5, qsize / 5)
return response, 503
if isinstance(error, http_error.HTTPException):
return render_error(category, error.name, error.code, exception={
'type': type(error).__name__,
'str': error.description,
'args': error.args
})
return render_error(category, "Exception occurred", 500, exception={
'type': type(error).__name__,
'str': str(error),
'args': error.args
}) | python | def render_exception(error):
""" Catch-all renderer for the top-level exception handler """
_, _, category = str.partition(request.path, '/')
qsize = index.queue_length()
if isinstance(error, http_error.NotFound) and qsize:
response = flask.make_response(render_error(
category, "Site reindex in progress (qs={})".format(qsize), 503))
response.headers['Retry-After'] = qsize
response.headers['Refresh'] = max(5, qsize / 5)
return response, 503
if isinstance(error, http_error.HTTPException):
return render_error(category, error.name, error.code, exception={
'type': type(error).__name__,
'str': error.description,
'args': error.args
})
return render_error(category, "Exception occurred", 500, exception={
'type': type(error).__name__,
'str': str(error),
'args': error.args
}) | [
"def",
"render_exception",
"(",
"error",
")",
":",
"_",
",",
"_",
",",
"category",
"=",
"str",
".",
"partition",
"(",
"request",
".",
"path",
",",
"'/'",
")",
"qsize",
"=",
"index",
".",
"queue_length",
"(",
")",
"if",
"isinstance",
"(",
"error",
","... | Catch-all renderer for the top-level exception handler | [
"Catch",
"-",
"all",
"renderer",
"for",
"the",
"top",
"-",
"level",
"exception",
"handler"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/rendering.py#L170-L193 |
PlaidWeb/Publ | publ/rendering.py | render_path_alias | def render_path_alias(path):
""" Render a known path-alias (used primarily for forced .php redirects) """
redir = path_alias.get_redirect('/' + path)
if not redir:
raise http_error.NotFound("Path redirection not found")
return redir | python | def render_path_alias(path):
""" Render a known path-alias (used primarily for forced .php redirects) """
redir = path_alias.get_redirect('/' + path)
if not redir:
raise http_error.NotFound("Path redirection not found")
return redir | [
"def",
"render_path_alias",
"(",
"path",
")",
":",
"redir",
"=",
"path_alias",
".",
"get_redirect",
"(",
"'/'",
"+",
"path",
")",
"if",
"not",
"redir",
":",
"raise",
"http_error",
".",
"NotFound",
"(",
"\"Path redirection not found\"",
")",
"return",
"redir"
] | Render a known path-alias (used primarily for forced .php redirects) | [
"Render",
"a",
"known",
"path",
"-",
"alias",
"(",
"used",
"primarily",
"for",
"forced",
".",
"php",
"redirects",
")"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/rendering.py#L197-L203 |
PlaidWeb/Publ | publ/rendering.py | render_category | def render_category(category='', template=None):
""" Render a category page.
Arguments:
category -- The category to render
template -- The template to render it with
"""
# pylint:disable=too-many-return-statements
# See if this is an aliased path
redir = get_redirect()
if redir:
return redir
# Forbidden template types
if template and template.startswith('_'):
raise http_error.Forbidden("Template is private")
if template in ['entry', 'error']:
raise http_error.BadRequest("Invalid view requested")
if category:
# See if there's any entries for the view...
if not orm.select(e for e in model.Entry if e.category == category or
e.category.startswith(category + '/')):
raise http_error.NotFound("No such category")
if not template:
template = Category(category).get('Index-Template') or 'index'
tmpl = map_template(category, template)
if not tmpl:
# this might actually be a malformed category URL
test_path = '/'.join((category, template)) if category else template
logger.debug("Checking for malformed category %s", test_path)
record = orm.select(
e for e in model.Entry if e.category == test_path).exists()
if record:
return redirect(url_for('category', category=test_path, **request.args))
# nope, we just don't know what this is
raise http_error.NotFound("No such view")
view_spec = view.parse_view_spec(request.args)
view_spec['category'] = category
view_obj = view.View(view_spec)
rendered, etag = render_publ_template(
tmpl,
_url_root=request.url_root,
category=Category(category),
view=view_obj)
if request.if_none_match.contains(etag):
return 'Not modified', 304
return rendered, {'Content-Type': mime_type(tmpl),
'ETag': etag} | python | def render_category(category='', template=None):
""" Render a category page.
Arguments:
category -- The category to render
template -- The template to render it with
"""
# pylint:disable=too-many-return-statements
# See if this is an aliased path
redir = get_redirect()
if redir:
return redir
# Forbidden template types
if template and template.startswith('_'):
raise http_error.Forbidden("Template is private")
if template in ['entry', 'error']:
raise http_error.BadRequest("Invalid view requested")
if category:
# See if there's any entries for the view...
if not orm.select(e for e in model.Entry if e.category == category or
e.category.startswith(category + '/')):
raise http_error.NotFound("No such category")
if not template:
template = Category(category).get('Index-Template') or 'index'
tmpl = map_template(category, template)
if not tmpl:
# this might actually be a malformed category URL
test_path = '/'.join((category, template)) if category else template
logger.debug("Checking for malformed category %s", test_path)
record = orm.select(
e for e in model.Entry if e.category == test_path).exists()
if record:
return redirect(url_for('category', category=test_path, **request.args))
# nope, we just don't know what this is
raise http_error.NotFound("No such view")
view_spec = view.parse_view_spec(request.args)
view_spec['category'] = category
view_obj = view.View(view_spec)
rendered, etag = render_publ_template(
tmpl,
_url_root=request.url_root,
category=Category(category),
view=view_obj)
if request.if_none_match.contains(etag):
return 'Not modified', 304
return rendered, {'Content-Type': mime_type(tmpl),
'ETag': etag} | [
"def",
"render_category",
"(",
"category",
"=",
"''",
",",
"template",
"=",
"None",
")",
":",
"# pylint:disable=too-many-return-statements",
"# See if this is an aliased path",
"redir",
"=",
"get_redirect",
"(",
")",
"if",
"redir",
":",
"return",
"redir",
"# Forbidden... | Render a category page.
Arguments:
category -- The category to render
template -- The template to render it with | [
"Render",
"a",
"category",
"page",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/rendering.py#L207-L265 |
PlaidWeb/Publ | publ/rendering.py | render_entry | def render_entry(entry_id, slug_text='', category=''):
""" Render an entry page.
Arguments:
entry_id -- The numeric ID of the entry to render
slug_text -- The expected URL slug text
category -- The expected category
"""
# pylint: disable=too-many-return-statements
# check if it's a valid entry
record = model.Entry.get(id=entry_id)
if not record:
# It's not a valid entry, so see if it's a redirection
path_redirect = get_redirect()
if path_redirect:
return path_redirect
logger.info("Attempted to retrieve nonexistent entry %d", entry_id)
raise http_error.NotFound("No such entry")
# see if the file still exists
if not os.path.isfile(record.file_path):
expire_record(record)
# See if there's a redirection
path_redirect = get_redirect()
if path_redirect:
return path_redirect
raise http_error.NotFound("No such entry")
# Show an access denied error if the entry has been set to draft mode
if record.status == model.PublishStatus.DRAFT.value:
raise http_error.Forbidden("Entry not available")
# Show a gone error if the entry has been deleted
if record.status == model.PublishStatus.GONE.value:
raise http_error.Gone()
# check if the canonical URL matches
if record.category != category or record.slug_text != slug_text:
# This could still be a redirected path...
path_redirect = get_redirect()
if path_redirect:
return path_redirect
# Redirect to the canonical URL
return redirect(url_for('entry',
entry_id=entry_id,
category=record.category,
slug_text=record.slug_text))
# if the entry canonically redirects, do that now
entry_redirect = record.redirect_url
if entry_redirect:
return redirect(entry_redirect)
entry_template = (record.entry_template
or Category(category).get('Entry-Template')
or 'entry')
tmpl = map_template(category, entry_template)
if not tmpl:
raise http_error.BadRequest("Missing entry template")
# Get the viewable entry
entry_obj = Entry(record)
# does the entry-id header mismatch? If so the old one is invalid
if int(entry_obj.get('Entry-ID')) != record.id:
expire_record(record)
return redirect(url_for('entry', entry_id=int(entry_obj.get('Entry-Id'))))
rendered, etag = render_publ_template(
tmpl,
_url_root=request.url_root,
entry=entry_obj,
category=Category(category))
if request.if_none_match.contains(etag):
return 'Not modified', 304
return rendered, {'Content-Type': mime_type(tmpl),
'ETag': etag} | python | def render_entry(entry_id, slug_text='', category=''):
""" Render an entry page.
Arguments:
entry_id -- The numeric ID of the entry to render
slug_text -- The expected URL slug text
category -- The expected category
"""
# pylint: disable=too-many-return-statements
# check if it's a valid entry
record = model.Entry.get(id=entry_id)
if not record:
# It's not a valid entry, so see if it's a redirection
path_redirect = get_redirect()
if path_redirect:
return path_redirect
logger.info("Attempted to retrieve nonexistent entry %d", entry_id)
raise http_error.NotFound("No such entry")
# see if the file still exists
if not os.path.isfile(record.file_path):
expire_record(record)
# See if there's a redirection
path_redirect = get_redirect()
if path_redirect:
return path_redirect
raise http_error.NotFound("No such entry")
# Show an access denied error if the entry has been set to draft mode
if record.status == model.PublishStatus.DRAFT.value:
raise http_error.Forbidden("Entry not available")
# Show a gone error if the entry has been deleted
if record.status == model.PublishStatus.GONE.value:
raise http_error.Gone()
# check if the canonical URL matches
if record.category != category or record.slug_text != slug_text:
# This could still be a redirected path...
path_redirect = get_redirect()
if path_redirect:
return path_redirect
# Redirect to the canonical URL
return redirect(url_for('entry',
entry_id=entry_id,
category=record.category,
slug_text=record.slug_text))
# if the entry canonically redirects, do that now
entry_redirect = record.redirect_url
if entry_redirect:
return redirect(entry_redirect)
entry_template = (record.entry_template
or Category(category).get('Entry-Template')
or 'entry')
tmpl = map_template(category, entry_template)
if not tmpl:
raise http_error.BadRequest("Missing entry template")
# Get the viewable entry
entry_obj = Entry(record)
# does the entry-id header mismatch? If so the old one is invalid
if int(entry_obj.get('Entry-ID')) != record.id:
expire_record(record)
return redirect(url_for('entry', entry_id=int(entry_obj.get('Entry-Id'))))
rendered, etag = render_publ_template(
tmpl,
_url_root=request.url_root,
entry=entry_obj,
category=Category(category))
if request.if_none_match.contains(etag):
return 'Not modified', 304
return rendered, {'Content-Type': mime_type(tmpl),
'ETag': etag} | [
"def",
"render_entry",
"(",
"entry_id",
",",
"slug_text",
"=",
"''",
",",
"category",
"=",
"''",
")",
":",
"# pylint: disable=too-many-return-statements",
"# check if it's a valid entry",
"record",
"=",
"model",
".",
"Entry",
".",
"get",
"(",
"id",
"=",
"entry_id"... | Render an entry page.
Arguments:
entry_id -- The numeric ID of the entry to render
slug_text -- The expected URL slug text
category -- The expected category | [
"Render",
"an",
"entry",
"page",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/rendering.py#L269-L354 |
PlaidWeb/Publ | publ/rendering.py | render_transparent_chit | def render_transparent_chit():
""" Render a transparent chit for external, sized images """
if request.if_none_match.contains('chit') or request.if_modified_since:
return 'Not modified', 304
out_bytes = base64.b64decode(
"R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7")
return out_bytes, {'Content-Type': 'image/gif', 'ETag': 'chit',
'Last-Modified': 'Tue, 31 Jul 1990 08:00:00 -0000'} | python | def render_transparent_chit():
""" Render a transparent chit for external, sized images """
if request.if_none_match.contains('chit') or request.if_modified_since:
return 'Not modified', 304
out_bytes = base64.b64decode(
"R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7")
return out_bytes, {'Content-Type': 'image/gif', 'ETag': 'chit',
'Last-Modified': 'Tue, 31 Jul 1990 08:00:00 -0000'} | [
"def",
"render_transparent_chit",
"(",
")",
":",
"if",
"request",
".",
"if_none_match",
".",
"contains",
"(",
"'chit'",
")",
"or",
"request",
".",
"if_modified_since",
":",
"return",
"'Not modified'",
",",
"304",
"out_bytes",
"=",
"base64",
".",
"b64decode",
"... | Render a transparent chit for external, sized images | [
"Render",
"a",
"transparent",
"chit",
"for",
"external",
"sized",
"images"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/rendering.py#L357-L366 |
PlaidWeb/Publ | publ/rendering.py | retrieve_asset | def retrieve_asset(filename):
""" Retrieves a non-image asset associated with an entry """
record = model.Image.get(asset_name=filename)
if not record:
raise http_error.NotFound("File not found")
if not record.is_asset:
raise http_error.Forbidden()
return flask.send_file(record.file_path, conditional=True) | python | def retrieve_asset(filename):
""" Retrieves a non-image asset associated with an entry """
record = model.Image.get(asset_name=filename)
if not record:
raise http_error.NotFound("File not found")
if not record.is_asset:
raise http_error.Forbidden()
return flask.send_file(record.file_path, conditional=True) | [
"def",
"retrieve_asset",
"(",
"filename",
")",
":",
"record",
"=",
"model",
".",
"Image",
".",
"get",
"(",
"asset_name",
"=",
"filename",
")",
"if",
"not",
"record",
":",
"raise",
"http_error",
".",
"NotFound",
"(",
"\"File not found\"",
")",
"if",
"not",
... | Retrieves a non-image asset associated with an entry | [
"Retrieves",
"a",
"non",
"-",
"image",
"asset",
"associated",
"with",
"an",
"entry"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/rendering.py#L370-L379 |
PlaidWeb/Publ | publ/maintenance.py | Maintenance.run | def run(self, force=False):
""" Run all pending tasks; 'force' will run all tasks whether they're
pending or not. """
now = time.time()
for func, spec in self.tasks.items():
if force or now >= spec.get('next_run', 0):
func()
spec['next_run'] = now + spec['interval'] | python | def run(self, force=False):
""" Run all pending tasks; 'force' will run all tasks whether they're
pending or not. """
now = time.time()
for func, spec in self.tasks.items():
if force or now >= spec.get('next_run', 0):
func()
spec['next_run'] = now + spec['interval'] | [
"def",
"run",
"(",
"self",
",",
"force",
"=",
"False",
")",
":",
"now",
"=",
"time",
".",
"time",
"(",
")",
"for",
"func",
",",
"spec",
"in",
"self",
".",
"tasks",
".",
"items",
"(",
")",
":",
"if",
"force",
"or",
"now",
">=",
"spec",
".",
"g... | Run all pending tasks; 'force' will run all tasks whether they're
pending or not. | [
"Run",
"all",
"pending",
"tasks",
";",
"force",
"will",
"run",
"all",
"tasks",
"whether",
"they",
"re",
"pending",
"or",
"not",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/maintenance.py#L16-L23 |
PlaidWeb/Publ | publ/image/__init__.py | _get_asset | def _get_asset(file_path):
""" Get the database record for an asset file """
record = model.Image.get(file_path=file_path)
fingerprint = ','.join((utils.file_fingerprint(file_path),
str(RENDITION_VERSION)))
if not record or record.fingerprint != fingerprint:
# Reindex the file
logger.info("Updating image %s -> %s", file_path, fingerprint)
# compute the md5sum; from https://stackoverflow.com/a/3431838/318857
md5 = hashlib.md5()
md5.update(bytes(RENDITION_VERSION))
with open(file_path, 'rb') as file:
for chunk in iter(lambda: file.read(16384), b""):
md5.update(chunk)
values = {
'file_path': file_path,
'checksum': md5.hexdigest(),
'fingerprint': fingerprint,
}
try:
image = PIL.Image.open(file_path)
image = fix_orientation(image)
except IOError:
image = None
if image:
values['width'] = image.width
values['height'] = image.height
values['transparent'] = image.mode in ('RGBA', 'P')
values['is_asset'] = False
else:
# PIL could not figure out what file type this is, so treat it as
# an asset
values['is_asset'] = True
values['asset_name'] = os.path.join(values['checksum'][:5],
os.path.basename(file_path))
record = model.Image.get(file_path=file_path)
if record:
record.set(**values)
else:
record = model.Image(**values)
orm.commit()
return record | python | def _get_asset(file_path):
""" Get the database record for an asset file """
record = model.Image.get(file_path=file_path)
fingerprint = ','.join((utils.file_fingerprint(file_path),
str(RENDITION_VERSION)))
if not record or record.fingerprint != fingerprint:
# Reindex the file
logger.info("Updating image %s -> %s", file_path, fingerprint)
# compute the md5sum; from https://stackoverflow.com/a/3431838/318857
md5 = hashlib.md5()
md5.update(bytes(RENDITION_VERSION))
with open(file_path, 'rb') as file:
for chunk in iter(lambda: file.read(16384), b""):
md5.update(chunk)
values = {
'file_path': file_path,
'checksum': md5.hexdigest(),
'fingerprint': fingerprint,
}
try:
image = PIL.Image.open(file_path)
image = fix_orientation(image)
except IOError:
image = None
if image:
values['width'] = image.width
values['height'] = image.height
values['transparent'] = image.mode in ('RGBA', 'P')
values['is_asset'] = False
else:
# PIL could not figure out what file type this is, so treat it as
# an asset
values['is_asset'] = True
values['asset_name'] = os.path.join(values['checksum'][:5],
os.path.basename(file_path))
record = model.Image.get(file_path=file_path)
if record:
record.set(**values)
else:
record = model.Image(**values)
orm.commit()
return record | [
"def",
"_get_asset",
"(",
"file_path",
")",
":",
"record",
"=",
"model",
".",
"Image",
".",
"get",
"(",
"file_path",
"=",
"file_path",
")",
"fingerprint",
"=",
"','",
".",
"join",
"(",
"(",
"utils",
".",
"file_fingerprint",
"(",
"file_path",
")",
",",
... | Get the database record for an asset file | [
"Get",
"the",
"database",
"record",
"for",
"an",
"asset",
"file"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/__init__.py#L98-L144 |
PlaidWeb/Publ | publ/image/__init__.py | get_image | def get_image(path, search_path):
""" Get an Image object. If the path is given as absolute, it will be
relative to the content directory; otherwise it will be relative to the
search path.
path -- the image's filename
search_path -- a search path for the image (string or list of strings)
"""
if path.startswith('@'):
return StaticImage(path[1:], search_path)
if path.startswith('//') or '://' in path:
return RemoteImage(path, search_path)
if os.path.isabs(path):
file_path = utils.find_file(os.path.relpath(
path, '/'), config.content_folder)
else:
file_path = utils.find_file(path, search_path)
if not file_path:
return ImageNotFound(path, search_path)
record = _get_asset(file_path)
if record.is_asset:
return FileAsset(record, search_path)
return LocalImage(record, search_path) | python | def get_image(path, search_path):
""" Get an Image object. If the path is given as absolute, it will be
relative to the content directory; otherwise it will be relative to the
search path.
path -- the image's filename
search_path -- a search path for the image (string or list of strings)
"""
if path.startswith('@'):
return StaticImage(path[1:], search_path)
if path.startswith('//') or '://' in path:
return RemoteImage(path, search_path)
if os.path.isabs(path):
file_path = utils.find_file(os.path.relpath(
path, '/'), config.content_folder)
else:
file_path = utils.find_file(path, search_path)
if not file_path:
return ImageNotFound(path, search_path)
record = _get_asset(file_path)
if record.is_asset:
return FileAsset(record, search_path)
return LocalImage(record, search_path) | [
"def",
"get_image",
"(",
"path",
",",
"search_path",
")",
":",
"if",
"path",
".",
"startswith",
"(",
"'@'",
")",
":",
"return",
"StaticImage",
"(",
"path",
"[",
"1",
":",
"]",
",",
"search_path",
")",
"if",
"path",
".",
"startswith",
"(",
"'//'",
")"... | Get an Image object. If the path is given as absolute, it will be
relative to the content directory; otherwise it will be relative to the
search path.
path -- the image's filename
search_path -- a search path for the image (string or list of strings) | [
"Get",
"an",
"Image",
"object",
".",
"If",
"the",
"path",
"is",
"given",
"as",
"absolute",
"it",
"will",
"be",
"relative",
"to",
"the",
"content",
"directory",
";",
"otherwise",
"it",
"will",
"be",
"relative",
"to",
"the",
"search",
"path",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/__init__.py#L147-L173 |
PlaidWeb/Publ | publ/image/__init__.py | parse_arglist | def parse_arglist(args):
""" Parses an arglist into arguments for Image, as a kwargs dict """
# per https://stackoverflow.com/a/49723227/318857
args = 'f({})'.format(args)
tree = ast.parse(args)
funccall = tree.body[0].value
args = [ast.literal_eval(arg) for arg in funccall.args]
kwargs = {arg.arg: ast.literal_eval(arg.value)
for arg in funccall.keywords}
if len(args) > 2:
raise TypeError(
"Expected at most 2 positional args but {} were given".format(len(args)))
if len(args) >= 1:
kwargs['width'] = int(args[0])
if len(args) >= 2:
kwargs['height'] = int(args[1])
return kwargs | python | def parse_arglist(args):
""" Parses an arglist into arguments for Image, as a kwargs dict """
# per https://stackoverflow.com/a/49723227/318857
args = 'f({})'.format(args)
tree = ast.parse(args)
funccall = tree.body[0].value
args = [ast.literal_eval(arg) for arg in funccall.args]
kwargs = {arg.arg: ast.literal_eval(arg.value)
for arg in funccall.keywords}
if len(args) > 2:
raise TypeError(
"Expected at most 2 positional args but {} were given".format(len(args)))
if len(args) >= 1:
kwargs['width'] = int(args[0])
if len(args) >= 2:
kwargs['height'] = int(args[1])
return kwargs | [
"def",
"parse_arglist",
"(",
"args",
")",
":",
"# per https://stackoverflow.com/a/49723227/318857",
"args",
"=",
"'f({})'",
".",
"format",
"(",
"args",
")",
"tree",
"=",
"ast",
".",
"parse",
"(",
"args",
")",
"funccall",
"=",
"tree",
".",
"body",
"[",
"0",
... | Parses an arglist into arguments for Image, as a kwargs dict | [
"Parses",
"an",
"arglist",
"into",
"arguments",
"for",
"Image",
"as",
"a",
"kwargs",
"dict"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/__init__.py#L176-L197 |
PlaidWeb/Publ | publ/image/__init__.py | parse_alt_text | def parse_alt_text(alt):
""" Parses the arguments out from a Publ-Markdown alt text into a tuple of text, args """
match = re.match(r'([^\{]*)(\{(.*)\})$', alt)
if match:
alt = match.group(1)
args = parse_arglist(match.group(3))
else:
args = {}
return alt, args | python | def parse_alt_text(alt):
""" Parses the arguments out from a Publ-Markdown alt text into a tuple of text, args """
match = re.match(r'([^\{]*)(\{(.*)\})$', alt)
if match:
alt = match.group(1)
args = parse_arglist(match.group(3))
else:
args = {}
return alt, args | [
"def",
"parse_alt_text",
"(",
"alt",
")",
":",
"match",
"=",
"re",
".",
"match",
"(",
"r'([^\\{]*)(\\{(.*)\\})$'",
",",
"alt",
")",
"if",
"match",
":",
"alt",
"=",
"match",
".",
"group",
"(",
"1",
")",
"args",
"=",
"parse_arglist",
"(",
"match",
".",
... | Parses the arguments out from a Publ-Markdown alt text into a tuple of text, args | [
"Parses",
"the",
"arguments",
"out",
"from",
"a",
"Publ",
"-",
"Markdown",
"alt",
"text",
"into",
"a",
"tuple",
"of",
"text",
"args"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/__init__.py#L200-L209 |
PlaidWeb/Publ | publ/image/__init__.py | parse_image_spec | def parse_image_spec(spec):
""" Parses out a Publ-Markdown image spec into a tuple of path, args, title """
# I was having trouble coming up with a single RE that did it right,
# so let's just break it down into sub-problems. First, parse out the
# alt text...
match = re.match(r'(.+)\s+\"(.*)\"\s*$', spec)
if match:
spec, title = match.group(1, 2)
else:
title = None
# and now parse out the arglist
match = re.match(r'([^\{]*)(\{(.*)\})\s*$', spec)
if match:
spec = match.group(1)
args = parse_arglist(match.group(3))
else:
args = {}
return spec, args, (title and html.unescape(title)) | python | def parse_image_spec(spec):
""" Parses out a Publ-Markdown image spec into a tuple of path, args, title """
# I was having trouble coming up with a single RE that did it right,
# so let's just break it down into sub-problems. First, parse out the
# alt text...
match = re.match(r'(.+)\s+\"(.*)\"\s*$', spec)
if match:
spec, title = match.group(1, 2)
else:
title = None
# and now parse out the arglist
match = re.match(r'([^\{]*)(\{(.*)\})\s*$', spec)
if match:
spec = match.group(1)
args = parse_arglist(match.group(3))
else:
args = {}
return spec, args, (title and html.unescape(title)) | [
"def",
"parse_image_spec",
"(",
"spec",
")",
":",
"# I was having trouble coming up with a single RE that did it right,",
"# so let's just break it down into sub-problems. First, parse out the",
"# alt text...",
"match",
"=",
"re",
".",
"match",
"(",
"r'(.+)\\s+\\\"(.*)\\\"\\s*$'",
"... | Parses out a Publ-Markdown image spec into a tuple of path, args, title | [
"Parses",
"out",
"a",
"Publ",
"-",
"Markdown",
"image",
"spec",
"into",
"a",
"tuple",
"of",
"path",
"args",
"title"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/__init__.py#L212-L232 |
PlaidWeb/Publ | publ/image/__init__.py | get_spec_list | def get_spec_list(image_specs, container_args):
""" Given a list of specs and a set of container args, return a tuple of
the final container argument list and the original list size """
spec_list = [spec.strip() for spec in image_specs.split('|')]
original_count = len(spec_list)
if 'count' in container_args:
if 'count_offset' in container_args:
spec_list = spec_list[container_args['count_offset']:]
spec_list = spec_list[:container_args['count']]
return spec_list, original_count | python | def get_spec_list(image_specs, container_args):
""" Given a list of specs and a set of container args, return a tuple of
the final container argument list and the original list size """
spec_list = [spec.strip() for spec in image_specs.split('|')]
original_count = len(spec_list)
if 'count' in container_args:
if 'count_offset' in container_args:
spec_list = spec_list[container_args['count_offset']:]
spec_list = spec_list[:container_args['count']]
return spec_list, original_count | [
"def",
"get_spec_list",
"(",
"image_specs",
",",
"container_args",
")",
":",
"spec_list",
"=",
"[",
"spec",
".",
"strip",
"(",
")",
"for",
"spec",
"in",
"image_specs",
".",
"split",
"(",
"'|'",
")",
"]",
"original_count",
"=",
"len",
"(",
"spec_list",
")... | Given a list of specs and a set of container args, return a tuple of
the final container argument list and the original list size | [
"Given",
"a",
"list",
"of",
"specs",
"and",
"a",
"set",
"of",
"container",
"args",
"return",
"a",
"tuple",
"of",
"the",
"final",
"container",
"argument",
"list",
"and",
"the",
"original",
"list",
"size"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/__init__.py#L235-L247 |
PlaidWeb/Publ | publ/image/__init__.py | get_async | def get_async(filename):
""" Asynchronously fetch an image """
if os.path.isfile(os.path.join(config.static_folder, filename)):
return flask.redirect(flask.url_for('static', filename=filename))
retry_count = int(flask.request.args.get('retry_count', 0))
if retry_count < 10:
time.sleep(0.25) # ghastly hack to get the client to backoff a bit
return flask.redirect(flask.url_for('async',
filename=filename,
cb=random.randint(0, 2**48),
retry_count=retry_count + 1))
# the image isn't available yet; generate a placeholder and let the
# client attempt to re-fetch periodically, maybe
vals = [int(b) for b in hashlib.md5(
filename.encode('utf-8')).digest()[0:12]]
placeholder = PIL.Image.new('RGB', (2, 2))
placeholder.putdata(list(zip(vals[0::3], vals[1::3], vals[2::3])))
outbytes = io.BytesIO()
placeholder.save(outbytes, "PNG")
outbytes.seek(0)
response = flask.make_response(
flask.send_file(outbytes, mimetype='image/png'))
response.headers['Refresh'] = 5
return response | python | def get_async(filename):
""" Asynchronously fetch an image """
if os.path.isfile(os.path.join(config.static_folder, filename)):
return flask.redirect(flask.url_for('static', filename=filename))
retry_count = int(flask.request.args.get('retry_count', 0))
if retry_count < 10:
time.sleep(0.25) # ghastly hack to get the client to backoff a bit
return flask.redirect(flask.url_for('async',
filename=filename,
cb=random.randint(0, 2**48),
retry_count=retry_count + 1))
# the image isn't available yet; generate a placeholder and let the
# client attempt to re-fetch periodically, maybe
vals = [int(b) for b in hashlib.md5(
filename.encode('utf-8')).digest()[0:12]]
placeholder = PIL.Image.new('RGB', (2, 2))
placeholder.putdata(list(zip(vals[0::3], vals[1::3], vals[2::3])))
outbytes = io.BytesIO()
placeholder.save(outbytes, "PNG")
outbytes.seek(0)
response = flask.make_response(
flask.send_file(outbytes, mimetype='image/png'))
response.headers['Refresh'] = 5
return response | [
"def",
"get_async",
"(",
"filename",
")",
":",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"os",
".",
"path",
".",
"join",
"(",
"config",
".",
"static_folder",
",",
"filename",
")",
")",
":",
"return",
"flask",
".",
"redirect",
"(",
"flask",
".",
... | Asynchronously fetch an image | [
"Asynchronously",
"fetch",
"an",
"image"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/__init__.py#L261-L288 |
PlaidWeb/Publ | publ/image/image.py | Image.get_img_attrs | def get_img_attrs(self, style=None, **kwargs):
""" Get an attribute list (src, srcset, style, et al) for the image.
style -- an optional list of CSS style fragments
Returns: a dict of attributes e.g. {'src':'foo.jpg','srcset':'foo.jpg 1x, bar.jpg 2x']
"""
add = {}
if 'prefix' in kwargs:
attr_prefixes = kwargs.get('prefix')
if isinstance(kwargs['prefix'], str):
attr_prefixes = [attr_prefixes]
for prefix in attr_prefixes:
for k, val in kwargs.items():
if k.startswith(prefix):
add[k[len(prefix):]] = val
return self._get_img_attrs(style, {**kwargs, **add}) | python | def get_img_attrs(self, style=None, **kwargs):
""" Get an attribute list (src, srcset, style, et al) for the image.
style -- an optional list of CSS style fragments
Returns: a dict of attributes e.g. {'src':'foo.jpg','srcset':'foo.jpg 1x, bar.jpg 2x']
"""
add = {}
if 'prefix' in kwargs:
attr_prefixes = kwargs.get('prefix')
if isinstance(kwargs['prefix'], str):
attr_prefixes = [attr_prefixes]
for prefix in attr_prefixes:
for k, val in kwargs.items():
if k.startswith(prefix):
add[k[len(prefix):]] = val
return self._get_img_attrs(style, {**kwargs, **add}) | [
"def",
"get_img_attrs",
"(",
"self",
",",
"style",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"add",
"=",
"{",
"}",
"if",
"'prefix'",
"in",
"kwargs",
":",
"attr_prefixes",
"=",
"kwargs",
".",
"get",
"(",
"'prefix'",
")",
"if",
"isinstance",
"(",... | Get an attribute list (src, srcset, style, et al) for the image.
style -- an optional list of CSS style fragments
Returns: a dict of attributes e.g. {'src':'foo.jpg','srcset':'foo.jpg 1x, bar.jpg 2x'] | [
"Get",
"an",
"attribute",
"list",
"(",
"src",
"srcset",
"style",
"et",
"al",
")",
"for",
"the",
"image",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/image.py#L36-L55 |
PlaidWeb/Publ | publ/image/image.py | Image.get_img_tag | def get_img_tag(self, title='', alt_text='', **kwargs):
""" Build a <img> tag for the image with the specified options.
Returns: an HTML fragment. """
try:
style = []
for key in ('img_style', 'style'):
if key in kwargs:
if isinstance(kwargs[key], (list, tuple, set)):
style += list(kwargs[key])
else:
style.append(kwargs[key])
if 'shape' in kwargs:
shape = self._get_shape_style(**kwargs)
if shape:
style.append("shape-outside: url('{}')".format(shape))
attrs = {
'alt': alt_text,
'title': title,
**self.get_img_attrs(style, **kwargs)
}
return flask.Markup(
self._wrap_link_target(
kwargs,
utils.make_tag(
'img', attrs, start_end=kwargs.get('xhtml')),
title))
except FileNotFoundError as error:
text = '<span class="error">Image not found: <code>{}</code>'.format(
html.escape(error.filename))
if ' ' in error.filename:
text += ' (Did you forget a <code>|</code>?)'
text += '</span>'
return flask.Markup(text) | python | def get_img_tag(self, title='', alt_text='', **kwargs):
""" Build a <img> tag for the image with the specified options.
Returns: an HTML fragment. """
try:
style = []
for key in ('img_style', 'style'):
if key in kwargs:
if isinstance(kwargs[key], (list, tuple, set)):
style += list(kwargs[key])
else:
style.append(kwargs[key])
if 'shape' in kwargs:
shape = self._get_shape_style(**kwargs)
if shape:
style.append("shape-outside: url('{}')".format(shape))
attrs = {
'alt': alt_text,
'title': title,
**self.get_img_attrs(style, **kwargs)
}
return flask.Markup(
self._wrap_link_target(
kwargs,
utils.make_tag(
'img', attrs, start_end=kwargs.get('xhtml')),
title))
except FileNotFoundError as error:
text = '<span class="error">Image not found: <code>{}</code>'.format(
html.escape(error.filename))
if ' ' in error.filename:
text += ' (Did you forget a <code>|</code>?)'
text += '</span>'
return flask.Markup(text) | [
"def",
"get_img_tag",
"(",
"self",
",",
"title",
"=",
"''",
",",
"alt_text",
"=",
"''",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"style",
"=",
"[",
"]",
"for",
"key",
"in",
"(",
"'img_style'",
",",
"'style'",
")",
":",
"if",
"key",
"in",
... | Build a <img> tag for the image with the specified options.
Returns: an HTML fragment. | [
"Build",
"a",
"<img",
">",
"tag",
"for",
"the",
"image",
"with",
"the",
"specified",
"options",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/image.py#L57-L95 |
PlaidWeb/Publ | publ/image/image.py | Image.get_css_background | def get_css_background(self, uncomment=False, **kwargs):
""" Get the CSS background attributes for an element.
Additional arguments:
uncomment -- surround the attributes with `*/` and `/*` so that the
template tag can be kept inside a comment block, to keep syntax
highlighters happy
"""
text = self._css_background(**kwargs)
if uncomment:
text = ' */ {} /* '.format(text)
return text | python | def get_css_background(self, uncomment=False, **kwargs):
""" Get the CSS background attributes for an element.
Additional arguments:
uncomment -- surround the attributes with `*/` and `/*` so that the
template tag can be kept inside a comment block, to keep syntax
highlighters happy
"""
text = self._css_background(**kwargs)
if uncomment:
text = ' */ {} /* '.format(text)
return text | [
"def",
"get_css_background",
"(",
"self",
",",
"uncomment",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
":",
"text",
"=",
"self",
".",
"_css_background",
"(",
"*",
"*",
"kwargs",
")",
"if",
"uncomment",
":",
"text",
"=",
"' */ {} /* '",
".",
"format",
... | Get the CSS background attributes for an element.
Additional arguments:
uncomment -- surround the attributes with `*/` and `/*` so that the
template tag can be kept inside a comment block, to keep syntax
highlighters happy | [
"Get",
"the",
"CSS",
"background",
"attributes",
"for",
"an",
"element",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/image.py#L116-L130 |
PlaidWeb/Publ | publ/image/image.py | Image.get_fullsize | def get_fullsize(self, kwargs):
""" Get the fullsize rendition URL """
fullsize_args = {}
if 'absolute' in kwargs:
fullsize_args['absolute'] = kwargs['absolute']
for key in ('width', 'height', 'quality', 'format', 'background', 'crop'):
fsk = 'fullsize_' + key
if fsk in kwargs:
fullsize_args[key] = kwargs[fsk]
img_fullsize, _ = self.get_rendition(1, **fullsize_args)
return img_fullsize | python | def get_fullsize(self, kwargs):
""" Get the fullsize rendition URL """
fullsize_args = {}
if 'absolute' in kwargs:
fullsize_args['absolute'] = kwargs['absolute']
for key in ('width', 'height', 'quality', 'format', 'background', 'crop'):
fsk = 'fullsize_' + key
if fsk in kwargs:
fullsize_args[key] = kwargs[fsk]
img_fullsize, _ = self.get_rendition(1, **fullsize_args)
return img_fullsize | [
"def",
"get_fullsize",
"(",
"self",
",",
"kwargs",
")",
":",
"fullsize_args",
"=",
"{",
"}",
"if",
"'absolute'",
"in",
"kwargs",
":",
"fullsize_args",
"[",
"'absolute'",
"]",
"=",
"kwargs",
"[",
"'absolute'",
"]",
"for",
"key",
"in",
"(",
"'width'",
",",... | Get the fullsize rendition URL | [
"Get",
"the",
"fullsize",
"rendition",
"URL"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/image.py#L160-L173 |
PlaidWeb/Publ | publ/image/image.py | Image._fullsize_link_tag | def _fullsize_link_tag(self, kwargs, title):
""" Render a <a href> that points to the fullsize rendition specified """
return utils.make_tag('a', {
'href': self.get_fullsize(kwargs),
'data-lightbox': kwargs['gallery_id'],
'title': title
}) | python | def _fullsize_link_tag(self, kwargs, title):
""" Render a <a href> that points to the fullsize rendition specified """
return utils.make_tag('a', {
'href': self.get_fullsize(kwargs),
'data-lightbox': kwargs['gallery_id'],
'title': title
}) | [
"def",
"_fullsize_link_tag",
"(",
"self",
",",
"kwargs",
",",
"title",
")",
":",
"return",
"utils",
".",
"make_tag",
"(",
"'a'",
",",
"{",
"'href'",
":",
"self",
".",
"get_fullsize",
"(",
"kwargs",
")",
",",
"'data-lightbox'",
":",
"kwargs",
"[",
"'galle... | Render a <a href> that points to the fullsize rendition specified | [
"Render",
"a",
"<a",
"href",
">",
"that",
"points",
"to",
"the",
"fullsize",
"rendition",
"specified"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/image.py#L175-L182 |
PlaidWeb/Publ | publ/path_alias.py | set_alias | def set_alias(alias, **kwargs):
""" Set a path alias.
Arguments:
alias -- The alias specification
entry -- The entry to alias it to
category -- The category to alias it to
url -- The external URL to alias it to
"""
spec = alias.split()
path = spec[0]
values = {**kwargs, 'path': path}
if len(spec) > 1:
values['template'] = spec[1]
record = model.PathAlias.get(path=path)
if record:
record.set(**values)
else:
record = model.PathAlias(**values)
orm.commit()
return record | python | def set_alias(alias, **kwargs):
""" Set a path alias.
Arguments:
alias -- The alias specification
entry -- The entry to alias it to
category -- The category to alias it to
url -- The external URL to alias it to
"""
spec = alias.split()
path = spec[0]
values = {**kwargs, 'path': path}
if len(spec) > 1:
values['template'] = spec[1]
record = model.PathAlias.get(path=path)
if record:
record.set(**values)
else:
record = model.PathAlias(**values)
orm.commit()
return record | [
"def",
"set_alias",
"(",
"alias",
",",
"*",
"*",
"kwargs",
")",
":",
"spec",
"=",
"alias",
".",
"split",
"(",
")",
"path",
"=",
"spec",
"[",
"0",
"]",
"values",
"=",
"{",
"*",
"*",
"kwargs",
",",
"'path'",
":",
"path",
"}",
"if",
"len",
"(",
... | Set a path alias.
Arguments:
alias -- The alias specification
entry -- The entry to alias it to
category -- The category to alias it to
url -- The external URL to alias it to | [
"Set",
"a",
"path",
"alias",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/path_alias.py#L11-L38 |
PlaidWeb/Publ | publ/path_alias.py | remove_alias | def remove_alias(path):
""" Remove a path alias.
Arguments:
path -- the path to remove the alias of
"""
orm.delete(p for p in model.PathAlias if p.path == path)
orm.commit() | python | def remove_alias(path):
""" Remove a path alias.
Arguments:
path -- the path to remove the alias of
"""
orm.delete(p for p in model.PathAlias if p.path == path)
orm.commit() | [
"def",
"remove_alias",
"(",
"path",
")",
":",
"orm",
".",
"delete",
"(",
"p",
"for",
"p",
"in",
"model",
".",
"PathAlias",
"if",
"p",
".",
"path",
"==",
"path",
")",
"orm",
".",
"commit",
"(",
")"
] | Remove a path alias.
Arguments:
path -- the path to remove the alias of | [
"Remove",
"a",
"path",
"alias",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/path_alias.py#L42-L50 |
PlaidWeb/Publ | publ/path_alias.py | remove_aliases | def remove_aliases(target):
""" Remove all aliases to a destination """
if isinstance(target, model.Entry):
orm.delete(p for p in model.PathAlias if p.entry == target)
elif isinstance(target, model.Category):
orm.delete(p for p in model.PathAlias if p.category == target)
else:
raise TypeError("Unknown type {}".format(type(target)))
orm.commit() | python | def remove_aliases(target):
""" Remove all aliases to a destination """
if isinstance(target, model.Entry):
orm.delete(p for p in model.PathAlias if p.entry == target)
elif isinstance(target, model.Category):
orm.delete(p for p in model.PathAlias if p.category == target)
else:
raise TypeError("Unknown type {}".format(type(target)))
orm.commit() | [
"def",
"remove_aliases",
"(",
"target",
")",
":",
"if",
"isinstance",
"(",
"target",
",",
"model",
".",
"Entry",
")",
":",
"orm",
".",
"delete",
"(",
"p",
"for",
"p",
"in",
"model",
".",
"PathAlias",
"if",
"p",
".",
"entry",
"==",
"target",
")",
"e... | Remove all aliases to a destination | [
"Remove",
"all",
"aliases",
"to",
"a",
"destination"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/path_alias.py#L54-L63 |
PlaidWeb/Publ | publ/path_alias.py | get_alias | def get_alias(path):
""" Get a path alias for a single path
Returns a tuple of (url,is_permanent)
"""
# pylint:disable=too-many-return-statements
record = model.PathAlias.get(path=path)
if not record:
return None, None
template = record.template if record.template != 'index' else None
if record.entry and record.entry.visible:
if record.template:
# a template was requested, so we go to the category page
category = (record.category.category
if record.category else record.entry.category)
return url_for('category',
start=record.entry.id,
template=template,
category=category), True
from . import entry # pylint:disable=cyclic-import
outbound = entry.Entry(record.entry).get('Redirect-To')
if outbound:
# The entry has a Redirect-To (soft redirect) header
return outbound, False
return url_for('entry',
entry_id=record.entry.id,
category=record.entry.category,
slug_text=record.entry.slug_text), True
if record.category:
return url_for('category',
category=record.category.category,
template=template), True
if record.url:
# This is an outbound URL that might be changed by the user, so
# we don't do a 301 Permanently moved
return record.url, False
return None, None | python | def get_alias(path):
""" Get a path alias for a single path
Returns a tuple of (url,is_permanent)
"""
# pylint:disable=too-many-return-statements
record = model.PathAlias.get(path=path)
if not record:
return None, None
template = record.template if record.template != 'index' else None
if record.entry and record.entry.visible:
if record.template:
# a template was requested, so we go to the category page
category = (record.category.category
if record.category else record.entry.category)
return url_for('category',
start=record.entry.id,
template=template,
category=category), True
from . import entry # pylint:disable=cyclic-import
outbound = entry.Entry(record.entry).get('Redirect-To')
if outbound:
# The entry has a Redirect-To (soft redirect) header
return outbound, False
return url_for('entry',
entry_id=record.entry.id,
category=record.entry.category,
slug_text=record.entry.slug_text), True
if record.category:
return url_for('category',
category=record.category.category,
template=template), True
if record.url:
# This is an outbound URL that might be changed by the user, so
# we don't do a 301 Permanently moved
return record.url, False
return None, None | [
"def",
"get_alias",
"(",
"path",
")",
":",
"# pylint:disable=too-many-return-statements",
"record",
"=",
"model",
".",
"PathAlias",
".",
"get",
"(",
"path",
"=",
"path",
")",
"if",
"not",
"record",
":",
"return",
"None",
",",
"None",
"template",
"=",
"record... | Get a path alias for a single path
Returns a tuple of (url,is_permanent) | [
"Get",
"a",
"path",
"alias",
"for",
"a",
"single",
"path"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/path_alias.py#L66-L111 |
PlaidWeb/Publ | publ/path_alias.py | get_redirect | def get_redirect(paths):
""" Get a redirect from a path or list of paths
Arguments:
paths -- either a single path string, or a list of paths to check
Returns: a flask.redirect() result
"""
if isinstance(paths, str):
paths = [paths]
for path in paths:
url, permanent = get_alias(path)
if url:
return redirect(url, 301 if permanent else 302)
url, permanent = current_app.get_path_regex(path)
if url:
return redirect(url, 301 if permanent else 302)
return None | python | def get_redirect(paths):
""" Get a redirect from a path or list of paths
Arguments:
paths -- either a single path string, or a list of paths to check
Returns: a flask.redirect() result
"""
if isinstance(paths, str):
paths = [paths]
for path in paths:
url, permanent = get_alias(path)
if url:
return redirect(url, 301 if permanent else 302)
url, permanent = current_app.get_path_regex(path)
if url:
return redirect(url, 301 if permanent else 302)
return None | [
"def",
"get_redirect",
"(",
"paths",
")",
":",
"if",
"isinstance",
"(",
"paths",
",",
"str",
")",
":",
"paths",
"=",
"[",
"paths",
"]",
"for",
"path",
"in",
"paths",
":",
"url",
",",
"permanent",
"=",
"get_alias",
"(",
"path",
")",
"if",
"url",
":"... | Get a redirect from a path or list of paths
Arguments:
paths -- either a single path string, or a list of paths to check
Returns: a flask.redirect() result | [
"Get",
"a",
"redirect",
"from",
"a",
"path",
"or",
"list",
"of",
"paths"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/path_alias.py#L114-L136 |
PlaidWeb/Publ | publ/image/local.py | fix_orientation | def fix_orientation(image):
""" adapted from https://stackoverflow.com/a/30462851/318857
Apply Image.transpose to ensure 0th row of pixels is at the visual
top of the image, and 0th column is the visual left-hand side.
Return the original image if unable to determine the orientation.
As per CIPA DC-008-2012, the orientation field contains an integer,
1 through 8. Other values are reserved.
"""
exif_orientation_tag = 0x0112
exif_transpose_sequences = [
[],
[],
[PIL.Image.FLIP_LEFT_RIGHT],
[PIL.Image.ROTATE_180],
[PIL.Image.FLIP_TOP_BOTTOM],
[PIL.Image.FLIP_LEFT_RIGHT, PIL.Image.ROTATE_90],
[PIL.Image.ROTATE_270],
[PIL.Image.FLIP_TOP_BOTTOM, PIL.Image.ROTATE_90],
[PIL.Image.ROTATE_90],
]
try:
# pylint:disable=protected-access
orientation = image._getexif()[exif_orientation_tag]
sequence = exif_transpose_sequences[orientation]
return functools.reduce(type(image).transpose, sequence, image)
except (TypeError, AttributeError, KeyError):
# either no EXIF tags or no orientation tag
pass
return image | python | def fix_orientation(image):
""" adapted from https://stackoverflow.com/a/30462851/318857
Apply Image.transpose to ensure 0th row of pixels is at the visual
top of the image, and 0th column is the visual left-hand side.
Return the original image if unable to determine the orientation.
As per CIPA DC-008-2012, the orientation field contains an integer,
1 through 8. Other values are reserved.
"""
exif_orientation_tag = 0x0112
exif_transpose_sequences = [
[],
[],
[PIL.Image.FLIP_LEFT_RIGHT],
[PIL.Image.ROTATE_180],
[PIL.Image.FLIP_TOP_BOTTOM],
[PIL.Image.FLIP_LEFT_RIGHT, PIL.Image.ROTATE_90],
[PIL.Image.ROTATE_270],
[PIL.Image.FLIP_TOP_BOTTOM, PIL.Image.ROTATE_90],
[PIL.Image.ROTATE_90],
]
try:
# pylint:disable=protected-access
orientation = image._getexif()[exif_orientation_tag]
sequence = exif_transpose_sequences[orientation]
return functools.reduce(type(image).transpose, sequence, image)
except (TypeError, AttributeError, KeyError):
# either no EXIF tags or no orientation tag
pass
return image | [
"def",
"fix_orientation",
"(",
"image",
")",
":",
"exif_orientation_tag",
"=",
"0x0112",
"exif_transpose_sequences",
"=",
"[",
"[",
"]",
",",
"[",
"]",
",",
"[",
"PIL",
".",
"Image",
".",
"FLIP_LEFT_RIGHT",
"]",
",",
"[",
"PIL",
".",
"Image",
".",
"ROTAT... | adapted from https://stackoverflow.com/a/30462851/318857
Apply Image.transpose to ensure 0th row of pixels is at the visual
top of the image, and 0th column is the visual left-hand side.
Return the original image if unable to determine the orientation.
As per CIPA DC-008-2012, the orientation field contains an integer,
1 through 8. Other values are reserved. | [
"adapted",
"from",
"https",
":",
"//",
"stackoverflow",
".",
"com",
"/",
"a",
"/",
"30462851",
"/",
"318857"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L23-L55 |
PlaidWeb/Publ | publ/image/local.py | LocalImage.thread_pool | def thread_pool():
""" Get the rendition threadpool """
if not LocalImage._thread_pool:
logger.info("Starting LocalImage threadpool")
LocalImage._thread_pool = concurrent.futures.ThreadPoolExecutor(
thread_name_prefix="Renderer")
return LocalImage._thread_pool | python | def thread_pool():
""" Get the rendition threadpool """
if not LocalImage._thread_pool:
logger.info("Starting LocalImage threadpool")
LocalImage._thread_pool = concurrent.futures.ThreadPoolExecutor(
thread_name_prefix="Renderer")
return LocalImage._thread_pool | [
"def",
"thread_pool",
"(",
")",
":",
"if",
"not",
"LocalImage",
".",
"_thread_pool",
":",
"logger",
".",
"info",
"(",
"\"Starting LocalImage threadpool\"",
")",
"LocalImage",
".",
"_thread_pool",
"=",
"concurrent",
".",
"futures",
".",
"ThreadPoolExecutor",
"(",
... | Get the rendition threadpool | [
"Get",
"the",
"rendition",
"threadpool"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L65-L71 |
PlaidWeb/Publ | publ/image/local.py | LocalImage.get_rendition | def get_rendition(self, output_scale=1, **kwargs):
# pylint:disable=too-many-locals
"""
Get the rendition for this image, generating it if necessary.
Returns a tuple of `(relative_path, width, height)`, where relative_path
is relative to the static file directory (i.e. what one would pass into
`get_static()`)
output_scale -- the upsample factor for the requested rendition
Keyword arguments:
scale -- the downsample factor for the base rendition
scale_min_width -- the minimum width after downsampling
scale_min_height -- the minimum height after downsampling
crop -- box to crop the original image into (left, top, right, bottom)
width -- the width to target
height -- the height to target
max_width -- the maximum width
max_height -- the maximum height
resize -- how to fit the width and height; "fit", "fill", or "stretch"
fill_crop_x -- horizontal offset fraction for resize="fill"
fill_crop_y -- vertical offset fraction for resize="fill"
format -- output format
background -- background color when converting transparent to opaque
quality -- the JPEG quality to save the image as
quantize -- how large a palette to use for GIF or PNG images
"""
basename, ext = os.path.splitext(
os.path.basename(self._record.file_path))
basename = utils.make_slug(basename)
if kwargs.get('format'):
ext = '.' + kwargs['format']
# The spec for building the output filename
out_spec = [basename, self._record.checksum[-10:]]
out_args = {}
if ext in ['.png', '.jpg', '.jpeg']:
out_args['optimize'] = True
crop = self._parse_tuple_string(kwargs.get('crop'))
size, box = self.get_rendition_size(kwargs, output_scale, crop)
box = self._adjust_crop_box(box, crop)
if size and (size[0] < self._record.width or size[1] < self._record.height):
out_spec.append('x'.join([str(v) for v in size]))
if box:
# pylint:disable=not-an-iterable
out_spec.append('-'.join([str(v) for v in box]))
# Set RGBA flattening options
flatten = self._record.transparent and ext not in ['.png', '.gif']
if flatten and 'background' in kwargs:
bg_color = kwargs['background']
if isinstance(bg_color, (tuple, list)):
out_spec.append('b' + '-'.join([str(a) for a in bg_color]))
else:
out_spec.append('b' + str(bg_color))
# Set JPEG quality
if ext in ('.jpg', '.jpeg') and kwargs.get('quality'):
out_spec.append('q' + str(kwargs['quality']))
out_args['quality'] = kwargs['quality']
if ext in ('.jpg', '.jpeg'):
out_args['optimize'] = True
# Build the output filename
out_basename = '_'.join([str(s) for s in out_spec]) + ext
out_rel_path = os.path.join(
config.image_output_subdir,
self._record.checksum[0:2],
self._record.checksum[2:6],
out_basename)
out_fullpath = os.path.join(config.static_folder, out_rel_path)
if os.path.isfile(out_fullpath):
os.utime(out_fullpath)
return utils.static_url(out_rel_path, kwargs.get('absolute')), size
LocalImage.thread_pool().submit(
self._render, out_fullpath, size, box, flatten, kwargs, out_args)
return flask.url_for('async', filename=out_rel_path, _external=kwargs.get('absolute')), size | python | def get_rendition(self, output_scale=1, **kwargs):
# pylint:disable=too-many-locals
"""
Get the rendition for this image, generating it if necessary.
Returns a tuple of `(relative_path, width, height)`, where relative_path
is relative to the static file directory (i.e. what one would pass into
`get_static()`)
output_scale -- the upsample factor for the requested rendition
Keyword arguments:
scale -- the downsample factor for the base rendition
scale_min_width -- the minimum width after downsampling
scale_min_height -- the minimum height after downsampling
crop -- box to crop the original image into (left, top, right, bottom)
width -- the width to target
height -- the height to target
max_width -- the maximum width
max_height -- the maximum height
resize -- how to fit the width and height; "fit", "fill", or "stretch"
fill_crop_x -- horizontal offset fraction for resize="fill"
fill_crop_y -- vertical offset fraction for resize="fill"
format -- output format
background -- background color when converting transparent to opaque
quality -- the JPEG quality to save the image as
quantize -- how large a palette to use for GIF or PNG images
"""
basename, ext = os.path.splitext(
os.path.basename(self._record.file_path))
basename = utils.make_slug(basename)
if kwargs.get('format'):
ext = '.' + kwargs['format']
# The spec for building the output filename
out_spec = [basename, self._record.checksum[-10:]]
out_args = {}
if ext in ['.png', '.jpg', '.jpeg']:
out_args['optimize'] = True
crop = self._parse_tuple_string(kwargs.get('crop'))
size, box = self.get_rendition_size(kwargs, output_scale, crop)
box = self._adjust_crop_box(box, crop)
if size and (size[0] < self._record.width or size[1] < self._record.height):
out_spec.append('x'.join([str(v) for v in size]))
if box:
# pylint:disable=not-an-iterable
out_spec.append('-'.join([str(v) for v in box]))
# Set RGBA flattening options
flatten = self._record.transparent and ext not in ['.png', '.gif']
if flatten and 'background' in kwargs:
bg_color = kwargs['background']
if isinstance(bg_color, (tuple, list)):
out_spec.append('b' + '-'.join([str(a) for a in bg_color]))
else:
out_spec.append('b' + str(bg_color))
# Set JPEG quality
if ext in ('.jpg', '.jpeg') and kwargs.get('quality'):
out_spec.append('q' + str(kwargs['quality']))
out_args['quality'] = kwargs['quality']
if ext in ('.jpg', '.jpeg'):
out_args['optimize'] = True
# Build the output filename
out_basename = '_'.join([str(s) for s in out_spec]) + ext
out_rel_path = os.path.join(
config.image_output_subdir,
self._record.checksum[0:2],
self._record.checksum[2:6],
out_basename)
out_fullpath = os.path.join(config.static_folder, out_rel_path)
if os.path.isfile(out_fullpath):
os.utime(out_fullpath)
return utils.static_url(out_rel_path, kwargs.get('absolute')), size
LocalImage.thread_pool().submit(
self._render, out_fullpath, size, box, flatten, kwargs, out_args)
return flask.url_for('async', filename=out_rel_path, _external=kwargs.get('absolute')), size | [
"def",
"get_rendition",
"(",
"self",
",",
"output_scale",
"=",
"1",
",",
"*",
"*",
"kwargs",
")",
":",
"# pylint:disable=too-many-locals",
"basename",
",",
"ext",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"sel... | Get the rendition for this image, generating it if necessary.
Returns a tuple of `(relative_path, width, height)`, where relative_path
is relative to the static file directory (i.e. what one would pass into
`get_static()`)
output_scale -- the upsample factor for the requested rendition
Keyword arguments:
scale -- the downsample factor for the base rendition
scale_min_width -- the minimum width after downsampling
scale_min_height -- the minimum height after downsampling
crop -- box to crop the original image into (left, top, right, bottom)
width -- the width to target
height -- the height to target
max_width -- the maximum width
max_height -- the maximum height
resize -- how to fit the width and height; "fit", "fill", or "stretch"
fill_crop_x -- horizontal offset fraction for resize="fill"
fill_crop_y -- vertical offset fraction for resize="fill"
format -- output format
background -- background color when converting transparent to opaque
quality -- the JPEG quality to save the image as
quantize -- how large a palette to use for GIF or PNG images | [
"Get",
"the",
"rendition",
"for",
"this",
"image",
"generating",
"it",
"if",
"necessary",
".",
"Returns",
"a",
"tuple",
"of",
"(",
"relative_path",
"width",
"height",
")",
"where",
"relative_path",
"is",
"relative",
"to",
"the",
"static",
"file",
"directory",
... | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L83-L170 |
PlaidWeb/Publ | publ/image/local.py | LocalImage._adjust_crop_box | def _adjust_crop_box(box, crop):
""" Given a fit box and a crop box, adjust one to the other """
if crop and box:
# Both boxes are the same size; just line them up.
return (box[0] + crop[0], box[1] + crop[1],
box[2] + crop[0], box[3] + crop[1])
if crop:
# We don't have a fit box, so just convert the crop box
return (crop[0], crop[1], crop[0] + crop[2], crop[1] + crop[3])
# We don't have a crop box, so return the fit box (even if it's None)
return box | python | def _adjust_crop_box(box, crop):
""" Given a fit box and a crop box, adjust one to the other """
if crop and box:
# Both boxes are the same size; just line them up.
return (box[0] + crop[0], box[1] + crop[1],
box[2] + crop[0], box[3] + crop[1])
if crop:
# We don't have a fit box, so just convert the crop box
return (crop[0], crop[1], crop[0] + crop[2], crop[1] + crop[3])
# We don't have a crop box, so return the fit box (even if it's None)
return box | [
"def",
"_adjust_crop_box",
"(",
"box",
",",
"crop",
")",
":",
"if",
"crop",
"and",
"box",
":",
"# Both boxes are the same size; just line them up.",
"return",
"(",
"box",
"[",
"0",
"]",
"+",
"crop",
"[",
"0",
"]",
",",
"box",
"[",
"1",
"]",
"+",
"crop",
... | Given a fit box and a crop box, adjust one to the other | [
"Given",
"a",
"fit",
"box",
"and",
"a",
"crop",
"box",
"adjust",
"one",
"to",
"the",
"other"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L180-L193 |
PlaidWeb/Publ | publ/image/local.py | LocalImage._parse_tuple_string | def _parse_tuple_string(argument):
""" Return a tuple from parsing 'a,b,c,d' -> (a,b,c,d) """
if isinstance(argument, str):
return tuple(int(p.strip()) for p in argument.split(','))
return argument | python | def _parse_tuple_string(argument):
""" Return a tuple from parsing 'a,b,c,d' -> (a,b,c,d) """
if isinstance(argument, str):
return tuple(int(p.strip()) for p in argument.split(','))
return argument | [
"def",
"_parse_tuple_string",
"(",
"argument",
")",
":",
"if",
"isinstance",
"(",
"argument",
",",
"str",
")",
":",
"return",
"tuple",
"(",
"int",
"(",
"p",
".",
"strip",
"(",
")",
")",
"for",
"p",
"in",
"argument",
".",
"split",
"(",
"','",
")",
"... | Return a tuple from parsing 'a,b,c,d' -> (a,b,c,d) | [
"Return",
"a",
"tuple",
"from",
"parsing",
"a",
"b",
"c",
"d",
"-",
">",
"(",
"a",
"b",
"c",
"d",
")"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L196-L200 |
PlaidWeb/Publ | publ/image/local.py | LocalImage.get_rendition_size | def get_rendition_size(self, spec, output_scale, crop):
"""
Wrapper to determine the overall rendition size and cropping box
Returns tuple of (size,box)
"""
if crop:
# Use the cropping rectangle size
_, _, width, height = crop
else:
# Use the original image size
width = self._record.width
height = self._record.height
mode = spec.get('resize', 'fit')
if mode == 'fit':
return self.get_rendition_fit_size(spec, width, height, output_scale)
if mode == 'fill':
return self.get_rendition_fill_size(spec, width, height, output_scale)
if mode == 'stretch':
return self.get_rendition_stretch_size(spec, width, height, output_scale)
raise ValueError("Unknown resize mode {}".format(mode)) | python | def get_rendition_size(self, spec, output_scale, crop):
"""
Wrapper to determine the overall rendition size and cropping box
Returns tuple of (size,box)
"""
if crop:
# Use the cropping rectangle size
_, _, width, height = crop
else:
# Use the original image size
width = self._record.width
height = self._record.height
mode = spec.get('resize', 'fit')
if mode == 'fit':
return self.get_rendition_fit_size(spec, width, height, output_scale)
if mode == 'fill':
return self.get_rendition_fill_size(spec, width, height, output_scale)
if mode == 'stretch':
return self.get_rendition_stretch_size(spec, width, height, output_scale)
raise ValueError("Unknown resize mode {}".format(mode)) | [
"def",
"get_rendition_size",
"(",
"self",
",",
"spec",
",",
"output_scale",
",",
"crop",
")",
":",
"if",
"crop",
":",
"# Use the cropping rectangle size",
"_",
",",
"_",
",",
"width",
",",
"height",
"=",
"crop",
"else",
":",
"# Use the original image size",
"w... | Wrapper to determine the overall rendition size and cropping box
Returns tuple of (size,box) | [
"Wrapper",
"to",
"determine",
"the",
"overall",
"rendition",
"size",
"and",
"cropping",
"box"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L254-L279 |
PlaidWeb/Publ | publ/image/local.py | LocalImage.get_rendition_fit_size | def get_rendition_fit_size(spec, input_w, input_h, output_scale):
""" Determine the scaled size based on the provided spec """
width = input_w
height = input_h
scale = spec.get('scale')
if scale:
width = width / scale
height = height / scale
min_width = spec.get('scale_min_width')
if min_width and width < min_width:
height = height * min_width / width
width = min_width
min_height = spec.get('scale_min_height')
if min_height and height < min_height:
width = width * min_height / height
height = min_height
tgt_width, tgt_height = spec.get('width'), spec.get('height')
if tgt_width and width > tgt_width:
height = height * tgt_width / width
width = tgt_width
if tgt_height and height > tgt_height:
width = width * tgt_height / height
height = tgt_height
tgt_width, tgt_height = spec.get('max_width'), spec.get('max_height')
if tgt_width and width > tgt_width:
height = height * tgt_width / width
width = tgt_width
if tgt_height and height > tgt_height:
width = width * tgt_height / height
height = tgt_height
width = width * output_scale
height = height * output_scale
# Never scale to larger than the base rendition
width = min(round(width), input_w)
height = min(round(height), input_h)
return (width, height), None | python | def get_rendition_fit_size(spec, input_w, input_h, output_scale):
""" Determine the scaled size based on the provided spec """
width = input_w
height = input_h
scale = spec.get('scale')
if scale:
width = width / scale
height = height / scale
min_width = spec.get('scale_min_width')
if min_width and width < min_width:
height = height * min_width / width
width = min_width
min_height = spec.get('scale_min_height')
if min_height and height < min_height:
width = width * min_height / height
height = min_height
tgt_width, tgt_height = spec.get('width'), spec.get('height')
if tgt_width and width > tgt_width:
height = height * tgt_width / width
width = tgt_width
if tgt_height and height > tgt_height:
width = width * tgt_height / height
height = tgt_height
tgt_width, tgt_height = spec.get('max_width'), spec.get('max_height')
if tgt_width and width > tgt_width:
height = height * tgt_width / width
width = tgt_width
if tgt_height and height > tgt_height:
width = width * tgt_height / height
height = tgt_height
width = width * output_scale
height = height * output_scale
# Never scale to larger than the base rendition
width = min(round(width), input_w)
height = min(round(height), input_h)
return (width, height), None | [
"def",
"get_rendition_fit_size",
"(",
"spec",
",",
"input_w",
",",
"input_h",
",",
"output_scale",
")",
":",
"width",
"=",
"input_w",
"height",
"=",
"input_h",
"scale",
"=",
"spec",
".",
"get",
"(",
"'scale'",
")",
"if",
"scale",
":",
"width",
"=",
"widt... | Determine the scaled size based on the provided spec | [
"Determine",
"the",
"scaled",
"size",
"based",
"on",
"the",
"provided",
"spec"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L282-L330 |
PlaidWeb/Publ | publ/image/local.py | LocalImage.get_rendition_fill_size | def get_rendition_fill_size(spec, input_w, input_h, output_scale):
""" Determine the scale-crop size given the provided spec """
width = input_w
height = input_h
scale = spec.get('scale')
if scale:
width = width / scale
height = height / scale
if spec.get('scale_min_width'):
width = max(width, spec['spec_min_width'])
if spec.get('scale_min_height'):
height = max(height, spec['scale_min_height'])
if spec.get('width'):
width = min(width, spec['width'])
if spec.get('max_width'):
width = min(width, spec['max_width'])
if spec.get('height'):
height = min(height, spec['height'])
if spec.get('max_height'):
height = min(height, spec['max_height'])
width = width * output_scale
height = height * output_scale
# Never scale to larger than the base rendition (but keep the output
# aspect)
if width > input_w:
height = height * input_w / width
width = input_w
if height > input_h:
width = width * input_h / height
height = input_h
# Determine the box size
box_w = min(input_w, round(width * input_h / height))
box_h = min(input_h, round(height * input_w / width))
# Box offset
box_x = round((input_w - box_w) * spec.get('fill_crop_x', 0.5))
box_y = round((input_h - box_h) * spec.get('fill_crop_y', 0.5))
return (round(width), round(height)), (box_x, box_y, box_x + box_w, box_y + box_h) | python | def get_rendition_fill_size(spec, input_w, input_h, output_scale):
""" Determine the scale-crop size given the provided spec """
width = input_w
height = input_h
scale = spec.get('scale')
if scale:
width = width / scale
height = height / scale
if spec.get('scale_min_width'):
width = max(width, spec['spec_min_width'])
if spec.get('scale_min_height'):
height = max(height, spec['scale_min_height'])
if spec.get('width'):
width = min(width, spec['width'])
if spec.get('max_width'):
width = min(width, spec['max_width'])
if spec.get('height'):
height = min(height, spec['height'])
if spec.get('max_height'):
height = min(height, spec['max_height'])
width = width * output_scale
height = height * output_scale
# Never scale to larger than the base rendition (but keep the output
# aspect)
if width > input_w:
height = height * input_w / width
width = input_w
if height > input_h:
width = width * input_h / height
height = input_h
# Determine the box size
box_w = min(input_w, round(width * input_h / height))
box_h = min(input_h, round(height * input_w / width))
# Box offset
box_x = round((input_w - box_w) * spec.get('fill_crop_x', 0.5))
box_y = round((input_h - box_h) * spec.get('fill_crop_y', 0.5))
return (round(width), round(height)), (box_x, box_y, box_x + box_w, box_y + box_h) | [
"def",
"get_rendition_fill_size",
"(",
"spec",
",",
"input_w",
",",
"input_h",
",",
"output_scale",
")",
":",
"width",
"=",
"input_w",
"height",
"=",
"input_h",
"scale",
"=",
"spec",
".",
"get",
"(",
"'scale'",
")",
"if",
"scale",
":",
"width",
"=",
"wid... | Determine the scale-crop size given the provided spec | [
"Determine",
"the",
"scale",
"-",
"crop",
"size",
"given",
"the",
"provided",
"spec"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L333-L381 |
PlaidWeb/Publ | publ/image/local.py | LocalImage.get_rendition_stretch_size | def get_rendition_stretch_size(spec, input_w, input_h, output_scale):
""" Determine the scale-crop size given the provided spec """
width = input_w
height = input_h
scale = spec.get('scale')
if scale:
width = width / scale
height = height / scale
min_width = spec.get('scale_min_width')
if min_width and width < min_width:
width = min_width
min_height = spec.get('scale_min_height')
if min_height and height < min_height:
height = min_height
tgt_width, tgt_height = spec.get('width'), spec.get('height')
if tgt_width and width > tgt_width:
width = tgt_width
tgt_height = spec.get('height')
if tgt_height and height > tgt_height:
height = tgt_height
tgt_width, tgt_height = spec.get('max_width'), spec.get('max_height')
if tgt_width and width > tgt_width:
width = tgt_width
tgt_height = spec.get('height')
if tgt_height and height > tgt_height:
height = tgt_height
width = width * output_scale
height = height * output_scale
return (round(width), round(height)), None | python | def get_rendition_stretch_size(spec, input_w, input_h, output_scale):
""" Determine the scale-crop size given the provided spec """
width = input_w
height = input_h
scale = spec.get('scale')
if scale:
width = width / scale
height = height / scale
min_width = spec.get('scale_min_width')
if min_width and width < min_width:
width = min_width
min_height = spec.get('scale_min_height')
if min_height and height < min_height:
height = min_height
tgt_width, tgt_height = spec.get('width'), spec.get('height')
if tgt_width and width > tgt_width:
width = tgt_width
tgt_height = spec.get('height')
if tgt_height and height > tgt_height:
height = tgt_height
tgt_width, tgt_height = spec.get('max_width'), spec.get('max_height')
if tgt_width and width > tgt_width:
width = tgt_width
tgt_height = spec.get('height')
if tgt_height and height > tgt_height:
height = tgt_height
width = width * output_scale
height = height * output_scale
return (round(width), round(height)), None | [
"def",
"get_rendition_stretch_size",
"(",
"spec",
",",
"input_w",
",",
"input_h",
",",
"output_scale",
")",
":",
"width",
"=",
"input_w",
"height",
"=",
"input_h",
"scale",
"=",
"spec",
".",
"get",
"(",
"'scale'",
")",
"if",
"scale",
":",
"width",
"=",
"... | Determine the scale-crop size given the provided spec | [
"Determine",
"the",
"scale",
"-",
"crop",
"size",
"given",
"the",
"provided",
"spec"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L384-L424 |
PlaidWeb/Publ | publ/image/local.py | LocalImage.flatten | def flatten(image, bgcolor=None):
""" Flatten an image, with an optional background color """
if bgcolor:
background = PIL.Image.new('RGB', image.size, bgcolor)
background.paste(image, mask=image.split()[3])
return background
return image.convert('RGB') | python | def flatten(image, bgcolor=None):
""" Flatten an image, with an optional background color """
if bgcolor:
background = PIL.Image.new('RGB', image.size, bgcolor)
background.paste(image, mask=image.split()[3])
return background
return image.convert('RGB') | [
"def",
"flatten",
"(",
"image",
",",
"bgcolor",
"=",
"None",
")",
":",
"if",
"bgcolor",
":",
"background",
"=",
"PIL",
".",
"Image",
".",
"new",
"(",
"'RGB'",
",",
"image",
".",
"size",
",",
"bgcolor",
")",
"background",
".",
"paste",
"(",
"image",
... | Flatten an image, with an optional background color | [
"Flatten",
"an",
"image",
"with",
"an",
"optional",
"background",
"color"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L427-L434 |
PlaidWeb/Publ | publ/image/local.py | LocalImage._get_renditions | def _get_renditions(self, kwargs):
""" Get a bunch of renditions; returns a tuple of 1x, 2x, size """
img_1x, size = self.get_rendition(
1, **utils.remap_args(kwargs, {"quality": "quality_ldpi"}))
img_2x, _ = self.get_rendition(
2, **utils.remap_args(kwargs, {"quality": "quality_hdpi"}))
return (img_1x, img_2x, size) | python | def _get_renditions(self, kwargs):
""" Get a bunch of renditions; returns a tuple of 1x, 2x, size """
img_1x, size = self.get_rendition(
1, **utils.remap_args(kwargs, {"quality": "quality_ldpi"}))
img_2x, _ = self.get_rendition(
2, **utils.remap_args(kwargs, {"quality": "quality_hdpi"}))
return (img_1x, img_2x, size) | [
"def",
"_get_renditions",
"(",
"self",
",",
"kwargs",
")",
":",
"img_1x",
",",
"size",
"=",
"self",
".",
"get_rendition",
"(",
"1",
",",
"*",
"*",
"utils",
".",
"remap_args",
"(",
"kwargs",
",",
"{",
"\"quality\"",
":",
"\"quality_ldpi\"",
"}",
")",
")... | Get a bunch of renditions; returns a tuple of 1x, 2x, size | [
"Get",
"a",
"bunch",
"of",
"renditions",
";",
"returns",
"a",
"tuple",
"of",
"1x",
"2x",
"size"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L436-L443 |
PlaidWeb/Publ | publ/image/local.py | LocalImage._get_img_attrs | def _get_img_attrs(self, style, kwargs):
""" Get the attributes of an an <img> tag for this image, hidpi-aware """
# Get the 1x and 2x renditions
img_1x, img_2x, size = self._get_renditions(kwargs)
return {
'src': img_1x,
'width': size[0],
'height': size[1],
'srcset': "{} 1x, {} 2x".format(img_1x, img_2x) if img_1x != img_2x else None,
'style': ';'.join(style) if style else None,
'class': kwargs.get('class', kwargs.get('img_class')),
'id': kwargs.get('img_id')
} | python | def _get_img_attrs(self, style, kwargs):
""" Get the attributes of an an <img> tag for this image, hidpi-aware """
# Get the 1x and 2x renditions
img_1x, img_2x, size = self._get_renditions(kwargs)
return {
'src': img_1x,
'width': size[0],
'height': size[1],
'srcset': "{} 1x, {} 2x".format(img_1x, img_2x) if img_1x != img_2x else None,
'style': ';'.join(style) if style else None,
'class': kwargs.get('class', kwargs.get('img_class')),
'id': kwargs.get('img_id')
} | [
"def",
"_get_img_attrs",
"(",
"self",
",",
"style",
",",
"kwargs",
")",
":",
"# Get the 1x and 2x renditions",
"img_1x",
",",
"img_2x",
",",
"size",
"=",
"self",
".",
"_get_renditions",
"(",
"kwargs",
")",
"return",
"{",
"'src'",
":",
"img_1x",
",",
"'width'... | Get the attributes of an an <img> tag for this image, hidpi-aware | [
"Get",
"the",
"attributes",
"of",
"an",
"an",
"<img",
">",
"tag",
"for",
"this",
"image",
"hidpi",
"-",
"aware"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L445-L459 |
PlaidWeb/Publ | publ/image/local.py | LocalImage._css_background | def _css_background(self, **kwargs):
""" Get the CSS specifiers for this as a hidpi-capable background image """
# Get the 1x and 2x renditions
img_1x, img_2x, _ = self._get_renditions(kwargs)
tmpl = 'background-image: url("{s1x}");'
if img_1x != img_2x:
image_set = 'image-set(url("{s1x}") 1x, url("{s2x}") 2x)'
tmpl += 'background-image: {ss};background-image: -webkit-{ss};'.format(
ss=image_set)
return tmpl.format(s1x=img_1x, s2x=img_2x) | python | def _css_background(self, **kwargs):
""" Get the CSS specifiers for this as a hidpi-capable background image """
# Get the 1x and 2x renditions
img_1x, img_2x, _ = self._get_renditions(kwargs)
tmpl = 'background-image: url("{s1x}");'
if img_1x != img_2x:
image_set = 'image-set(url("{s1x}") 1x, url("{s2x}") 2x)'
tmpl += 'background-image: {ss};background-image: -webkit-{ss};'.format(
ss=image_set)
return tmpl.format(s1x=img_1x, s2x=img_2x) | [
"def",
"_css_background",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"# Get the 1x and 2x renditions",
"img_1x",
",",
"img_2x",
",",
"_",
"=",
"self",
".",
"_get_renditions",
"(",
"kwargs",
")",
"tmpl",
"=",
"'background-image: url(\"{s1x}\");'",
"if",
"img... | Get the CSS specifiers for this as a hidpi-capable background image | [
"Get",
"the",
"CSS",
"specifiers",
"for",
"this",
"as",
"a",
"hidpi",
"-",
"capable",
"background",
"image"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/image/local.py#L461-L472 |
PlaidWeb/Publ | publ/html_entry.py | process | def process(text, config, search_path):
""" Process an HTML entry's HTML """
processor = HTMLEntry(config, search_path)
processor.feed(text)
text = processor.get_data()
if not config.get('no_smartquotes'):
text = misaka.smartypants(text)
return flask.Markup(text) | python | def process(text, config, search_path):
""" Process an HTML entry's HTML """
processor = HTMLEntry(config, search_path)
processor.feed(text)
text = processor.get_data()
if not config.get('no_smartquotes'):
text = misaka.smartypants(text)
return flask.Markup(text) | [
"def",
"process",
"(",
"text",
",",
"config",
",",
"search_path",
")",
":",
"processor",
"=",
"HTMLEntry",
"(",
"config",
",",
"search_path",
")",
"processor",
".",
"feed",
"(",
"text",
")",
"text",
"=",
"processor",
".",
"get_data",
"(",
")",
"if",
"n... | Process an HTML entry's HTML | [
"Process",
"an",
"HTML",
"entry",
"s",
"HTML"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/html_entry.py#L93-L102 |
PlaidWeb/Publ | publ/html_entry.py | HTMLEntry._handle_tag | def _handle_tag(self, tag, attrs, self_closing):
""" Handle a tag.
attrs -- the attributes of the tag
self_closing -- whether this is self-closing
"""
if tag.lower() == 'img':
attrs = self._image_attrs(attrs)
# Remap the attributes
out_attrs = []
for key, val in attrs:
if (key.lower() == 'href'
or (key.lower() == 'src' and not tag.lower() == 'img')):
out_attrs.append((key, links.resolve(
val, self._search_path, self._config.get('absolute'))))
else:
out_attrs.append((key, val))
self.append(
utils.make_tag(
tag,
out_attrs,
self_closing)) | python | def _handle_tag(self, tag, attrs, self_closing):
""" Handle a tag.
attrs -- the attributes of the tag
self_closing -- whether this is self-closing
"""
if tag.lower() == 'img':
attrs = self._image_attrs(attrs)
# Remap the attributes
out_attrs = []
for key, val in attrs:
if (key.lower() == 'href'
or (key.lower() == 'src' and not tag.lower() == 'img')):
out_attrs.append((key, links.resolve(
val, self._search_path, self._config.get('absolute'))))
else:
out_attrs.append((key, val))
self.append(
utils.make_tag(
tag,
out_attrs,
self_closing)) | [
"def",
"_handle_tag",
"(",
"self",
",",
"tag",
",",
"attrs",
",",
"self_closing",
")",
":",
"if",
"tag",
".",
"lower",
"(",
")",
"==",
"'img'",
":",
"attrs",
"=",
"self",
".",
"_image_attrs",
"(",
"attrs",
")",
"# Remap the attributes",
"out_attrs",
"=",... | Handle a tag.
attrs -- the attributes of the tag
self_closing -- whether this is self-closing | [
"Handle",
"a",
"tag",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/html_entry.py#L34-L58 |
PlaidWeb/Publ | publ/html_entry.py | HTMLEntry._image_attrs | def _image_attrs(self, attrs):
""" Rewrite the SRC attribute on an <img> tag, possibly adding a SRCSET.
"""
path = None
config = {**self._config}
for key, val in attrs:
if key.lower() == 'width' or key.lower() == 'height':
try:
config[key.lower()] = int(val)
except ValueError:
pass
elif key.lower() == 'src':
path = val
img_path, img_args, _ = image.parse_image_spec(path)
img = image.get_image(img_path, self._search_path)
for key, val in img_args.items():
if val and key not in config:
config[key] = val
try:
img_attrs = img.get_img_attrs(**config)
except FileNotFoundError as error:
return [('data-publ-error', 'file not found: {}'.format(error.filename))]
# return the original attr list with the computed overrides in place
return [(key, val) for key, val in attrs
if key.lower() not in img_attrs] + list(img_attrs.items()) | python | def _image_attrs(self, attrs):
""" Rewrite the SRC attribute on an <img> tag, possibly adding a SRCSET.
"""
path = None
config = {**self._config}
for key, val in attrs:
if key.lower() == 'width' or key.lower() == 'height':
try:
config[key.lower()] = int(val)
except ValueError:
pass
elif key.lower() == 'src':
path = val
img_path, img_args, _ = image.parse_image_spec(path)
img = image.get_image(img_path, self._search_path)
for key, val in img_args.items():
if val and key not in config:
config[key] = val
try:
img_attrs = img.get_img_attrs(**config)
except FileNotFoundError as error:
return [('data-publ-error', 'file not found: {}'.format(error.filename))]
# return the original attr list with the computed overrides in place
return [(key, val) for key, val in attrs
if key.lower() not in img_attrs] + list(img_attrs.items()) | [
"def",
"_image_attrs",
"(",
"self",
",",
"attrs",
")",
":",
"path",
"=",
"None",
"config",
"=",
"{",
"*",
"*",
"self",
".",
"_config",
"}",
"for",
"key",
",",
"val",
"in",
"attrs",
":",
"if",
"key",
".",
"lower",
"(",
")",
"==",
"'width'",
"or",
... | Rewrite the SRC attribute on an <img> tag, possibly adding a SRCSET. | [
"Rewrite",
"the",
"SRC",
"attribute",
"on",
"an",
"<img",
">",
"tag",
"possibly",
"adding",
"a",
"SRCSET",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/html_entry.py#L60-L90 |
PlaidWeb/Publ | publ/index.py | last_modified | def last_modified():
""" information about the most recently modified file """
files = model.FileFingerprint.select().order_by(
orm.desc(model.FileFingerprint.file_mtime))
for file in files:
return file.file_mtime, file.file_path
return None, None | python | def last_modified():
""" information about the most recently modified file """
files = model.FileFingerprint.select().order_by(
orm.desc(model.FileFingerprint.file_mtime))
for file in files:
return file.file_mtime, file.file_path
return None, None | [
"def",
"last_modified",
"(",
")",
":",
"files",
"=",
"model",
".",
"FileFingerprint",
".",
"select",
"(",
")",
".",
"order_by",
"(",
"orm",
".",
"desc",
"(",
"model",
".",
"FileFingerprint",
".",
"file_mtime",
")",
")",
"for",
"file",
"in",
"files",
":... | information about the most recently modified file | [
"information",
"about",
"the",
"most",
"recently",
"modified",
"file"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L58-L64 |
PlaidWeb/Publ | publ/index.py | scan_file | def scan_file(fullpath, relpath, assign_id):
""" Scan a file for the index
fullpath -- The full path to the file
relpath -- The path to the file, relative to its base directory
assign_id -- Whether to assign an ID to the file if not yet assigned
This calls into various modules' scanner functions; the expectation is that
the scan_file function will return a truthy value if it was scanned
successfully, False if it failed, and None if there is nothing to scan.
"""
logger.debug("Scanning file: %s (%s) %s", fullpath, relpath, assign_id)
def do_scan():
""" helper function to do the scan and gather the result """
_, ext = os.path.splitext(fullpath)
try:
if ext in ENTRY_TYPES:
logger.info("Scanning entry: %s", fullpath)
return entry.scan_file(fullpath, relpath, assign_id)
if ext in CATEGORY_TYPES:
logger.info("Scanning meta info: %s", fullpath)
return category.scan_file(fullpath, relpath)
return None
except: # pylint: disable=bare-except
logger.exception("Got error parsing %s", fullpath)
return False
result = do_scan()
if result is False and not assign_id:
logger.info("Scheduling fixup for %s", fullpath)
THREAD_POOL.submit(scan_file, fullpath, relpath, True)
else:
logger.debug("%s complete", fullpath)
if result:
set_fingerprint(fullpath)
SCHEDULED_FILES.remove(fullpath) | python | def scan_file(fullpath, relpath, assign_id):
""" Scan a file for the index
fullpath -- The full path to the file
relpath -- The path to the file, relative to its base directory
assign_id -- Whether to assign an ID to the file if not yet assigned
This calls into various modules' scanner functions; the expectation is that
the scan_file function will return a truthy value if it was scanned
successfully, False if it failed, and None if there is nothing to scan.
"""
logger.debug("Scanning file: %s (%s) %s", fullpath, relpath, assign_id)
def do_scan():
""" helper function to do the scan and gather the result """
_, ext = os.path.splitext(fullpath)
try:
if ext in ENTRY_TYPES:
logger.info("Scanning entry: %s", fullpath)
return entry.scan_file(fullpath, relpath, assign_id)
if ext in CATEGORY_TYPES:
logger.info("Scanning meta info: %s", fullpath)
return category.scan_file(fullpath, relpath)
return None
except: # pylint: disable=bare-except
logger.exception("Got error parsing %s", fullpath)
return False
result = do_scan()
if result is False and not assign_id:
logger.info("Scheduling fixup for %s", fullpath)
THREAD_POOL.submit(scan_file, fullpath, relpath, True)
else:
logger.debug("%s complete", fullpath)
if result:
set_fingerprint(fullpath)
SCHEDULED_FILES.remove(fullpath) | [
"def",
"scan_file",
"(",
"fullpath",
",",
"relpath",
",",
"assign_id",
")",
":",
"logger",
".",
"debug",
"(",
"\"Scanning file: %s (%s) %s\"",
",",
"fullpath",
",",
"relpath",
",",
"assign_id",
")",
"def",
"do_scan",
"(",
")",
":",
"\"\"\" helper function to do ... | Scan a file for the index
fullpath -- The full path to the file
relpath -- The path to the file, relative to its base directory
assign_id -- Whether to assign an ID to the file if not yet assigned
This calls into various modules' scanner functions; the expectation is that
the scan_file function will return a truthy value if it was scanned
successfully, False if it failed, and None if there is nothing to scan. | [
"Scan",
"a",
"file",
"for",
"the",
"index"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L77-L117 |
PlaidWeb/Publ | publ/index.py | get_last_fingerprint | def get_last_fingerprint(fullpath):
""" Get the last known modification time for a file """
record = model.FileFingerprint.get(file_path=fullpath)
if record:
return record.fingerprint
return None | python | def get_last_fingerprint(fullpath):
""" Get the last known modification time for a file """
record = model.FileFingerprint.get(file_path=fullpath)
if record:
return record.fingerprint
return None | [
"def",
"get_last_fingerprint",
"(",
"fullpath",
")",
":",
"record",
"=",
"model",
".",
"FileFingerprint",
".",
"get",
"(",
"file_path",
"=",
"fullpath",
")",
"if",
"record",
":",
"return",
"record",
".",
"fingerprint",
"return",
"None"
] | Get the last known modification time for a file | [
"Get",
"the",
"last",
"known",
"modification",
"time",
"for",
"a",
"file"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L121-L126 |
PlaidWeb/Publ | publ/index.py | set_fingerprint | def set_fingerprint(fullpath, fingerprint=None):
""" Set the last known modification time for a file """
try:
fingerprint = fingerprint or utils.file_fingerprint(fullpath)
record = model.FileFingerprint.get(file_path=fullpath)
if record:
record.set(fingerprint=fingerprint,
file_mtime=os.stat(fullpath).st_mtime)
else:
record = model.FileFingerprint(
file_path=fullpath,
fingerprint=fingerprint,
file_mtime=os.stat(fullpath).st_mtime)
orm.commit()
except FileNotFoundError:
orm.delete(fp for fp in model.FileFingerprint if fp.file_path == fullpath) | python | def set_fingerprint(fullpath, fingerprint=None):
""" Set the last known modification time for a file """
try:
fingerprint = fingerprint or utils.file_fingerprint(fullpath)
record = model.FileFingerprint.get(file_path=fullpath)
if record:
record.set(fingerprint=fingerprint,
file_mtime=os.stat(fullpath).st_mtime)
else:
record = model.FileFingerprint(
file_path=fullpath,
fingerprint=fingerprint,
file_mtime=os.stat(fullpath).st_mtime)
orm.commit()
except FileNotFoundError:
orm.delete(fp for fp in model.FileFingerprint if fp.file_path == fullpath) | [
"def",
"set_fingerprint",
"(",
"fullpath",
",",
"fingerprint",
"=",
"None",
")",
":",
"try",
":",
"fingerprint",
"=",
"fingerprint",
"or",
"utils",
".",
"file_fingerprint",
"(",
"fullpath",
")",
"record",
"=",
"model",
".",
"FileFingerprint",
".",
"get",
"("... | Set the last known modification time for a file | [
"Set",
"the",
"last",
"known",
"modification",
"time",
"for",
"a",
"file"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L130-L146 |
PlaidWeb/Publ | publ/index.py | background_scan | def background_scan(content_dir):
""" Start background scanning a directory for changes """
observer = watchdog.observers.Observer()
observer.schedule(IndexWatchdog(content_dir),
content_dir, recursive=True)
logging.info("Watching %s for changes", content_dir)
observer.start() | python | def background_scan(content_dir):
""" Start background scanning a directory for changes """
observer = watchdog.observers.Observer()
observer.schedule(IndexWatchdog(content_dir),
content_dir, recursive=True)
logging.info("Watching %s for changes", content_dir)
observer.start() | [
"def",
"background_scan",
"(",
"content_dir",
")",
":",
"observer",
"=",
"watchdog",
".",
"observers",
".",
"Observer",
"(",
")",
"observer",
".",
"schedule",
"(",
"IndexWatchdog",
"(",
"content_dir",
")",
",",
"content_dir",
",",
"recursive",
"=",
"True",
"... | Start background scanning a directory for changes | [
"Start",
"background",
"scanning",
"a",
"directory",
"for",
"changes"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L188-L194 |
PlaidWeb/Publ | publ/index.py | prune_missing | def prune_missing(table):
""" Prune any files which are missing from the specified table """
try:
for item in table.select():
if not os.path.isfile(item.file_path):
logger.info("File disappeared: %s", item.file_path)
item.delete()
except: # pylint:disable=bare-except
logger.exception("Error pruning %s", table) | python | def prune_missing(table):
""" Prune any files which are missing from the specified table """
try:
for item in table.select():
if not os.path.isfile(item.file_path):
logger.info("File disappeared: %s", item.file_path)
item.delete()
except: # pylint:disable=bare-except
logger.exception("Error pruning %s", table) | [
"def",
"prune_missing",
"(",
"table",
")",
":",
"try",
":",
"for",
"item",
"in",
"table",
".",
"select",
"(",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"isfile",
"(",
"item",
".",
"file_path",
")",
":",
"logger",
".",
"info",
"(",
"\"File disa... | Prune any files which are missing from the specified table | [
"Prune",
"any",
"files",
"which",
"are",
"missing",
"from",
"the",
"specified",
"table"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L198-L206 |
PlaidWeb/Publ | publ/index.py | scan_index | def scan_index(content_dir):
""" Scan all files in a content directory """
def scan_directory(root, files):
""" Helper function to scan a single directory """
try:
for file in files:
fullpath = os.path.join(root, file)
relpath = os.path.relpath(fullpath, content_dir)
fingerprint = utils.file_fingerprint(fullpath)
last_fingerprint = get_last_fingerprint(fullpath)
if fingerprint != last_fingerprint and SCHEDULED_FILES.add(fullpath):
scan_file(fullpath, relpath, False)
except: # pylint:disable=bare-except
logger.exception("Got error parsing directory %s", root)
for root, _, files in os.walk(content_dir, followlinks=True):
THREAD_POOL.submit(scan_directory, root, files)
for table in (model.Entry, model.Category, model.Image, model.FileFingerprint):
THREAD_POOL.submit(prune_missing, table) | python | def scan_index(content_dir):
""" Scan all files in a content directory """
def scan_directory(root, files):
""" Helper function to scan a single directory """
try:
for file in files:
fullpath = os.path.join(root, file)
relpath = os.path.relpath(fullpath, content_dir)
fingerprint = utils.file_fingerprint(fullpath)
last_fingerprint = get_last_fingerprint(fullpath)
if fingerprint != last_fingerprint and SCHEDULED_FILES.add(fullpath):
scan_file(fullpath, relpath, False)
except: # pylint:disable=bare-except
logger.exception("Got error parsing directory %s", root)
for root, _, files in os.walk(content_dir, followlinks=True):
THREAD_POOL.submit(scan_directory, root, files)
for table in (model.Entry, model.Category, model.Image, model.FileFingerprint):
THREAD_POOL.submit(prune_missing, table) | [
"def",
"scan_index",
"(",
"content_dir",
")",
":",
"def",
"scan_directory",
"(",
"root",
",",
"files",
")",
":",
"\"\"\" Helper function to scan a single directory \"\"\"",
"try",
":",
"for",
"file",
"in",
"files",
":",
"fullpath",
"=",
"os",
".",
"path",
".",
... | Scan all files in a content directory | [
"Scan",
"all",
"files",
"in",
"a",
"content",
"directory"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L209-L230 |
PlaidWeb/Publ | publ/index.py | ConcurrentSet.add | def add(self, item):
""" Add an item to the set, and return whether it was newly added """
with self.lock:
if item in self.set:
return False
self.set.add(item)
return True | python | def add(self, item):
""" Add an item to the set, and return whether it was newly added """
with self.lock:
if item in self.set:
return False
self.set.add(item)
return True | [
"def",
"add",
"(",
"self",
",",
"item",
")",
":",
"with",
"self",
".",
"lock",
":",
"if",
"item",
"in",
"self",
".",
"set",
":",
"return",
"False",
"self",
".",
"set",
".",
"add",
"(",
"item",
")",
"return",
"True"
] | Add an item to the set, and return whether it was newly added | [
"Add",
"an",
"item",
"to",
"the",
"set",
"and",
"return",
"whether",
"it",
"was",
"newly",
"added"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L38-L44 |
PlaidWeb/Publ | publ/index.py | ConcurrentSet.remove | def remove(self, item):
""" Remove an item from the set, returning if it was present """
with self.lock:
if item in self.set:
self.set.remove(item)
return True
return False | python | def remove(self, item):
""" Remove an item from the set, returning if it was present """
with self.lock:
if item in self.set:
self.set.remove(item)
return True
return False | [
"def",
"remove",
"(",
"self",
",",
"item",
")",
":",
"with",
"self",
".",
"lock",
":",
"if",
"item",
"in",
"self",
".",
"set",
":",
"self",
".",
"set",
".",
"remove",
"(",
"item",
")",
"return",
"True",
"return",
"False"
] | Remove an item from the set, returning if it was present | [
"Remove",
"an",
"item",
"from",
"the",
"set",
"returning",
"if",
"it",
"was",
"present"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L46-L52 |
PlaidWeb/Publ | publ/index.py | IndexWatchdog.update_file | def update_file(self, fullpath):
""" Update a file """
if SCHEDULED_FILES.add(fullpath):
logger.debug("Scheduling reindex of %s", fullpath)
relpath = os.path.relpath(fullpath, self.content_dir)
THREAD_POOL.submit(scan_file, fullpath, relpath, False) | python | def update_file(self, fullpath):
""" Update a file """
if SCHEDULED_FILES.add(fullpath):
logger.debug("Scheduling reindex of %s", fullpath)
relpath = os.path.relpath(fullpath, self.content_dir)
THREAD_POOL.submit(scan_file, fullpath, relpath, False) | [
"def",
"update_file",
"(",
"self",
",",
"fullpath",
")",
":",
"if",
"SCHEDULED_FILES",
".",
"add",
"(",
"fullpath",
")",
":",
"logger",
".",
"debug",
"(",
"\"Scheduling reindex of %s\"",
",",
"fullpath",
")",
"relpath",
"=",
"os",
".",
"path",
".",
"relpat... | Update a file | [
"Update",
"a",
"file"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L156-L161 |
PlaidWeb/Publ | publ/index.py | IndexWatchdog.on_created | def on_created(self, event):
""" on_created handler """
logger.debug("file created: %s", event.src_path)
if not event.is_directory:
self.update_file(event.src_path) | python | def on_created(self, event):
""" on_created handler """
logger.debug("file created: %s", event.src_path)
if not event.is_directory:
self.update_file(event.src_path) | [
"def",
"on_created",
"(",
"self",
",",
"event",
")",
":",
"logger",
".",
"debug",
"(",
"\"file created: %s\"",
",",
"event",
".",
"src_path",
")",
"if",
"not",
"event",
".",
"is_directory",
":",
"self",
".",
"update_file",
"(",
"event",
".",
"src_path",
... | on_created handler | [
"on_created",
"handler"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L163-L167 |
PlaidWeb/Publ | publ/index.py | IndexWatchdog.on_modified | def on_modified(self, event):
""" on_modified handler """
logger.debug("file modified: %s", event.src_path)
if not event.is_directory:
self.update_file(event.src_path) | python | def on_modified(self, event):
""" on_modified handler """
logger.debug("file modified: %s", event.src_path)
if not event.is_directory:
self.update_file(event.src_path) | [
"def",
"on_modified",
"(",
"self",
",",
"event",
")",
":",
"logger",
".",
"debug",
"(",
"\"file modified: %s\"",
",",
"event",
".",
"src_path",
")",
"if",
"not",
"event",
".",
"is_directory",
":",
"self",
".",
"update_file",
"(",
"event",
".",
"src_path",
... | on_modified handler | [
"on_modified",
"handler"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L169-L173 |
PlaidWeb/Publ | publ/index.py | IndexWatchdog.on_moved | def on_moved(self, event):
""" on_moved handler """
logger.debug("file moved: %s -> %s", event.src_path, event.dest_path)
if not event.is_directory:
self.update_file(event.dest_path) | python | def on_moved(self, event):
""" on_moved handler """
logger.debug("file moved: %s -> %s", event.src_path, event.dest_path)
if not event.is_directory:
self.update_file(event.dest_path) | [
"def",
"on_moved",
"(",
"self",
",",
"event",
")",
":",
"logger",
".",
"debug",
"(",
"\"file moved: %s -> %s\"",
",",
"event",
".",
"src_path",
",",
"event",
".",
"dest_path",
")",
"if",
"not",
"event",
".",
"is_directory",
":",
"self",
".",
"update_file",... | on_moved handler | [
"on_moved",
"handler"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L175-L179 |
PlaidWeb/Publ | publ/index.py | IndexWatchdog.on_deleted | def on_deleted(self, event):
""" on_deleted handler """
logger.debug("File deleted: %s", event.src_path)
if not event.is_directory:
self.update_file(event.src_path) | python | def on_deleted(self, event):
""" on_deleted handler """
logger.debug("File deleted: %s", event.src_path)
if not event.is_directory:
self.update_file(event.src_path) | [
"def",
"on_deleted",
"(",
"self",
",",
"event",
")",
":",
"logger",
".",
"debug",
"(",
"\"File deleted: %s\"",
",",
"event",
".",
"src_path",
")",
"if",
"not",
"event",
".",
"is_directory",
":",
"self",
".",
"update_file",
"(",
"event",
".",
"src_path",
... | on_deleted handler | [
"on_deleted",
"handler"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/index.py#L181-L185 |
PlaidWeb/Publ | publ/view.py | parse_view_spec | def parse_view_spec(args):
""" Parse a view specification from a request arg list """
view_spec = {}
if 'date' in args:
view_spec['date'] = args['date']
elif 'id' in args:
view_spec['start'] = args['id']
if 'tag' in args:
view_spec['tag'] = args.getlist('tag')
if len(view_spec['tag']) == 1:
view_spec['tag'] = args['tag']
return view_spec | python | def parse_view_spec(args):
""" Parse a view specification from a request arg list """
view_spec = {}
if 'date' in args:
view_spec['date'] = args['date']
elif 'id' in args:
view_spec['start'] = args['id']
if 'tag' in args:
view_spec['tag'] = args.getlist('tag')
if len(view_spec['tag']) == 1:
view_spec['tag'] = args['tag']
return view_spec | [
"def",
"parse_view_spec",
"(",
"args",
")",
":",
"view_spec",
"=",
"{",
"}",
"if",
"'date'",
"in",
"args",
":",
"view_spec",
"[",
"'date'",
"]",
"=",
"args",
"[",
"'date'",
"]",
"elif",
"'id'",
"in",
"args",
":",
"view_spec",
"[",
"'start'",
"]",
"="... | Parse a view specification from a request arg list | [
"Parse",
"a",
"view",
"specification",
"from",
"a",
"request",
"arg",
"list"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L414-L429 |
PlaidWeb/Publ | publ/view.py | View.deleted | def deleted(self):
""" Gets the deleted entries from the view """
query = queries.build_query({**self.spec,
'future': False,
'_deleted': True})
return [Entry(e) for e in query] | python | def deleted(self):
""" Gets the deleted entries from the view """
query = queries.build_query({**self.spec,
'future': False,
'_deleted': True})
return [Entry(e) for e in query] | [
"def",
"deleted",
"(",
"self",
")",
":",
"query",
"=",
"queries",
".",
"build_query",
"(",
"{",
"*",
"*",
"self",
".",
"spec",
",",
"'future'",
":",
"False",
",",
"'_deleted'",
":",
"True",
"}",
")",
"return",
"[",
"Entry",
"(",
"e",
")",
"for",
... | Gets the deleted entries from the view | [
"Gets",
"the",
"deleted",
"entries",
"from",
"the",
"view"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L155-L160 |
PlaidWeb/Publ | publ/view.py | View.last_modified | def last_modified(self):
""" Gets the most recent modification time for all entries in the view """
if self.entries:
latest = max(self.entries, key=lambda x: x.last_modified)
return arrow.get(latest.last_modified)
return arrow.get() | python | def last_modified(self):
""" Gets the most recent modification time for all entries in the view """
if self.entries:
latest = max(self.entries, key=lambda x: x.last_modified)
return arrow.get(latest.last_modified)
return arrow.get() | [
"def",
"last_modified",
"(",
"self",
")",
":",
"if",
"self",
".",
"entries",
":",
"latest",
"=",
"max",
"(",
"self",
".",
"entries",
",",
"key",
"=",
"lambda",
"x",
":",
"x",
".",
"last_modified",
")",
"return",
"arrow",
".",
"get",
"(",
"latest",
... | Gets the most recent modification time for all entries in the view | [
"Gets",
"the",
"most",
"recent",
"modification",
"time",
"for",
"all",
"entries",
"in",
"the",
"view"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L168-L173 |
PlaidWeb/Publ | publ/view.py | View.previous | def previous(self):
""" Gets the previous page, respecting sort order """
if self._order_by == 'oldest':
return self.older
if self._order_by == 'newest':
return self.newer
return None | python | def previous(self):
""" Gets the previous page, respecting sort order """
if self._order_by == 'oldest':
return self.older
if self._order_by == 'newest':
return self.newer
return None | [
"def",
"previous",
"(",
"self",
")",
":",
"if",
"self",
".",
"_order_by",
"==",
"'oldest'",
":",
"return",
"self",
".",
"older",
"if",
"self",
".",
"_order_by",
"==",
"'newest'",
":",
"return",
"self",
".",
"newer",
"return",
"None"
] | Gets the previous page, respecting sort order | [
"Gets",
"the",
"previous",
"page",
"respecting",
"sort",
"order"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L188-L194 |
PlaidWeb/Publ | publ/view.py | View.next | def next(self):
""" Gets the next page, respecting sort order """
if self._order_by == 'oldest':
return self.newer
if self._order_by == 'newest':
return self.older
return None | python | def next(self):
""" Gets the next page, respecting sort order """
if self._order_by == 'oldest':
return self.newer
if self._order_by == 'newest':
return self.older
return None | [
"def",
"next",
"(",
"self",
")",
":",
"if",
"self",
".",
"_order_by",
"==",
"'oldest'",
":",
"return",
"self",
".",
"newer",
"if",
"self",
".",
"_order_by",
"==",
"'newest'",
":",
"return",
"self",
".",
"older",
"return",
"None"
] | Gets the next page, respecting sort order | [
"Gets",
"the",
"next",
"page",
"respecting",
"sort",
"order"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L197-L203 |
PlaidWeb/Publ | publ/view.py | View.newest | def newest(self):
""" Gets the newest entry in the view, regardless of sort order """
if self._order_by == 'newest':
return self.first
if self._order_by == 'oldest':
return self.last
return max(self.entries, key=lambda x: (x.date, x.id)) | python | def newest(self):
""" Gets the newest entry in the view, regardless of sort order """
if self._order_by == 'newest':
return self.first
if self._order_by == 'oldest':
return self.last
return max(self.entries, key=lambda x: (x.date, x.id)) | [
"def",
"newest",
"(",
"self",
")",
":",
"if",
"self",
".",
"_order_by",
"==",
"'newest'",
":",
"return",
"self",
".",
"first",
"if",
"self",
".",
"_order_by",
"==",
"'oldest'",
":",
"return",
"self",
".",
"last",
"return",
"max",
"(",
"self",
".",
"e... | Gets the newest entry in the view, regardless of sort order | [
"Gets",
"the",
"newest",
"entry",
"in",
"the",
"view",
"regardless",
"of",
"sort",
"order"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L206-L212 |
PlaidWeb/Publ | publ/view.py | View.oldest | def oldest(self):
""" Gets the oldest entry in the view, regardless of sort order """
if self._order_by == 'newest':
return self.last
if self._order_by == 'oldest':
return self.first
return min(self.entries, key=lambda x: (x.date, -x.id)) | python | def oldest(self):
""" Gets the oldest entry in the view, regardless of sort order """
if self._order_by == 'newest':
return self.last
if self._order_by == 'oldest':
return self.first
return min(self.entries, key=lambda x: (x.date, -x.id)) | [
"def",
"oldest",
"(",
"self",
")",
":",
"if",
"self",
".",
"_order_by",
"==",
"'newest'",
":",
"return",
"self",
".",
"last",
"if",
"self",
".",
"_order_by",
"==",
"'oldest'",
":",
"return",
"self",
".",
"first",
"return",
"min",
"(",
"self",
".",
"e... | Gets the oldest entry in the view, regardless of sort order | [
"Gets",
"the",
"oldest",
"entry",
"in",
"the",
"view",
"regardless",
"of",
"sort",
"order"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L215-L221 |
PlaidWeb/Publ | publ/view.py | View.paging | def paging(self):
""" Gets the pagination type; compatible with entry.archive(page_type=...) """
if 'date' in self.spec:
_, date_span, _ = utils.parse_date(self.spec['date'])
return date_span
return 'offset' | python | def paging(self):
""" Gets the pagination type; compatible with entry.archive(page_type=...) """
if 'date' in self.spec:
_, date_span, _ = utils.parse_date(self.spec['date'])
return date_span
return 'offset' | [
"def",
"paging",
"(",
"self",
")",
":",
"if",
"'date'",
"in",
"self",
".",
"spec",
":",
"_",
",",
"date_span",
",",
"_",
"=",
"utils",
".",
"parse_date",
"(",
"self",
".",
"spec",
"[",
"'date'",
"]",
")",
"return",
"date_span",
"return",
"'offset'"
] | Gets the pagination type; compatible with entry.archive(page_type=...) | [
"Gets",
"the",
"pagination",
"type",
";",
"compatible",
"with",
"entry",
".",
"archive",
"(",
"page_type",
"=",
"...",
")"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L224-L229 |
PlaidWeb/Publ | publ/view.py | View.pages | def pages(self):
""" Gets a list of all pages for this view """
cur = self
pages = []
while cur.previous:
cur = cur.previous
while cur:
pages.append(cur)
cur = cur.next
return pages | python | def pages(self):
""" Gets a list of all pages for this view """
cur = self
pages = []
while cur.previous:
cur = cur.previous
while cur:
pages.append(cur)
cur = cur.next
return pages | [
"def",
"pages",
"(",
"self",
")",
":",
"cur",
"=",
"self",
"pages",
"=",
"[",
"]",
"while",
"cur",
".",
"previous",
":",
"cur",
"=",
"cur",
".",
"previous",
"while",
"cur",
":",
"pages",
".",
"append",
"(",
"cur",
")",
"cur",
"=",
"cur",
".",
"... | Gets a list of all pages for this view | [
"Gets",
"a",
"list",
"of",
"all",
"pages",
"for",
"this",
"view"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L232-L241 |
PlaidWeb/Publ | publ/view.py | View.tags | def tags(self):
""" Returns a list of all the tags applied to this view """
tag_list = self.spec.get('tag', [])
if isinstance(tag_list, (list, set, tuple)):
return list(tag_list)
return [tag_list] | python | def tags(self):
""" Returns a list of all the tags applied to this view """
tag_list = self.spec.get('tag', [])
if isinstance(tag_list, (list, set, tuple)):
return list(tag_list)
return [tag_list] | [
"def",
"tags",
"(",
"self",
")",
":",
"tag_list",
"=",
"self",
".",
"spec",
".",
"get",
"(",
"'tag'",
",",
"[",
"]",
")",
"if",
"isinstance",
"(",
"tag_list",
",",
"(",
"list",
",",
"set",
",",
"tuple",
")",
")",
":",
"return",
"list",
"(",
"ta... | Returns a list of all the tags applied to this view | [
"Returns",
"a",
"list",
"of",
"all",
"the",
"tags",
"applied",
"to",
"this",
"view"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L254-L259 |
PlaidWeb/Publ | publ/view.py | View._pagination | def _pagination(self):
""" Compute the neighboring pages from this view.
Returns a tuple of older page, newer page.
"""
oldest = self.oldest
newest = self.newest
base = {key: val for key, val in self.spec.items()
if key not in OFFSET_PRIORITY}
oldest_neighbor = View({
**base,
'before': oldest,
'order': 'newest'
}).first if oldest else None
newest_neighbor = View({
**base,
'after': newest,
'order': 'oldest'
}).first if newest else None
if 'date' in self.spec:
return self._get_date_pagination(base, oldest_neighbor, newest_neighbor)
if 'count' in self.spec:
return self._get_count_pagination(base, oldest_neighbor, newest_neighbor)
# we're not paginating
return None, None | python | def _pagination(self):
""" Compute the neighboring pages from this view.
Returns a tuple of older page, newer page.
"""
oldest = self.oldest
newest = self.newest
base = {key: val for key, val in self.spec.items()
if key not in OFFSET_PRIORITY}
oldest_neighbor = View({
**base,
'before': oldest,
'order': 'newest'
}).first if oldest else None
newest_neighbor = View({
**base,
'after': newest,
'order': 'oldest'
}).first if newest else None
if 'date' in self.spec:
return self._get_date_pagination(base, oldest_neighbor, newest_neighbor)
if 'count' in self.spec:
return self._get_count_pagination(base, oldest_neighbor, newest_neighbor)
# we're not paginating
return None, None | [
"def",
"_pagination",
"(",
"self",
")",
":",
"oldest",
"=",
"self",
".",
"oldest",
"newest",
"=",
"self",
".",
"newest",
"base",
"=",
"{",
"key",
":",
"val",
"for",
"key",
",",
"val",
"in",
"self",
".",
"spec",
".",
"items",
"(",
")",
"if",
"key"... | Compute the neighboring pages from this view.
Returns a tuple of older page, newer page. | [
"Compute",
"the",
"neighboring",
"pages",
"from",
"this",
"view",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L262-L293 |
PlaidWeb/Publ | publ/view.py | View._get_date_pagination | def _get_date_pagination(self, base, oldest_neighbor, newest_neighbor):
""" Compute the pagination for date-based views """
_, span, date_format = utils.parse_date(self.spec['date'])
if newest_neighbor:
newer_date = newest_neighbor.date.span(span)[0]
newer_view = View({**base,
'order': self._order_by,
'date': newer_date.format(date_format)})
else:
newer_view = None
if oldest_neighbor:
older_date = oldest_neighbor.date.span(span)[0]
older_view = View({**base,
'order': self._order_by,
'date': older_date.format(date_format)})
else:
older_view = None
return older_view, newer_view | python | def _get_date_pagination(self, base, oldest_neighbor, newest_neighbor):
""" Compute the pagination for date-based views """
_, span, date_format = utils.parse_date(self.spec['date'])
if newest_neighbor:
newer_date = newest_neighbor.date.span(span)[0]
newer_view = View({**base,
'order': self._order_by,
'date': newer_date.format(date_format)})
else:
newer_view = None
if oldest_neighbor:
older_date = oldest_neighbor.date.span(span)[0]
older_view = View({**base,
'order': self._order_by,
'date': older_date.format(date_format)})
else:
older_view = None
return older_view, newer_view | [
"def",
"_get_date_pagination",
"(",
"self",
",",
"base",
",",
"oldest_neighbor",
",",
"newest_neighbor",
")",
":",
"_",
",",
"span",
",",
"date_format",
"=",
"utils",
".",
"parse_date",
"(",
"self",
".",
"spec",
"[",
"'date'",
"]",
")",
"if",
"newest_neigh... | Compute the pagination for date-based views | [
"Compute",
"the",
"pagination",
"for",
"date",
"-",
"based",
"views"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L295-L315 |
PlaidWeb/Publ | publ/view.py | View._get_count_pagination | def _get_count_pagination(self, base, oldest_neighbor, newest_neighbor):
""" Compute the pagination for count-based views """
count = self.spec['count']
out_spec = {**base, 'count': count, 'order': self._order_by}
if self._order_by == 'newest':
older_view = View({**out_spec,
'last': oldest_neighbor}) if oldest_neighbor else None
newer_count = View({**base,
'first': newest_neighbor,
'order': 'oldest',
'count': count}) if newest_neighbor else None
newer_view = View({**out_spec,
'last': newer_count.last}) if newer_count else None
return older_view, newer_view
if self._order_by == 'oldest':
older_count = View({**base,
'last': oldest_neighbor,
'order': 'newest',
'count': count}) if oldest_neighbor else None
older_view = View({**out_spec,
'first': older_count.last}) if older_count else None
newer_view = View({**out_spec,
'first': newest_neighbor}) if newest_neighbor else None
return older_view, newer_view
return None, None | python | def _get_count_pagination(self, base, oldest_neighbor, newest_neighbor):
""" Compute the pagination for count-based views """
count = self.spec['count']
out_spec = {**base, 'count': count, 'order': self._order_by}
if self._order_by == 'newest':
older_view = View({**out_spec,
'last': oldest_neighbor}) if oldest_neighbor else None
newer_count = View({**base,
'first': newest_neighbor,
'order': 'oldest',
'count': count}) if newest_neighbor else None
newer_view = View({**out_spec,
'last': newer_count.last}) if newer_count else None
return older_view, newer_view
if self._order_by == 'oldest':
older_count = View({**base,
'last': oldest_neighbor,
'order': 'newest',
'count': count}) if oldest_neighbor else None
older_view = View({**out_spec,
'first': older_count.last}) if older_count else None
newer_view = View({**out_spec,
'first': newest_neighbor}) if newest_neighbor else None
return older_view, newer_view
return None, None | [
"def",
"_get_count_pagination",
"(",
"self",
",",
"base",
",",
"oldest_neighbor",
",",
"newest_neighbor",
")",
":",
"count",
"=",
"self",
".",
"spec",
"[",
"'count'",
"]",
"out_spec",
"=",
"{",
"*",
"*",
"base",
",",
"'count'",
":",
"count",
",",
"'order... | Compute the pagination for count-based views | [
"Compute",
"the",
"pagination",
"for",
"count",
"-",
"based",
"views"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L317-L350 |
PlaidWeb/Publ | publ/view.py | View.tag_add | def tag_add(self, *tags):
""" Return a view with the specified tags added """
return View({**self.spec, 'tag': list(set(self.tags) | set(tags))}) | python | def tag_add(self, *tags):
""" Return a view with the specified tags added """
return View({**self.spec, 'tag': list(set(self.tags) | set(tags))}) | [
"def",
"tag_add",
"(",
"self",
",",
"*",
"tags",
")",
":",
"return",
"View",
"(",
"{",
"*",
"*",
"self",
".",
"spec",
",",
"'tag'",
":",
"list",
"(",
"set",
"(",
"self",
".",
"tags",
")",
"|",
"set",
"(",
"tags",
")",
")",
"}",
")"
] | Return a view with the specified tags added | [
"Return",
"a",
"view",
"with",
"the",
"specified",
"tags",
"added"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L355-L357 |
PlaidWeb/Publ | publ/view.py | View.tag_remove | def tag_remove(self, *tags):
""" Return a view with the specified tags removed """
return View({**self.spec, 'tag': list(set(self.tags) - set(tags))}) | python | def tag_remove(self, *tags):
""" Return a view with the specified tags removed """
return View({**self.spec, 'tag': list(set(self.tags) - set(tags))}) | [
"def",
"tag_remove",
"(",
"self",
",",
"*",
"tags",
")",
":",
"return",
"View",
"(",
"{",
"*",
"*",
"self",
".",
"spec",
",",
"'tag'",
":",
"list",
"(",
"set",
"(",
"self",
".",
"tags",
")",
"-",
"set",
"(",
"tags",
")",
")",
"}",
")"
] | Return a view with the specified tags removed | [
"Return",
"a",
"view",
"with",
"the",
"specified",
"tags",
"removed"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L359-L361 |
PlaidWeb/Publ | publ/view.py | View.tag_toggle | def tag_toggle(self, *tags):
""" Return a view with the specified tags toggled """
return View({**self.spec, 'tag': list(set(self.tags) ^ set(tags))}) | python | def tag_toggle(self, *tags):
""" Return a view with the specified tags toggled """
return View({**self.spec, 'tag': list(set(self.tags) ^ set(tags))}) | [
"def",
"tag_toggle",
"(",
"self",
",",
"*",
"tags",
")",
":",
"return",
"View",
"(",
"{",
"*",
"*",
"self",
".",
"spec",
",",
"'tag'",
":",
"list",
"(",
"set",
"(",
"self",
".",
"tags",
")",
"^",
"set",
"(",
"tags",
")",
")",
"}",
")"
] | Return a view with the specified tags toggled | [
"Return",
"a",
"view",
"with",
"the",
"specified",
"tags",
"toggled"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/view.py#L363-L365 |
PlaidWeb/Publ | publ/markdown.py | to_html | def to_html(text, config, search_path):
""" Convert Markdown text to HTML """
processor = misaka.Markdown(HtmlRenderer(config, search_path),
extensions=ENABLED_EXTENSIONS)
text = processor(text)
if not config.get('no_smartquotes'):
text = misaka.smartypants(text)
return flask.Markup(text) | python | def to_html(text, config, search_path):
""" Convert Markdown text to HTML """
processor = misaka.Markdown(HtmlRenderer(config, search_path),
extensions=ENABLED_EXTENSIONS)
text = processor(text)
if not config.get('no_smartquotes'):
text = misaka.smartypants(text)
return flask.Markup(text) | [
"def",
"to_html",
"(",
"text",
",",
"config",
",",
"search_path",
")",
":",
"processor",
"=",
"misaka",
".",
"Markdown",
"(",
"HtmlRenderer",
"(",
"config",
",",
"search_path",
")",
",",
"extensions",
"=",
"ENABLED_EXTENSIONS",
")",
"text",
"=",
"processor",... | Convert Markdown text to HTML | [
"Convert",
"Markdown",
"text",
"to",
"HTML"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/markdown.py#L167-L176 |
PlaidWeb/Publ | publ/markdown.py | render_title | def render_title(text, markup=True, no_smartquotes=False):
""" Convert a Markdown title to HTML """
# HACK: If the title starts with something that looks like a list, save it
# for later
pfx, text = re.match(r'([0-9. ]*)(.*)', text).group(1, 2)
text = pfx + misaka.Markdown(TitleRenderer(),
extensions=TITLE_EXTENSIONS)(text)
if not markup:
strip = HTMLStripper()
strip.feed(text)
text = strip.get_data()
if not no_smartquotes:
text = misaka.smartypants(text)
return flask.Markup(text) | python | def render_title(text, markup=True, no_smartquotes=False):
""" Convert a Markdown title to HTML """
# HACK: If the title starts with something that looks like a list, save it
# for later
pfx, text = re.match(r'([0-9. ]*)(.*)', text).group(1, 2)
text = pfx + misaka.Markdown(TitleRenderer(),
extensions=TITLE_EXTENSIONS)(text)
if not markup:
strip = HTMLStripper()
strip.feed(text)
text = strip.get_data()
if not no_smartquotes:
text = misaka.smartypants(text)
return flask.Markup(text) | [
"def",
"render_title",
"(",
"text",
",",
"markup",
"=",
"True",
",",
"no_smartquotes",
"=",
"False",
")",
":",
"# HACK: If the title starts with something that looks like a list, save it",
"# for later",
"pfx",
",",
"text",
"=",
"re",
".",
"match",
"(",
"r'([0-9. ]*)(... | Convert a Markdown title to HTML | [
"Convert",
"a",
"Markdown",
"title",
"to",
"HTML"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/markdown.py#L218-L235 |
PlaidWeb/Publ | publ/markdown.py | HtmlRenderer.image | def image(self, raw_url, title='', alt=''):
""" Adapt a standard Markdown image to a generated rendition set.
Container arguments used (in addition to the rendition tags):
div_class -- The CSS class name to use on any wrapper div
div_style -- Additional CSS styles to apply to the wrapper div
count -- The maximum number of images to show at once
more_text -- If there are more than `count` images, add this text indicating
that there are more images to be seen. This string gets two template
arguments, `{count}` which is the total number of images in the set,
and `{remain}` which is the number of images omitted from the set.
more_link -- If `more_text` is shown, this will format the text as a link to this location.
more_class -- If `more_text` is shown, wraps it in a `<div>` with this class.
"""
# pylint: disable=too-many-locals
text = ''
image_specs = raw_url
if title:
image_specs += ' "{}"'.format(title)
alt, container_args = image.parse_alt_text(alt)
container_args = {**self._config, **container_args}
spec_list, original_count = image.get_spec_list(
image_specs, container_args)
for spec in spec_list:
text += self._render_image(spec,
container_args,
alt)
if original_count > len(spec_list) and 'more_text' in container_args:
more_text = container_args['more_text'].format(
count=original_count,
remain=original_count - len(spec_list))
if 'more_link' in container_args:
more_text = '{a}{text}</a>'.format(
text=more_text,
a=utils.make_tag('a', {'href': container_args['more_link']}))
if 'more_class' in container_args:
more_text = '{div}{text}</div>'.format(
text=more_text,
div=utils.make_tag('div', {'class': container_args['more_class']}))
text += flask.Markup(more_text)
if text and (container_args.get('div_class') or
container_args.get('div_style')):
text = '{tag}{text}</div>'.format(
tag=utils.make_tag('div',
{'class': container_args.get('div_class'),
'style': container_args.get('div_style')}),
text=text)
# if text is ''/falsy then misaka interprets this as a failed parse...
return text or ' ' | python | def image(self, raw_url, title='', alt=''):
""" Adapt a standard Markdown image to a generated rendition set.
Container arguments used (in addition to the rendition tags):
div_class -- The CSS class name to use on any wrapper div
div_style -- Additional CSS styles to apply to the wrapper div
count -- The maximum number of images to show at once
more_text -- If there are more than `count` images, add this text indicating
that there are more images to be seen. This string gets two template
arguments, `{count}` which is the total number of images in the set,
and `{remain}` which is the number of images omitted from the set.
more_link -- If `more_text` is shown, this will format the text as a link to this location.
more_class -- If `more_text` is shown, wraps it in a `<div>` with this class.
"""
# pylint: disable=too-many-locals
text = ''
image_specs = raw_url
if title:
image_specs += ' "{}"'.format(title)
alt, container_args = image.parse_alt_text(alt)
container_args = {**self._config, **container_args}
spec_list, original_count = image.get_spec_list(
image_specs, container_args)
for spec in spec_list:
text += self._render_image(spec,
container_args,
alt)
if original_count > len(spec_list) and 'more_text' in container_args:
more_text = container_args['more_text'].format(
count=original_count,
remain=original_count - len(spec_list))
if 'more_link' in container_args:
more_text = '{a}{text}</a>'.format(
text=more_text,
a=utils.make_tag('a', {'href': container_args['more_link']}))
if 'more_class' in container_args:
more_text = '{div}{text}</div>'.format(
text=more_text,
div=utils.make_tag('div', {'class': container_args['more_class']}))
text += flask.Markup(more_text)
if text and (container_args.get('div_class') or
container_args.get('div_style')):
text = '{tag}{text}</div>'.format(
tag=utils.make_tag('div',
{'class': container_args.get('div_class'),
'style': container_args.get('div_style')}),
text=text)
# if text is ''/falsy then misaka interprets this as a failed parse...
return text or ' ' | [
"def",
"image",
"(",
"self",
",",
"raw_url",
",",
"title",
"=",
"''",
",",
"alt",
"=",
"''",
")",
":",
"# pylint: disable=too-many-locals",
"text",
"=",
"''",
"image_specs",
"=",
"raw_url",
"if",
"title",
":",
"image_specs",
"+=",
"' \"{}\"'",
".",
"format... | Adapt a standard Markdown image to a generated rendition set.
Container arguments used (in addition to the rendition tags):
div_class -- The CSS class name to use on any wrapper div
div_style -- Additional CSS styles to apply to the wrapper div
count -- The maximum number of images to show at once
more_text -- If there are more than `count` images, add this text indicating
that there are more images to be seen. This string gets two template
arguments, `{count}` which is the total number of images in the set,
and `{remain}` which is the number of images omitted from the set.
more_link -- If `more_text` is shown, this will format the text as a link to this location.
more_class -- If `more_text` is shown, wraps it in a `<div>` with this class. | [
"Adapt",
"a",
"standard",
"Markdown",
"image",
"to",
"a",
"generated",
"rendition",
"set",
"."
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/markdown.py#L43-L101 |
PlaidWeb/Publ | publ/markdown.py | HtmlRenderer.blockcode | def blockcode(self, text, lang):
""" Pass a code fence through pygments """
if lang and self._config.get('highlight_syntax', 'True'):
try:
lexer = pygments.lexers.get_lexer_by_name(lang, stripall=True)
except pygments.lexers.ClassNotFound:
lexer = None
if lexer:
formatter = pygments.formatters.HtmlFormatter() # pylint: disable=no-member
return pygments.highlight(text, lexer, formatter)
return '\n<div class="highlight"><pre>{}</pre></div>\n'.format(
flask.escape(text.strip())) | python | def blockcode(self, text, lang):
""" Pass a code fence through pygments """
if lang and self._config.get('highlight_syntax', 'True'):
try:
lexer = pygments.lexers.get_lexer_by_name(lang, stripall=True)
except pygments.lexers.ClassNotFound:
lexer = None
if lexer:
formatter = pygments.formatters.HtmlFormatter() # pylint: disable=no-member
return pygments.highlight(text, lexer, formatter)
return '\n<div class="highlight"><pre>{}</pre></div>\n'.format(
flask.escape(text.strip())) | [
"def",
"blockcode",
"(",
"self",
",",
"text",
",",
"lang",
")",
":",
"if",
"lang",
"and",
"self",
".",
"_config",
".",
"get",
"(",
"'highlight_syntax'",
",",
"'True'",
")",
":",
"try",
":",
"lexer",
"=",
"pygments",
".",
"lexers",
".",
"get_lexer_by_na... | Pass a code fence through pygments | [
"Pass",
"a",
"code",
"fence",
"through",
"pygments"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/markdown.py#L103-L116 |
PlaidWeb/Publ | publ/markdown.py | HtmlRenderer.link | def link(self, content, link, title=''):
""" Emit a link, potentially remapped based on our embed or static rules """
link = links.resolve(link, self._search_path,
self._config.get('absolute'))
return '{}{}</a>'.format(
utils.make_tag('a', {
'href': link,
'title': title if title else None
}),
content) | python | def link(self, content, link, title=''):
""" Emit a link, potentially remapped based on our embed or static rules """
link = links.resolve(link, self._search_path,
self._config.get('absolute'))
return '{}{}</a>'.format(
utils.make_tag('a', {
'href': link,
'title': title if title else None
}),
content) | [
"def",
"link",
"(",
"self",
",",
"content",
",",
"link",
",",
"title",
"=",
"''",
")",
":",
"link",
"=",
"links",
".",
"resolve",
"(",
"link",
",",
"self",
".",
"_search_path",
",",
"self",
".",
"_config",
".",
"get",
"(",
"'absolute'",
")",
")",
... | Emit a link, potentially remapped based on our embed or static rules | [
"Emit",
"a",
"link",
"potentially",
"remapped",
"based",
"on",
"our",
"embed",
"or",
"static",
"rules"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/markdown.py#L118-L129 |
PlaidWeb/Publ | publ/markdown.py | HtmlRenderer.paragraph | def paragraph(content):
""" emit a paragraph, stripping out any leading or following empty paragraphs """
# if the content contains a top-level div then don't wrap it in a <p>
# tag
if content.startswith('<div') and content.endswith('</div>'):
return '\n' + content + '\n'
text = '<p>' + content + '</p>'
text = re.sub(r'<p>\s*</p>', r'', text)
return text or ' ' | python | def paragraph(content):
""" emit a paragraph, stripping out any leading or following empty paragraphs """
# if the content contains a top-level div then don't wrap it in a <p>
# tag
if content.startswith('<div') and content.endswith('</div>'):
return '\n' + content + '\n'
text = '<p>' + content + '</p>'
text = re.sub(r'<p>\s*</p>', r'', text)
return text or ' ' | [
"def",
"paragraph",
"(",
"content",
")",
":",
"# if the content contains a top-level div then don't wrap it in a <p>",
"# tag",
"if",
"content",
".",
"startswith",
"(",
"'<div'",
")",
"and",
"content",
".",
"endswith",
"(",
"'</div>'",
")",
":",
"return",
"'\\n'",
"... | emit a paragraph, stripping out any leading or following empty paragraphs | [
"emit",
"a",
"paragraph",
"stripping",
"out",
"any",
"leading",
"or",
"following",
"empty",
"paragraphs"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/markdown.py#L132-L142 |
PlaidWeb/Publ | publ/markdown.py | HtmlRenderer._render_image | def _render_image(self, spec, container_args, alt_text=None):
""" Render an image specification into an <img> tag """
try:
path, image_args, title = image.parse_image_spec(spec)
except Exception as err: # pylint: disable=broad-except
logger.exception("Got error on spec %s: %s", spec, err)
return ('<span class="error">Couldn\'t parse image spec: ' +
'<code>{}</code> {}</span>'.format(flask.escape(spec),
flask.escape(str(err))))
composite_args = {**container_args, **image_args}
try:
img = image.get_image(path, self._search_path)
except Exception as err: # pylint: disable=broad-except
logger.exception("Got error on image %s: %s", path, err)
return ('<span class="error">Error loading image {}: {}</span>'.format(
flask.escape(spec), flask.escape(str(err))))
return img.get_img_tag(title, alt_text, **composite_args) | python | def _render_image(self, spec, container_args, alt_text=None):
""" Render an image specification into an <img> tag """
try:
path, image_args, title = image.parse_image_spec(spec)
except Exception as err: # pylint: disable=broad-except
logger.exception("Got error on spec %s: %s", spec, err)
return ('<span class="error">Couldn\'t parse image spec: ' +
'<code>{}</code> {}</span>'.format(flask.escape(spec),
flask.escape(str(err))))
composite_args = {**container_args, **image_args}
try:
img = image.get_image(path, self._search_path)
except Exception as err: # pylint: disable=broad-except
logger.exception("Got error on image %s: %s", path, err)
return ('<span class="error">Error loading image {}: {}</span>'.format(
flask.escape(spec), flask.escape(str(err))))
return img.get_img_tag(title, alt_text, **composite_args) | [
"def",
"_render_image",
"(",
"self",
",",
"spec",
",",
"container_args",
",",
"alt_text",
"=",
"None",
")",
":",
"try",
":",
"path",
",",
"image_args",
",",
"title",
"=",
"image",
".",
"parse_image_spec",
"(",
"spec",
")",
"except",
"Exception",
"as",
"e... | Render an image specification into an <img> tag | [
"Render",
"an",
"image",
"specification",
"into",
"an",
"<img",
">",
"tag"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/markdown.py#L144-L164 |
PlaidWeb/Publ | publ/links.py | resolve | def resolve(path, search_path, absolute=False):
""" Remap a link or source target to an appropriate entry or image rendition """
# Resolve external URLs
if re.match(r'([a-z][a-z0-9+.\-]*:)?//', path, re.I):
return path
# Resolve static assets
if path.startswith('@'):
return utils.static_url(path[1:], absolute)
path, sep, anchor = path.partition('#')
# Resolve entries
entry = utils.find_entry(path, search_path)
if entry:
return entry.permalink(absolute=absolute) + sep + anchor
# Resolve images and assets
img_path, img_args, _ = image.parse_image_spec(path)
img = image.get_image(img_path, search_path)
if not isinstance(img, image.ImageNotFound):
path, _ = img.get_rendition(**img_args)
return path + sep + anchor | python | def resolve(path, search_path, absolute=False):
""" Remap a link or source target to an appropriate entry or image rendition """
# Resolve external URLs
if re.match(r'([a-z][a-z0-9+.\-]*:)?//', path, re.I):
return path
# Resolve static assets
if path.startswith('@'):
return utils.static_url(path[1:], absolute)
path, sep, anchor = path.partition('#')
# Resolve entries
entry = utils.find_entry(path, search_path)
if entry:
return entry.permalink(absolute=absolute) + sep + anchor
# Resolve images and assets
img_path, img_args, _ = image.parse_image_spec(path)
img = image.get_image(img_path, search_path)
if not isinstance(img, image.ImageNotFound):
path, _ = img.get_rendition(**img_args)
return path + sep + anchor | [
"def",
"resolve",
"(",
"path",
",",
"search_path",
",",
"absolute",
"=",
"False",
")",
":",
"# Resolve external URLs",
"if",
"re",
".",
"match",
"(",
"r'([a-z][a-z0-9+.\\-]*:)?//'",
",",
"path",
",",
"re",
".",
"I",
")",
":",
"return",
"path",
"# Resolve sta... | Remap a link or source target to an appropriate entry or image rendition | [
"Remap",
"a",
"link",
"or",
"source",
"target",
"to",
"an",
"appropriate",
"entry",
"or",
"image",
"rendition"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/links.py#L10-L33 |
PlaidWeb/Publ | publ/caching.py | do_not_cache | def do_not_cache():
""" Return whether we should cache a page render """
from . import index # pylint: disable=cyclic-import
if index.in_progress():
# We are reindexing the site
return True
if request.if_none_match or request.if_modified_since:
# we might be returning a 304 NOT MODIFIED based on a client request,
# and we don't want to cache that as the result for *all* client
# requests to this URI
return True
return False | python | def do_not_cache():
""" Return whether we should cache a page render """
from . import index # pylint: disable=cyclic-import
if index.in_progress():
# We are reindexing the site
return True
if request.if_none_match or request.if_modified_since:
# we might be returning a 304 NOT MODIFIED based on a client request,
# and we don't want to cache that as the result for *all* client
# requests to this URI
return True
return False | [
"def",
"do_not_cache",
"(",
")",
":",
"from",
".",
"import",
"index",
"# pylint: disable=cyclic-import",
"if",
"index",
".",
"in_progress",
"(",
")",
":",
"# We are reindexing the site",
"return",
"True",
"if",
"request",
".",
"if_none_match",
"or",
"request",
"."... | Return whether we should cache a page render | [
"Return",
"whether",
"we",
"should",
"cache",
"a",
"page",
"render"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/caching.py#L20-L35 |
PlaidWeb/Publ | publ/queries.py | where_entry_visible | def where_entry_visible(query, date=None):
""" Generate a where clause for currently-visible entries
Arguments:
date -- The date to generate it relative to (defaults to right now)
"""
return orm.select(
e for e in query
if e.status == model.PublishStatus.PUBLISHED.value or
(e.status == model.PublishStatus.SCHEDULED.value and
(e.utc_date <= (date or arrow.utcnow().datetime))
)
) | python | def where_entry_visible(query, date=None):
""" Generate a where clause for currently-visible entries
Arguments:
date -- The date to generate it relative to (defaults to right now)
"""
return orm.select(
e for e in query
if e.status == model.PublishStatus.PUBLISHED.value or
(e.status == model.PublishStatus.SCHEDULED.value and
(e.utc_date <= (date or arrow.utcnow().datetime))
)
) | [
"def",
"where_entry_visible",
"(",
"query",
",",
"date",
"=",
"None",
")",
":",
"return",
"orm",
".",
"select",
"(",
"e",
"for",
"e",
"in",
"query",
"if",
"e",
".",
"status",
"==",
"model",
".",
"PublishStatus",
".",
"PUBLISHED",
".",
"value",
"or",
... | Generate a where clause for currently-visible entries
Arguments:
date -- The date to generate it relative to (defaults to right now) | [
"Generate",
"a",
"where",
"clause",
"for",
"currently",
"-",
"visible",
"entries"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L10-L24 |
PlaidWeb/Publ | publ/queries.py | where_entry_visible_future | def where_entry_visible_future(query):
""" Generate a where clause for entries that are visible now or in the future """
return orm.select(
e for e in query
if e.status in (model.PublishStatus.PUBLISHED.value,
model.PublishStatus.SCHEDULED.value)) | python | def where_entry_visible_future(query):
""" Generate a where clause for entries that are visible now or in the future """
return orm.select(
e for e in query
if e.status in (model.PublishStatus.PUBLISHED.value,
model.PublishStatus.SCHEDULED.value)) | [
"def",
"where_entry_visible_future",
"(",
"query",
")",
":",
"return",
"orm",
".",
"select",
"(",
"e",
"for",
"e",
"in",
"query",
"if",
"e",
".",
"status",
"in",
"(",
"model",
".",
"PublishStatus",
".",
"PUBLISHED",
".",
"value",
",",
"model",
".",
"Pu... | Generate a where clause for entries that are visible now or in the future | [
"Generate",
"a",
"where",
"clause",
"for",
"entries",
"that",
"are",
"visible",
"now",
"or",
"in",
"the",
"future"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L27-L33 |
PlaidWeb/Publ | publ/queries.py | where_entry_deleted | def where_entry_deleted(query):
""" Generate a where clause for entries that have been deleted """
return orm.select(
e for e in query
if e.status == model.PublishStatus.GONE.value) | python | def where_entry_deleted(query):
""" Generate a where clause for entries that have been deleted """
return orm.select(
e for e in query
if e.status == model.PublishStatus.GONE.value) | [
"def",
"where_entry_deleted",
"(",
"query",
")",
":",
"return",
"orm",
".",
"select",
"(",
"e",
"for",
"e",
"in",
"query",
"if",
"e",
".",
"status",
"==",
"model",
".",
"PublishStatus",
".",
"GONE",
".",
"value",
")"
] | Generate a where clause for entries that have been deleted | [
"Generate",
"a",
"where",
"clause",
"for",
"entries",
"that",
"have",
"been",
"deleted"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L36-L40 |
PlaidWeb/Publ | publ/queries.py | where_entry_category | def where_entry_category(query, category, recurse=False):
""" Generate a where clause for a particular category """
category = str(category)
if category and recurse:
# We're recursing and aren't in /, so add the prefix clause
return orm.select(
e for e in query
if e.category == category or e.category.startswith(category + '/')
)
if not recurse:
# We're not recursing, so we need an exact match on a possibly-empty
# category
return orm.select(e for e in query if e.category == category)
# We're recursing and have no category, which means we're doing nothing
return query | python | def where_entry_category(query, category, recurse=False):
""" Generate a where clause for a particular category """
category = str(category)
if category and recurse:
# We're recursing and aren't in /, so add the prefix clause
return orm.select(
e for e in query
if e.category == category or e.category.startswith(category + '/')
)
if not recurse:
# We're not recursing, so we need an exact match on a possibly-empty
# category
return orm.select(e for e in query if e.category == category)
# We're recursing and have no category, which means we're doing nothing
return query | [
"def",
"where_entry_category",
"(",
"query",
",",
"category",
",",
"recurse",
"=",
"False",
")",
":",
"category",
"=",
"str",
"(",
"category",
")",
"if",
"category",
"and",
"recurse",
":",
"# We're recursing and aren't in /, so add the prefix clause",
"return",
"orm... | Generate a where clause for a particular category | [
"Generate",
"a",
"where",
"clause",
"for",
"a",
"particular",
"category"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L43-L60 |
PlaidWeb/Publ | publ/queries.py | where_before_entry | def where_before_entry(query, ref):
""" Generate a where clause for prior entries
ref -- The entry of reference
"""
return orm.select(
e for e in query
if e.local_date < ref.local_date or
(e.local_date == ref.local_date and e.id < ref.id)
) | python | def where_before_entry(query, ref):
""" Generate a where clause for prior entries
ref -- The entry of reference
"""
return orm.select(
e for e in query
if e.local_date < ref.local_date or
(e.local_date == ref.local_date and e.id < ref.id)
) | [
"def",
"where_before_entry",
"(",
"query",
",",
"ref",
")",
":",
"return",
"orm",
".",
"select",
"(",
"e",
"for",
"e",
"in",
"query",
"if",
"e",
".",
"local_date",
"<",
"ref",
".",
"local_date",
"or",
"(",
"e",
".",
"local_date",
"==",
"ref",
".",
... | Generate a where clause for prior entries
ref -- The entry of reference | [
"Generate",
"a",
"where",
"clause",
"for",
"prior",
"entries"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L63-L72 |
PlaidWeb/Publ | publ/queries.py | where_after_entry | def where_after_entry(query, ref):
""" Generate a where clause for later entries
ref -- the entry of reference
"""
return orm.select(
e for e in query
if e.local_date > ref.local_date or
(e.local_date == ref.local_date and
e.id > ref.id
)
) | python | def where_after_entry(query, ref):
""" Generate a where clause for later entries
ref -- the entry of reference
"""
return orm.select(
e for e in query
if e.local_date > ref.local_date or
(e.local_date == ref.local_date and
e.id > ref.id
)
) | [
"def",
"where_after_entry",
"(",
"query",
",",
"ref",
")",
":",
"return",
"orm",
".",
"select",
"(",
"e",
"for",
"e",
"in",
"query",
"if",
"e",
".",
"local_date",
">",
"ref",
".",
"local_date",
"or",
"(",
"e",
".",
"local_date",
"==",
"ref",
".",
"... | Generate a where clause for later entries
ref -- the entry of reference | [
"Generate",
"a",
"where",
"clause",
"for",
"later",
"entries"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L75-L86 |
PlaidWeb/Publ | publ/queries.py | where_entry_last | def where_entry_last(query, ref):
""" Generate a where clause where this is the last entry
ref -- the entry of reference
"""
return orm.select(
e for e in query
if e.local_date < ref.local_date or
(e.local_date == ref.local_date and
e.id <= ref.id
)
) | python | def where_entry_last(query, ref):
""" Generate a where clause where this is the last entry
ref -- the entry of reference
"""
return orm.select(
e for e in query
if e.local_date < ref.local_date or
(e.local_date == ref.local_date and
e.id <= ref.id
)
) | [
"def",
"where_entry_last",
"(",
"query",
",",
"ref",
")",
":",
"return",
"orm",
".",
"select",
"(",
"e",
"for",
"e",
"in",
"query",
"if",
"e",
".",
"local_date",
"<",
"ref",
".",
"local_date",
"or",
"(",
"e",
".",
"local_date",
"==",
"ref",
".",
"l... | Generate a where clause where this is the last entry
ref -- the entry of reference | [
"Generate",
"a",
"where",
"clause",
"where",
"this",
"is",
"the",
"last",
"entry"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L89-L100 |
PlaidWeb/Publ | publ/queries.py | where_entry_first | def where_entry_first(query, ref):
""" Generate a where clause where this is the first entry
ref -- the entry of reference
"""
return orm.select(
e for e in query
if e.local_date > ref.local_date or
(e.local_date == ref.local_date and
e.id >= ref.id
)
) | python | def where_entry_first(query, ref):
""" Generate a where clause where this is the first entry
ref -- the entry of reference
"""
return orm.select(
e for e in query
if e.local_date > ref.local_date or
(e.local_date == ref.local_date and
e.id >= ref.id
)
) | [
"def",
"where_entry_first",
"(",
"query",
",",
"ref",
")",
":",
"return",
"orm",
".",
"select",
"(",
"e",
"for",
"e",
"in",
"query",
"if",
"e",
".",
"local_date",
">",
"ref",
".",
"local_date",
"or",
"(",
"e",
".",
"local_date",
"==",
"ref",
".",
"... | Generate a where clause where this is the first entry
ref -- the entry of reference | [
"Generate",
"a",
"where",
"clause",
"where",
"this",
"is",
"the",
"first",
"entry"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L103-L114 |
PlaidWeb/Publ | publ/queries.py | where_entry_type | def where_entry_type(query, entry_type):
""" Generate a where clause for entries of certain types
entry_type -- one or more entries to check against
"""
if isinstance(entry_type, (list, set, tuple)):
return orm.select(e for e in query if e.entry_type in entry_type)
return orm.select(e for e in query if e.entry_type == entry_type) | python | def where_entry_type(query, entry_type):
""" Generate a where clause for entries of certain types
entry_type -- one or more entries to check against
"""
if isinstance(entry_type, (list, set, tuple)):
return orm.select(e for e in query if e.entry_type in entry_type)
return orm.select(e for e in query if e.entry_type == entry_type) | [
"def",
"where_entry_type",
"(",
"query",
",",
"entry_type",
")",
":",
"if",
"isinstance",
"(",
"entry_type",
",",
"(",
"list",
",",
"set",
",",
"tuple",
")",
")",
":",
"return",
"orm",
".",
"select",
"(",
"e",
"for",
"e",
"in",
"query",
"if",
"e",
... | Generate a where clause for entries of certain types
entry_type -- one or more entries to check against | [
"Generate",
"a",
"where",
"clause",
"for",
"entries",
"of",
"certain",
"types"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L117-L124 |
PlaidWeb/Publ | publ/queries.py | where_entry_tag | def where_entry_tag(query, tag):
""" Generate a where clause for entries with the given tag """
if isinstance(tag, (list, set, tuple)):
tags = [t.lower() for t in tag]
return orm.select(e for e in query for t in e.tags if t.key in tags)
return orm.select(e for e in query for t in e.tags if t.key == tag.lower()) | python | def where_entry_tag(query, tag):
""" Generate a where clause for entries with the given tag """
if isinstance(tag, (list, set, tuple)):
tags = [t.lower() for t in tag]
return orm.select(e for e in query for t in e.tags if t.key in tags)
return orm.select(e for e in query for t in e.tags if t.key == tag.lower()) | [
"def",
"where_entry_tag",
"(",
"query",
",",
"tag",
")",
":",
"if",
"isinstance",
"(",
"tag",
",",
"(",
"list",
",",
"set",
",",
"tuple",
")",
")",
":",
"tags",
"=",
"[",
"t",
".",
"lower",
"(",
")",
"for",
"t",
"in",
"tag",
"]",
"return",
"orm... | Generate a where clause for entries with the given tag | [
"Generate",
"a",
"where",
"clause",
"for",
"entries",
"with",
"the",
"given",
"tag"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L137-L142 |
PlaidWeb/Publ | publ/queries.py | where_entry_date | def where_entry_date(query, datespec):
""" Where clause for entries which match a textual date spec
datespec -- The date spec to check for, in YYYY[[-]MM[[-]DD]] format
"""
date, interval, _ = utils.parse_date(datespec)
start_date, end_date = date.span(interval)
return orm.select(
e for e in query if
e.local_date >= start_date.naive and
e.local_date <= end_date.naive
) | python | def where_entry_date(query, datespec):
""" Where clause for entries which match a textual date spec
datespec -- The date spec to check for, in YYYY[[-]MM[[-]DD]] format
"""
date, interval, _ = utils.parse_date(datespec)
start_date, end_date = date.span(interval)
return orm.select(
e for e in query if
e.local_date >= start_date.naive and
e.local_date <= end_date.naive
) | [
"def",
"where_entry_date",
"(",
"query",
",",
"datespec",
")",
":",
"date",
",",
"interval",
",",
"_",
"=",
"utils",
".",
"parse_date",
"(",
"datespec",
")",
"start_date",
",",
"end_date",
"=",
"date",
".",
"span",
"(",
"interval",
")",
"return",
"orm",
... | Where clause for entries which match a textual date spec
datespec -- The date spec to check for, in YYYY[[-]MM[[-]DD]] format | [
"Where",
"clause",
"for",
"entries",
"which",
"match",
"a",
"textual",
"date",
"spec"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L145-L157 |
PlaidWeb/Publ | publ/queries.py | get_entry | def get_entry(entry):
""" Helper function to get an entry by ID or by object """
if hasattr(entry, 'id'):
return entry
if isinstance(entry, (int, str)):
return model.Entry.get(id=int(entry))
raise ValueError("entry is of unknown type {}".format(type(entry))) | python | def get_entry(entry):
""" Helper function to get an entry by ID or by object """
if hasattr(entry, 'id'):
return entry
if isinstance(entry, (int, str)):
return model.Entry.get(id=int(entry))
raise ValueError("entry is of unknown type {}".format(type(entry))) | [
"def",
"get_entry",
"(",
"entry",
")",
":",
"if",
"hasattr",
"(",
"entry",
",",
"'id'",
")",
":",
"return",
"entry",
"if",
"isinstance",
"(",
"entry",
",",
"(",
"int",
",",
"str",
")",
")",
":",
"return",
"model",
".",
"Entry",
".",
"get",
"(",
"... | Helper function to get an entry by ID or by object | [
"Helper",
"function",
"to",
"get",
"an",
"entry",
"by",
"ID",
"or",
"by",
"object"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L160-L168 |
PlaidWeb/Publ | publ/queries.py | build_query | def build_query(spec):
""" build the where clause based on a view specification
spec -- The view specification. Contains the following possible values:
future -- Boolean; whether to include entries from the future
category -- Which category to limit to
recurse -- Whether to include subcategories
entry_type -- one or more entry types to include
entry_type_not -- one or more entry types to exclude
date -- a date spec
last -- the last entry to end a view on
first -- the first entry to start a view on
before -- get entries from before this one
after -- get entries from after this one
"""
query = model.Entry.select()
# primarily restrict by publication status
if spec.get('_deleted', False):
query = where_entry_deleted(query)
elif spec.get('future', False):
query = where_entry_visible_future(query)
else:
query = where_entry_visible(query)
# restrict by category
if spec.get('category') is not None:
path = str(spec.get('category', ''))
recurse = spec.get('recurse', False)
query = where_entry_category(query, path, recurse)
if spec.get('entry_type') is not None:
query = where_entry_type(query, spec['entry_type'])
if spec.get('entry_type_not') is not None:
query = where_entry_type_not(query, spec['entry_type_not'])
if spec.get('tag') is not None:
query = where_entry_tag(query, spec['tag'])
if spec.get('date') is not None:
query = where_entry_date(query, spec['date'])
if spec.get('last') is not None:
query = where_entry_last(query, get_entry(spec['last']))
if spec.get('first') is not None:
query = where_entry_first(query, get_entry(spec['first']))
if spec.get('before') is not None:
query = where_before_entry(query, get_entry(spec['before']))
if spec.get('after') is not None:
query = where_after_entry(query, get_entry(spec['after']))
return query.distinct() | python | def build_query(spec):
""" build the where clause based on a view specification
spec -- The view specification. Contains the following possible values:
future -- Boolean; whether to include entries from the future
category -- Which category to limit to
recurse -- Whether to include subcategories
entry_type -- one or more entry types to include
entry_type_not -- one or more entry types to exclude
date -- a date spec
last -- the last entry to end a view on
first -- the first entry to start a view on
before -- get entries from before this one
after -- get entries from after this one
"""
query = model.Entry.select()
# primarily restrict by publication status
if spec.get('_deleted', False):
query = where_entry_deleted(query)
elif spec.get('future', False):
query = where_entry_visible_future(query)
else:
query = where_entry_visible(query)
# restrict by category
if spec.get('category') is not None:
path = str(spec.get('category', ''))
recurse = spec.get('recurse', False)
query = where_entry_category(query, path, recurse)
if spec.get('entry_type') is not None:
query = where_entry_type(query, spec['entry_type'])
if spec.get('entry_type_not') is not None:
query = where_entry_type_not(query, spec['entry_type_not'])
if spec.get('tag') is not None:
query = where_entry_tag(query, spec['tag'])
if spec.get('date') is not None:
query = where_entry_date(query, spec['date'])
if spec.get('last') is not None:
query = where_entry_last(query, get_entry(spec['last']))
if spec.get('first') is not None:
query = where_entry_first(query, get_entry(spec['first']))
if spec.get('before') is not None:
query = where_before_entry(query, get_entry(spec['before']))
if spec.get('after') is not None:
query = where_after_entry(query, get_entry(spec['after']))
return query.distinct() | [
"def",
"build_query",
"(",
"spec",
")",
":",
"query",
"=",
"model",
".",
"Entry",
".",
"select",
"(",
")",
"# primarily restrict by publication status",
"if",
"spec",
".",
"get",
"(",
"'_deleted'",
",",
"False",
")",
":",
"query",
"=",
"where_entry_deleted",
... | build the where clause based on a view specification
spec -- The view specification. Contains the following possible values:
future -- Boolean; whether to include entries from the future
category -- Which category to limit to
recurse -- Whether to include subcategories
entry_type -- one or more entry types to include
entry_type_not -- one or more entry types to exclude
date -- a date spec
last -- the last entry to end a view on
first -- the first entry to start a view on
before -- get entries from before this one
after -- get entries from after this one | [
"build",
"the",
"where",
"clause",
"based",
"on",
"a",
"view",
"specification"
] | train | https://github.com/PlaidWeb/Publ/blob/ce7893632ddc3cb70b4978a41ffd7dd06fa13565/publ/queries.py#L171-L227 |
misakar/mana | mana/mana.py | start_init_info | def start_init_info(path):
"""
start init msg
"""
if os.path.isdir(path):
warning_path_exist(path)
exit(1)
else:
logger.info('''\033[33m{Info}\033[0m
==> start init your flask project [on]
==> \033[32m%s\033[0m\n''' % path) | python | def start_init_info(path):
"""
start init msg
"""
if os.path.isdir(path):
warning_path_exist(path)
exit(1)
else:
logger.info('''\033[33m{Info}\033[0m
==> start init your flask project [on]
==> \033[32m%s\033[0m\n''' % path) | [
"def",
"start_init_info",
"(",
"path",
")",
":",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"path",
")",
":",
"warning_path_exist",
"(",
"path",
")",
"exit",
"(",
"1",
")",
"else",
":",
"logger",
".",
"info",
"(",
"'''\\033[33m{Info}\\033[0m\n ==> star... | start init msg | [
"start",
"init",
"msg"
] | train | https://github.com/misakar/mana/blob/95ccdbf230ed7abc33ea2c878c66d2c8fc72ea69/mana/mana.py#L68-L78 |
misakar/mana | mana/mana.py | create_templates_static_files | def create_templates_static_files(app_path):
"""
create templates and static
"""
templates_path = os.path.join(app_path, 'templates')
static_path = os.path.join(app_path, 'static')
_mkdir_p(templates_path)
_mkdir_p(static_path)
# create {img, css, js}
os.chdir(static_path)
img_path = os.path.join(static_path, 'img')
css_path = os.path.join(static_path, 'css')
js_path = os.path.join(static_path, 'js')
_mkdir_p(img_path)
_mkdir_p(css_path)
_mkdir_p(js_path)
return css_path, templates_path | python | def create_templates_static_files(app_path):
"""
create templates and static
"""
templates_path = os.path.join(app_path, 'templates')
static_path = os.path.join(app_path, 'static')
_mkdir_p(templates_path)
_mkdir_p(static_path)
# create {img, css, js}
os.chdir(static_path)
img_path = os.path.join(static_path, 'img')
css_path = os.path.join(static_path, 'css')
js_path = os.path.join(static_path, 'js')
_mkdir_p(img_path)
_mkdir_p(css_path)
_mkdir_p(js_path)
return css_path, templates_path | [
"def",
"create_templates_static_files",
"(",
"app_path",
")",
":",
"templates_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"app_path",
",",
"'templates'",
")",
"static_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"app_path",
",",
"'static'",
")",
"... | create templates and static | [
"create",
"templates",
"and",
"static"
] | train | https://github.com/misakar/mana/blob/95ccdbf230ed7abc33ea2c878c66d2c8fc72ea69/mana/mana.py#L90-L107 |
misakar/mana | mana/mana.py | create_blueprint | def create_blueprint(app_path, blueprint, views_code, forms_code, templates_path):
"""
create blueprint
"""
blueprint_path = os.path.join(app_path, blueprint)
_mkdir_p(blueprint_path)
# create blueprint files
os.chdir(blueprint_path)
init_code('__init__.py', _init_blueprint_code % (blueprint, blueprint))
init_code('views.py', views_code)
init_code('forms.py', forms_code)
# main blueprint templates
os.chdir(templates_path)
blueprint_templates_path = os.path.join(templates_path, blueprint)
_mkdir_p(blueprint_templates_path)
return blueprint_templates_path | python | def create_blueprint(app_path, blueprint, views_code, forms_code, templates_path):
"""
create blueprint
"""
blueprint_path = os.path.join(app_path, blueprint)
_mkdir_p(blueprint_path)
# create blueprint files
os.chdir(blueprint_path)
init_code('__init__.py', _init_blueprint_code % (blueprint, blueprint))
init_code('views.py', views_code)
init_code('forms.py', forms_code)
# main blueprint templates
os.chdir(templates_path)
blueprint_templates_path = os.path.join(templates_path, blueprint)
_mkdir_p(blueprint_templates_path)
return blueprint_templates_path | [
"def",
"create_blueprint",
"(",
"app_path",
",",
"blueprint",
",",
"views_code",
",",
"forms_code",
",",
"templates_path",
")",
":",
"blueprint_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"app_path",
",",
"blueprint",
")",
"_mkdir_p",
"(",
"blueprint_path... | create blueprint | [
"create",
"blueprint"
] | train | https://github.com/misakar/mana/blob/95ccdbf230ed7abc33ea2c878c66d2c8fc72ea69/mana/mana.py#L110-L126 |
misakar/mana | mana/mana.py | init | def init(project_name):
"""
build a minimal flask project
"""
# the destination path
dst_path = os.path.join(os.getcwd(), project_name)
start_init_info(dst_path)
# create dst path
_mkdir_p(dst_path)
os.chdir(dst_path)
# create files
init_code('manage.py', _manage_basic_code)
init_code('requirement.txt', _requirement_code)
# create app/
app_path = os.path.join(dst_path, 'app')
_mkdir_p(app_path)
os.chdir(app_path)
# create files
init_code('views.py', _views_basic_code)
init_code('forms.py', _forms_basic_code)
init_code('__init__.py', _init_basic_code)
create_templates_static_files(app_path)
init_done_info() | python | def init(project_name):
"""
build a minimal flask project
"""
# the destination path
dst_path = os.path.join(os.getcwd(), project_name)
start_init_info(dst_path)
# create dst path
_mkdir_p(dst_path)
os.chdir(dst_path)
# create files
init_code('manage.py', _manage_basic_code)
init_code('requirement.txt', _requirement_code)
# create app/
app_path = os.path.join(dst_path, 'app')
_mkdir_p(app_path)
os.chdir(app_path)
# create files
init_code('views.py', _views_basic_code)
init_code('forms.py', _forms_basic_code)
init_code('__init__.py', _init_basic_code)
create_templates_static_files(app_path)
init_done_info() | [
"def",
"init",
"(",
"project_name",
")",
":",
"# the destination path",
"dst_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"getcwd",
"(",
")",
",",
"project_name",
")",
"start_init_info",
"(",
"dst_path",
")",
"# create dst path",
"_mkdir_p",
"... | build a minimal flask project | [
"build",
"a",
"minimal",
"flask",
"project"
] | train | https://github.com/misakar/mana/blob/95ccdbf230ed7abc33ea2c878c66d2c8fc72ea69/mana/mana.py#L163-L192 |
misakar/mana | mana/mana.py | blueprint | def blueprint(blueprint_name):
"""
create and register a blueprint
"""
app = os.getcwd().split('/')[-1]
if app != 'app':
logger.warning('''\033[31m{Warning}\033[0m
==> your current path is \033[32m%s\033[0m\n
==> please create your blueprint under app folder!''' % os.getcwd())
exit(1)
# destination path
dst_path = os.path.join(os.getcwd(), blueprint_name)
if os.path.isdir(dst_path):
logger.warning('''\033[31m{Warning}\033[0m
==> bluprint \033[32m%s\033[0m\n exist
==> please try again !''' % dst_path)
exit(1)
# create dst_path
_mkdir_p(dst_path)
# change dir
os.chdir(dst_path)
# create files
init_code('__init__.py', _init_blueprint_code %
(blueprint_name, blueprint_name))
init_code('views.py', _views_blueprint_code %
(blueprint_name, blueprint_name))
init_code('forms.py', _forms_basic_code)
# register auth in app
os.chdir(os.path.join(dst_path, '..'))
with open('__init__.py', 'r+') as f:
prev = pos = 0
while f.readline():
prev, pos = pos, f.tell()
f.seek(prev)
f.write(
'\nfrom %s import %s\napp.register_blueprint(%s, url_prefix="/%s")\n\n'
% (
blueprint_name, blueprint_name,
blueprint_name, blueprint_name
)
)
# create blueprint templates
templates_path = os.path.join(os.getcwd(), 'templates')
os.chdir(templates_path)
blueprint_templates_path = os.path.join(templates_path, blueprint_name)
_mkdir_p(blueprint_templates_path)
logger.info('''\033[33m{Info}\033[0m: create blueprint done!''') | python | def blueprint(blueprint_name):
"""
create and register a blueprint
"""
app = os.getcwd().split('/')[-1]
if app != 'app':
logger.warning('''\033[31m{Warning}\033[0m
==> your current path is \033[32m%s\033[0m\n
==> please create your blueprint under app folder!''' % os.getcwd())
exit(1)
# destination path
dst_path = os.path.join(os.getcwd(), blueprint_name)
if os.path.isdir(dst_path):
logger.warning('''\033[31m{Warning}\033[0m
==> bluprint \033[32m%s\033[0m\n exist
==> please try again !''' % dst_path)
exit(1)
# create dst_path
_mkdir_p(dst_path)
# change dir
os.chdir(dst_path)
# create files
init_code('__init__.py', _init_blueprint_code %
(blueprint_name, blueprint_name))
init_code('views.py', _views_blueprint_code %
(blueprint_name, blueprint_name))
init_code('forms.py', _forms_basic_code)
# register auth in app
os.chdir(os.path.join(dst_path, '..'))
with open('__init__.py', 'r+') as f:
prev = pos = 0
while f.readline():
prev, pos = pos, f.tell()
f.seek(prev)
f.write(
'\nfrom %s import %s\napp.register_blueprint(%s, url_prefix="/%s")\n\n'
% (
blueprint_name, blueprint_name,
blueprint_name, blueprint_name
)
)
# create blueprint templates
templates_path = os.path.join(os.getcwd(), 'templates')
os.chdir(templates_path)
blueprint_templates_path = os.path.join(templates_path, blueprint_name)
_mkdir_p(blueprint_templates_path)
logger.info('''\033[33m{Info}\033[0m: create blueprint done!''') | [
"def",
"blueprint",
"(",
"blueprint_name",
")",
":",
"app",
"=",
"os",
".",
"getcwd",
"(",
")",
".",
"split",
"(",
"'/'",
")",
"[",
"-",
"1",
"]",
"if",
"app",
"!=",
"'app'",
":",
"logger",
".",
"warning",
"(",
"'''\\033[31m{Warning}\\033[0m\n==> your cu... | create and register a blueprint | [
"create",
"and",
"register",
"a",
"blueprint"
] | train | https://github.com/misakar/mana/blob/95ccdbf230ed7abc33ea2c878c66d2c8fc72ea69/mana/mana.py#L197-L249 |
misakar/mana | mana/mana.py | startproject | def startproject(project_name):
"""
build a full status project
"""
# the destination path
dst_path = os.path.join(os.getcwd(), project_name)
start_init_info(dst_path)
# create dst path
_mkdir_p(dst_path)
# create project tree
os.chdir(dst_path)
# create files
init_code('manage.py', _manage_admin_code)
init_code('requirement.txt', _requirement_admin_code)
init_code('config.py', _config_sql_code)
# create app/
app_path = os.path.join(dst_path, 'app')
_mkdir_p(app_path)
# create files
os.chdir(app_path)
init_code('models.py', _models_admin_code)
init_code('__init__.py', _init_admin_code)
# create templates and static
css_path, templates_path = create_templates_static_files(app_path)
# create css files
os.chdir(css_path)
init_code('sign.css', _auth_login_css_code)
# create main blueprint
create_blueprint(
app_path,
'main',
_views_blueprint_code % ('main', 'main'),
_forms_basic_code,
templates_path
)
# create auth blueprint
auth_templates_path = create_blueprint(
app_path,
'auth',
_auth_views_code,
_auth_forms_code,
templates_path
)
# create auth templates files
os.chdir(auth_templates_path)
init_code('login.html', _auth_login_html_code)
# create admin site
admin_path = os.path.join(app_path, 'admin')
_mkdir_p(admin_path)
# create admin files
os.chdir(admin_path)
init_code('__init__.py', '')
init_code('views.py', _admin_views_code)
# create admin templates
os.chdir(templates_path)
admin_templates_path = os.path.join(templates_path, 'admin')
_mkdir_p(admin_templates_path)
# create admin templates files
os.chdir(admin_templates_path)
init_code('index.html', _admin_index_html_code)
init_code('logout.html', _admin_logout_html_code)
init_done_info() | python | def startproject(project_name):
"""
build a full status project
"""
# the destination path
dst_path = os.path.join(os.getcwd(), project_name)
start_init_info(dst_path)
# create dst path
_mkdir_p(dst_path)
# create project tree
os.chdir(dst_path)
# create files
init_code('manage.py', _manage_admin_code)
init_code('requirement.txt', _requirement_admin_code)
init_code('config.py', _config_sql_code)
# create app/
app_path = os.path.join(dst_path, 'app')
_mkdir_p(app_path)
# create files
os.chdir(app_path)
init_code('models.py', _models_admin_code)
init_code('__init__.py', _init_admin_code)
# create templates and static
css_path, templates_path = create_templates_static_files(app_path)
# create css files
os.chdir(css_path)
init_code('sign.css', _auth_login_css_code)
# create main blueprint
create_blueprint(
app_path,
'main',
_views_blueprint_code % ('main', 'main'),
_forms_basic_code,
templates_path
)
# create auth blueprint
auth_templates_path = create_blueprint(
app_path,
'auth',
_auth_views_code,
_auth_forms_code,
templates_path
)
# create auth templates files
os.chdir(auth_templates_path)
init_code('login.html', _auth_login_html_code)
# create admin site
admin_path = os.path.join(app_path, 'admin')
_mkdir_p(admin_path)
# create admin files
os.chdir(admin_path)
init_code('__init__.py', '')
init_code('views.py', _admin_views_code)
# create admin templates
os.chdir(templates_path)
admin_templates_path = os.path.join(templates_path, 'admin')
_mkdir_p(admin_templates_path)
# create admin templates files
os.chdir(admin_templates_path)
init_code('index.html', _admin_index_html_code)
init_code('logout.html', _admin_logout_html_code)
init_done_info() | [
"def",
"startproject",
"(",
"project_name",
")",
":",
"# the destination path",
"dst_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"getcwd",
"(",
")",
",",
"project_name",
")",
"start_init_info",
"(",
"dst_path",
")",
"# create dst path",
"_mkdir... | build a full status project | [
"build",
"a",
"full",
"status",
"project"
] | train | https://github.com/misakar/mana/blob/95ccdbf230ed7abc33ea2c878c66d2c8fc72ea69/mana/mana.py#L254-L327 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.