_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q11100 | InstanceAssertionsMixin.assert_instance_created | train | def assert_instance_created(self, model_class, **kwargs):
"""
Checks if a model instance was created in the database.
For example::
>>> with self.assert_instance_created(Article, slug='lorem-ipsum'):
... Article.objects.create(slug='lorem-ipsum')
"""
return ... | python | {
"resource": ""
} |
q11101 | InstanceAssertionsMixin.assert_instance_deleted | train | def assert_instance_deleted(self, model_class, **kwargs):
"""
Checks if the model instance was deleted from the database.
For example::
>>> with self.assert_instance_deleted(Article, slug='lorem-ipsum'):
... Article.objects.get(slug='lorem-ipsum').delete()
"""
... | python | {
"resource": ""
} |
q11102 | _split_into_mimetype_and_priority | train | def _split_into_mimetype_and_priority(x):
"""Split an accept header item into mimetype and priority.
>>> _split_into_mimetype_and_priority('text/*')
('text/*', 1.0)
>>> _split_into_mimetype_and_priority('application/json;q=0.5')
('application/json', 0.5)
"""
if ';' in x:
content_ty... | python | {
"resource": ""
} |
q11103 | _parse_and_sort_accept_header | train | def _parse_and_sort_accept_header(accept_header):
"""Parse and sort the accept header items.
>>> _parse_and_sort_accept_header('application/json;q=0.5, text/*')
[('text/*', 1.0), ('application/json', 0.5)]
"""
return sorted([_split_into_mimetype_and_priority(x) for x in accept_header.split(',')],
... | python | {
"resource": ""
} |
q11104 | accept_best_match | train | def accept_best_match(accept_header, mimetypes):
"""Return a mimetype best matched the accept headers.
>>> accept_best_match('application/json, text/html', ['application/json', 'text/plain'])
'application/json'
>>> accept_best_match('application/json;q=0.5, text/*', ['application/json', 'text/plain'])... | python | {
"resource": ""
} |
q11105 | match_url_vars_type | train | def match_url_vars_type(url_vars, type_hints):
""" Match types of url vars.
>>> match_url_vars_type({'user_id': '1'}, {'user_id': int})
(True, {'user_id': 1})
>>> match_url_vars_type({'user_id': 'foo'}, {'user_id': int})
(False, {})
"""
typed_url_vars = {}
try:
for k, v in url_v... | python | {
"resource": ""
} |
q11106 | match_path | train | def match_path(rule, path):
""" Match path.
>>> match_path('/foo', '/foo')
(True, {})
>>> match_path('/foo', '/bar')
(False, {})
>>> match_path('/users/{user_id}', '/users/1')
(True, {'user_id': '1'})
>>> match_path('/users/{user_id}', '/users/not-integer')
(True, {'user_id': 'not-i... | python | {
"resource": ""
} |
q11107 | Router.match | train | def match(self, path, method):
""" Get callback and url_vars.
>>> from kobin import Response
>>> r = Router()
>>> def view(user_id: int) -> Response:
... return Response(f'You are {user_id}')
...
>>> r.add('/users/{user_id}', 'GET', 'user-detail', view)
... | python | {
"resource": ""
} |
q11108 | Router.reverse | train | def reverse(self, name, **kwargs):
""" Reverse routing.
>>> from kobin import Response
>>> r = Router()
>>> def view(user_id: int) -> Response:
... return Response(f'You are {user_id}')
...
>>> r.add('/users/{user_id}', 'GET', 'user-detail', view)
>>>... | python | {
"resource": ""
} |
q11109 | synchronized | train | def synchronized(fn):
'''
A decorator which acquires a lock before attempting to execute its wrapped
function. Releases the lock in a finally clause.
:param fn: The function to wrap.
'''
lock = threading.Lock()
@functools.wraps(fn)
def decorated(*args, **kwargs):
lock.acquire()... | python | {
"resource": ""
} |
q11110 | ARef.notify_watches | train | def notify_watches(self, oldval, newval):
'''
Passes `oldval` and `newval` to each `fn` in the watches dictionary,
passing along its respective key and the reference to this object.
:param oldval: The old value which will be passed to the watch.
:param newval: The new value whic... | python | {
"resource": ""
} |
q11111 | Atom.swap | train | def swap(self, fn, *args, **kwargs):
'''
Given a mutator `fn`, calls `fn` with the atom's current state, `args`,
and `kwargs`. The return value of this invocation becomes the new value
of the atom. Returns the new value.
:param fn: A function which will be passed the current sta... | python | {
"resource": ""
} |
q11112 | Atom.reset | train | def reset(self, newval):
'''
Resets the atom's value to `newval`, returning `newval`.
:param newval: The new value to set.
'''
oldval = self._state.get()
self._state.set(newval)
self.notify_watches(oldval, newval)
return newval | python | {
"resource": ""
} |
q11113 | Atom.compare_and_set | train | def compare_and_set(self, oldval, newval):
'''
Given `oldval` and `newval`, sets the atom's value to `newval` if and
only if `oldval` is the atom's current value. Returns `True` upon
success, otherwise `False`.
:param oldval: The old expected value.
:param newval: The ne... | python | {
"resource": ""
} |
q11114 | find_conda | train | def find_conda():
""" Try to find conda on the system """
USER_HOME = os.path.expanduser('~')
CONDA_HOME = os.environ.get('CONDA_HOME', '')
PROGRAMDATA = os.environ.get('PROGRAMDATA', '')
# Search common install paths and sys path
search_paths = [
# Windows
join(PROGRAMDATA, 'mi... | python | {
"resource": ""
} |
q11115 | cp | train | def cp(src, dst):
""" Like cp -R src dst """
print("[DEBUG]: -> copying {} to {}".format(src, dst))
if os.path.isfile(src):
if not exists(dirname(dst)):
os.makedirs(dirname(dst))
shutil.copy(src, dst)
else:
copy_tree(src, dst) | python | {
"resource": ""
} |
q11116 | find_commands | train | def find_commands(cls):
""" Finds commands by finding the subclasses of Command"""
cmds = []
for subclass in cls.__subclasses__():
cmds.append(subclass)
cmds.extend(find_commands(subclass))
return cmds | python | {
"resource": ""
} |
q11117 | Link.link | train | def link(self, path, pkg):
""" Link the package in the current directory.
"""
# Check if a custom linker exists to handle linking this package
#for ep in pkg_resources.iter_entry_points(group="enaml_native_linker"):
# if ep.name.replace("-", '_') == pkg.replace("-", '_'):
... | python | {
"resource": ""
} |
q11118 | Link.is_app_linked | train | def is_app_linked(source, pkg, java_package):
""" Returns true if the compile project line exists exists in the file
"""
for line in source.split("\n"):
if java_package in line:
return True
return False | python | {
"resource": ""
} |
q11119 | Unlink.run | train | def run(self, args=None):
""" The name IS required here. """
print(Colors.BLUE+"[INFO] Unlinking {}...".format(
args.names)+Colors.RESET)
for name in args.names:
self.unlink(Link.package_dir, name) | python | {
"resource": ""
} |
q11120 | Unlink.unlink | train | def unlink(self, path, pkg):
""" Unlink the package in the current directory.
"""
#: Check if a custom unlinker exists to handle unlinking this package
for ep in pkg_resources.iter_entry_points(
group="enaml_native_unlinker"):
if ep.name.replace("-", '_') == p... | python | {
"resource": ""
} |
q11121 | Server.run_tornado | train | def run_tornado(self, args):
""" Tornado dev server implementation """
server = self
import tornado.ioloop
import tornado.web
import tornado.websocket
ioloop = tornado.ioloop.IOLoop.current()
class DevWebSocketHandler(tornado.websocket.WebSocketHandler):
... | python | {
"resource": ""
} |
q11122 | Server.run_twisted | train | def run_twisted(self, args):
""" Twisted dev server implementation """
server = self
from twisted.internet import reactor
from twisted.web import resource
from twisted.web.static import File
from twisted.web.server import Site
from autobahn.twisted.websocket impo... | python | {
"resource": ""
} |
q11123 | Server.on_message | train | def on_message(self, handler, msg):
""" In remote debugging mode this simply acts as a forwarding
proxy for the two clients.
"""
if self.remote_debugging:
#: Forward to other clients
for h in self.handlers:
if h != handler:
h.wr... | python | {
"resource": ""
} |
q11124 | Server.send_message | train | def send_message(self, msg):
""" Send a message to the client. This should not be used in
remote debugging mode.
"""
if not self.handlers:
return #: Client not connected
for h in self.handlers:
h.write_message(msg) | python | {
"resource": ""
} |
q11125 | EnamlNativeCli._default_commands | train | def _default_commands(self):
""" Build the list of CLI commands by finding subclasses of the Command
class
Also allows commands to be installed using the "enaml_native_command"
entry point. This entry point should return a Command subclass
"""
commands = [c() for c in... | python | {
"resource": ""
} |
q11126 | EnamlNativeCli._default_ctx | train | def _default_ctx(self):
""" Return the package config or context and normalize some of the
values
"""
if not self.in_app_directory:
print("Warning: {} does not exist. Using the default.".format(
self.package))
ctx = {}
else:
... | python | {
"resource": ""
} |
q11127 | EnamlNativeCli._default_parser | train | def _default_parser(self):
""" Generate a parser using the command list """
parser = ArgumentParser(prog='enaml-native')
#: Build commands by name
cmds = {c.title: c for c in self.commands}
#: Build parser, prepare commands
subparsers = parser.add_subparsers()
f... | python | {
"resource": ""
} |
q11128 | EnamlNativeCli.start | train | def start(self):
""" Run the commands"""
self.check_dependencies()
self.args = self.parser.parse_args()
# Python 3 doesn't set the cmd if no args are given
if not hasattr(self.args, 'cmd'):
self.parser.print_help()
return
cmd = self.args.cmd
... | python | {
"resource": ""
} |
q11129 | find_data | train | def find_data(folder):
""" Include everything in the folder """
for (path, directories, filenames) in os.walk(folder):
for filename in filenames:
yield os.path.join('..', path, filename) | python | {
"resource": ""
} |
q11130 | generate | train | def generate(number=4, choice=SystemRandom().choice, words=words, joiner=" "):
"""
Generate a random passphrase from the GSL.
"""
return joiner.join(choice(words) for each in range(number)) | python | {
"resource": ""
} |
q11131 | Trk.write_meta_info | train | def write_meta_info(self, byte1, byte2, data):
"Worker method for writing meta info"
write_varlen(self.data, 0) # tick
write_byte(self.data, byte1)
write_byte(self.data, byte2)
write_varlen(self.data, len(data))
write_chars(self.data, data) | python | {
"resource": ""
} |
q11132 | how_long | train | def how_long(length=4, choices=len(words), speed=1000 * 1000 * 1000 * 1000,
optimism=2):
"""
How long might it take to guess a password?
@param length: the number of words that we're going to choose.
@type length: L{int}
@param choice: the number of words we might choose between.
... | python | {
"resource": ""
} |
q11133 | SeqBase.zip | train | def zip(self, other):
"""
zips two sequences unifying the corresponding points.
"""
return self.__class__(p1 % p2 for p1, p2 in zip(self, other)) | python | {
"resource": ""
} |
q11134 | SeqBase.display | train | def display(self, format="png"):
"""
Return an object that can be used to display this sequence.
This is used for IPython Notebook.
:param format: "png" or "svg"
"""
from sebastian.core.transforms import lilypond
seq = HSeq(self) | lilypond()
lily_output... | python | {
"resource": ""
} |
q11135 | HSeq.append | train | def append(self, point):
"""
appends a copy of the given point to this sequence
"""
point = Point(point)
self._elements.append(point) | python | {
"resource": ""
} |
q11136 | HSeq.repeat | train | def repeat(self, count):
"""
repeat sequence given number of times to produce a new sequence
"""
x = HSeq()
for i in range(count):
x = x.concatenate(self)
return x | python | {
"resource": ""
} |
q11137 | arpeggio | train | def arpeggio(pattern, point):
"""
turns each subsequence into an arpeggio matching the given ``pattern``.
"""
point['sequence'] = HSeq(point['sequence'][i] for i in pattern)
return point | python | {
"resource": ""
} |
q11138 | fill | train | def fill(duration, point):
"""
fills the subsequence of the point with repetitions of its subsequence and
sets the ``duration`` of each point.
"""
point['sequence'] = point['sequence'] * (point[DURATION_64] / (8 * duration)) | add({DURATION_64: duration})
return point | python | {
"resource": ""
} |
q11139 | expand | train | def expand(sequence):
"""
expands a tree of sequences into a single, flat sequence, recursively.
"""
expanse = []
for point in sequence:
if 'sequence' in point:
expanse.extend(expand(point['sequence']))
else:
expanse.append(point)
return sequence.__class__... | python | {
"resource": ""
} |
q11140 | debug | train | def debug(sequence):
"""
adds information to the sequence for better debugging, currently only
an index property on each point in the sequence.
"""
points = []
for i, p in enumerate(sequence):
copy = Point(p)
copy['index'] = i
points.append(copy)
return sequence.__cla... | python | {
"resource": ""
} |
q11141 | transform_sequence | train | def transform_sequence(f):
"""
A decorator to take a function operating on a point and
turn it into a function returning a callable operating on a sequence.
The functions passed to this decorator must define a kwarg called "point",
or have point be the last positional argument
"""
@wraps(f)
... | python | {
"resource": ""
} |
q11142 | subseq | train | def subseq(start_offset=0, end_offset=None):
"""
Return a portion of the input sequence
"""
def _(sequence):
return sequence.subseq(start_offset, end_offset)
return _ | python | {
"resource": ""
} |
q11143 | lilypond | train | def lilypond(point):
"""
Generate lilypond representation for a point
"""
#If lilypond already computed, leave as is
if "lilypond" in point:
return point
#Defaults:
pitch_string = ""
octave_string = ""
duration_string = ""
preamble = ""
dynamic_string = ""
if "pi... | python | {
"resource": ""
} |
q11144 | dynamics | train | def dynamics(start, end=None):
"""
Apply dynamics to a sequence. If end is specified, it will crescendo or diminuendo linearly from start to end dynamics.
You can pass any of these strings as dynamic markers: ['pppppp', 'ppppp', 'pppp', 'ppp', 'pp', 'p', 'mp', 'mf', 'f', 'ff', 'fff', ''ffff]
Args:
... | python | {
"resource": ""
} |
q11145 | query_revisions_by_revids | train | def query_revisions_by_revids(session, revids, **params):
"""
Gets a set of revisions by their IDs by repeatedly querying in batches.
If an ID cannot be found, it is ignored.
"""
doc = session.get(action='query', prop='revisions',
revids=revids, **params)
for page_doc in d... | python | {
"resource": ""
} |
q11146 | load_metafile | train | def load_metafile(filepath):
""" Load a metadata file from the filesystem """
try:
with open(filepath, 'r', encoding='utf-8') as file:
return email.message_from_file(file)
except FileNotFoundError:
logger.warning("Category file %s not found", filepath)
orm.delete(c for c ... | python | {
"resource": ""
} |
q11147 | Category.name | train | def name(self):
""" Get the display name of the category """
if self._meta and self._meta.get('name'):
# get it from the meta file
return self._meta.get('name')
# infer it from the basename
return self.basename.replace('_', ' ').title() | python | {
"resource": ""
} |
q11148 | Category.description | train | def description(self):
""" Get the textual description of the category """
if self._meta and self._meta.get_payload():
return utils.TrueCallableProxy(self._description)
return utils.CallableProxy(None) | python | {
"resource": ""
} |
q11149 | Category.breadcrumb | train | def breadcrumb(self):
""" Get the category hierarchy leading up to this category, including
root and self.
For example, path/to/long/category will return a list containing
Category('path'), Category('path/to'), and Category('path/to/long').
"""
ret = []
here = se... | python | {
"resource": ""
} |
q11150 | Category.sort_name | train | def sort_name(self):
""" Get the sorting name of this category """
if self._record and self._record.sort_name:
return self._record.sort_name
return self.name | python | {
"resource": ""
} |
q11151 | Category.parent | train | def parent(self):
""" Get the parent category """
if self.path:
return Category(os.path.dirname(self.path))
return None | python | {
"resource": ""
} |
q11152 | Category._get_subcats | train | def _get_subcats(self, recurse=False):
""" Get the subcategories of this category
recurse -- whether to include their subcategories as well
"""
if recurse:
# No need to filter
return sorted([Category(e) for e in self._subcats_recursive],
... | python | {
"resource": ""
} |
q11153 | Category._first | train | def _first(self, **spec):
""" Get the earliest entry in this category, optionally including subcategories """
for record in self._entries(spec).order_by(model.Entry.local_date,
model.Entry.id)[:1]:
return entry.Entry(record)
return N... | python | {
"resource": ""
} |
q11154 | Category._last | train | def _last(self, **spec):
""" Get the latest entry in this category, optionally including subcategories """
for record in self._entries(spec).order_by(orm.desc(model.Entry.local_date),
orm.desc(model.Entry.id))[:1]:
return entry.Entry(record)... | python | {
"resource": ""
} |
q11155 | static_url | train | def static_url(path, absolute=False):
""" Shorthand for returning a URL for the requested static file.
Arguments:
path -- the path to the file (relative to the static files directory)
absolute -- whether the link should be absolute or relative
"""
if os.sep != '/':
path = '/'.join(pat... | python | {
"resource": ""
} |
q11156 | make_tag | train | def make_tag(name, attrs, start_end=False):
""" Build an HTML tag from the given name and attributes.
Arguments:
name -- the name of the tag (p, div, etc.)
attrs -- a dict of attributes to apply to the tag
start_end -- whether this tag should be self-closing
"""
text = '<' + name
if ... | python | {
"resource": ""
} |
q11157 | file_fingerprint | train | def file_fingerprint(fullpath):
""" Get a metadata fingerprint for a file """
stat = os.stat(fullpath)
return ','.join([str(value) for value in [stat.st_ino, stat.st_mtime, stat.st_size] if value]) | python | {
"resource": ""
} |
q11158 | remap_args | train | def remap_args(input_args, remap):
""" Generate a new argument list by remapping keys. The 'remap'
dict maps from destination key -> priority list of source keys
"""
out_args = input_args
for dest_key, src_keys in remap.items():
remap_value = None
if isinstance(src_keys, str):
... | python | {
"resource": ""
} |
q11159 | remap_link_target | train | def remap_link_target(path, absolute=False):
""" remap a link target to a static URL if it's prefixed with @ """
if path.startswith('@'):
# static resource
return static_url(path[1:], absolute=absolute)
if absolute:
# absolute-ify whatever the URL is
return urllib.parse.urlj... | python | {
"resource": ""
} |
q11160 | get_category | train | def get_category(filename):
""" Get a default category name from a filename in a cross-platform manner """
return '/'.join(os.path.dirname(filename).split(os.sep)) | python | {
"resource": ""
} |
q11161 | CallableProxy._default | train | def _default(self):
""" Get the default function return """
if self._default_args:
return self._func(
*self._default_args,
**self._default_kwargs)
return self._func(**self._default_kwargs) | python | {
"resource": ""
} |
q11162 | setup | train | def setup():
""" Set up the database """
try:
db.bind(**config.database_config)
except OSError:
# Attempted to connect to a file-based database where the file didn't
# exist
db.bind(**config.database_config, create_db=True)
rebuild = True
try:
db.generate_ma... | python | {
"resource": ""
} |
q11163 | Entry.visible | train | def visible(self):
""" Returns true if the entry should be viewable """
return self.status not in (PublishStatus.DRAFT.value,
PublishStatus.GONE.value) | python | {
"resource": ""
} |
q11164 | extract_card | train | def extract_card(text, config, image_search_path):
""" Extract card data based on the provided texts. """
card = CardData()
parser = CardParser(card, config, image_search_path)
misaka.Markdown(parser, extensions=markdown.ENABLED_EXTENSIONS)(text)
return card | python | {
"resource": ""
} |
q11165 | CardParser.paragraph | train | def paragraph(self, content):
""" Turn the first paragraph of text into the summary text """
if not self._out.description:
self._out.description = content
return ' ' | python | {
"resource": ""
} |
q11166 | CardParser.image | train | def image(self, raw_url, title='', alt=''):
''' extract the images '''
max_images = self._config.get('count')
if max_images is not None and len(self._out.images) >= max_images:
# We already have enough images, so bail out
return ' '
image_specs = raw_url
... | python | {
"resource": ""
} |
q11167 | CardParser._render_image | train | def _render_image(self, spec, alt=''):
""" Given an image spec, try to turn it into a card image per the configuration """
# pylint: disable=unused-argument
try:
path, image_args, _ = image.parse_image_spec(spec)
except Exception as err: # pylint: disable=broad-except
... | python | {
"resource": ""
} |
q11168 | publ | train | def publ(name, cfg):
""" Create a Flask app and configure it for use with Publ """
config.setup(cfg)
app = _PublApp(name,
template_folder=config.template_folder,
static_folder=config.static_folder,
static_url_path=config.static_url_path)
for ro... | python | {
"resource": ""
} |
q11169 | startup | train | def startup():
""" Startup routine for initiating the content indexer """
model.setup()
index.scan_index(config.content_folder)
index.background_scan(config.content_folder) | python | {
"resource": ""
} |
q11170 | set_cache_expiry | train | def set_cache_expiry(response):
""" Set the cache control headers """
if response.cache_control.max_age is None and 'CACHE_DEFAULT_TIMEOUT' in config.cache:
response.cache_control.max_age = config.cache['CACHE_DEFAULT_TIMEOUT']
return response | python | {
"resource": ""
} |
q11171 | _PublApp.path_alias_regex | train | def path_alias_regex(self, regex):
""" A decorator that adds a path-alias regular expression; calls
add_path_regex """
def decorator(func):
""" Adds the function to the regular expression alias list """
self.add_path_regex(regex, func)
return decorator | python | {
"resource": ""
} |
q11172 | _PublApp.get_path_regex | train | def get_path_regex(self, path):
""" Evaluate the registered path-alias regular expressions """
for regex, func in self._regex_map:
match = re.match(regex, path)
if match:
return func(match)
return None, None | python | {
"resource": ""
} |
q11173 | guess_title | train | def guess_title(basename):
""" Attempt to guess the title from the filename """
base, _ = os.path.splitext(basename)
return re.sub(r'[ _-]+', r' ', base).title() | python | {
"resource": ""
} |
q11174 | get_entry_id | train | def get_entry_id(entry, fullpath, assign_id):
""" Get or generate an entry ID for an entry """
warn_duplicate = False
if 'Entry-ID' in entry:
entry_id = int(entry['Entry-ID'])
else:
entry_id = None
# See if we've inadvertently duplicated an entry ID
if entry_id:
try:
... | python | {
"resource": ""
} |
q11175 | save_file | train | def save_file(fullpath, entry):
""" Save a message file out, without mangling the headers """
with tempfile.NamedTemporaryFile('w', delete=False) as file:
tmpfile = file.name
# we can't just use file.write(str(entry)) because otherwise the
# headers "helpfully" do MIME encoding normaliza... | python | {
"resource": ""
} |
q11176 | expire_file | train | def expire_file(filepath):
""" Expire a record for a missing file """
load_message.cache_clear()
orm.delete(pa for pa in model.PathAlias if pa.entry.file_path == filepath)
orm.delete(item for item in model.Entry if item.file_path == filepath)
orm.commit() | python | {
"resource": ""
} |
q11177 | expire_record | train | def expire_record(record):
""" Expire a record for a missing entry """
load_message.cache_clear()
# This entry no longer exists so delete it, and anything that references it
# SQLite doesn't support cascading deletes so let's just clean up
# manually
orm.delete(pa for pa in model.PathAlias if p... | python | {
"resource": ""
} |
q11178 | Entry._link | train | def _link(self, *args, **kwargs):
""" Returns a link, potentially pre-redirected """
if self._record.redirect_url:
return links.resolve(self._record.redirect_url,
self.search_path, kwargs.get('absolute'))
return self._permalink(*args, **kwargs) | python | {
"resource": ""
} |
q11179 | Entry._permalink | train | def _permalink(self, absolute=False, expand=True, **kwargs):
""" Returns a canonical URL for the item """
return flask.url_for('entry',
entry_id=self._record.id,
category=self._record.category if expand else None,
slu... | python | {
"resource": ""
} |
q11180 | Entry.search_path | train | def search_path(self):
""" The relative image search path for this entry """
return [os.path.dirname(self._record.file_path)] + self.category.search_path | python | {
"resource": ""
} |
q11181 | Entry._message | train | def _message(self):
""" get the message payload """
filepath = self._record.file_path
try:
return load_message(filepath)
except FileNotFoundError:
expire_file(filepath)
empty = email.message.Message()
empty.set_payload('')
retur... | python | {
"resource": ""
} |
q11182 | Entry.body | train | def body(self):
""" Get the above-the-fold entry body text """
body, _, is_markdown = self._entry_content
return TrueCallableProxy(
self._get_markup,
body,
is_markdown) if body else CallableProxy(None) | python | {
"resource": ""
} |
q11183 | Entry.more | train | def more(self):
""" Get the below-the-fold entry body text """
_, more, is_markdown = self._entry_content
return TrueCallableProxy(
self._get_markup,
more,
is_markdown) if more else CallableProxy(None) | python | {
"resource": ""
} |
q11184 | Entry.card | train | def card(self):
""" Get the entry's OpenGraph card """
body, more, is_markdown = self._entry_content
return TrueCallableProxy(
self._get_card,
body or more) if is_markdown else CallableProxy(None) | python | {
"resource": ""
} |
q11185 | Entry.summary | train | def summary(self):
""" Get the entry's summary text """
if self.get('Summary'):
return self.get('Summary')
body, more, is_markdown = self._entry_content
return TrueCallableProxy(
self._get_summary,
body or more) if is_markdown else CallableProxy(None) | python | {
"resource": ""
} |
q11186 | Entry.last_modified | train | def last_modified(self):
""" Get the date of last file modification """
if self.get('Last-Modified'):
return arrow.get(self.get('Last-Modified'))
return self.date | python | {
"resource": ""
} |
q11187 | Entry._get_markup | train | def _get_markup(self, text, is_markdown, **kwargs):
""" get the rendered markup for an entry
is_markdown -- whether the entry is formatted as Markdown
kwargs -- parameters to pass to the Markdown processor
"""
if is_markdown:
return markdown.to_html(
... | python | {
"resource": ""
} |
q11188 | Entry._get_summary | train | def _get_summary(self, text, **kwargs):
""" Render out just the summary """
card = cards.extract_card(text, kwargs, self.search_path)
return flask.Markup((card.description or '').strip()) | python | {
"resource": ""
} |
q11189 | Entry._previous | train | def _previous(self, **kwargs):
""" Get the previous item in any particular category """
spec = self._pagination_default_spec(kwargs)
spec.update(kwargs)
query = queries.build_query(spec)
query = queries.where_before_entry(query, self._record)
for record in query.order_b... | python | {
"resource": ""
} |
q11190 | Entry._next | train | def _next(self, **kwargs):
""" Get the next item in any particular category """
spec = self._pagination_default_spec(kwargs)
spec.update(kwargs)
query = queries.build_query(spec)
query = queries.where_after_entry(query, self._record)
for record in query.order_by(model.E... | python | {
"resource": ""
} |
q11191 | setup | train | def setup(cfg):
""" set up the global configuration from an object """
# copy the necessary configuration values over
this_module = sys.modules[__name__]
for name, value in cfg.items():
if hasattr(this_module, name):
setattr(this_module, name, value) | python | {
"resource": ""
} |
q11192 | mime_type | train | def mime_type(template):
""" infer the content-type from the extension """
_, ext = os.path.splitext(template.filename)
return EXTENSION_MAP.get(ext, 'text/html; charset=utf-8') | python | {
"resource": ""
} |
q11193 | map_template | train | def map_template(category, template_list):
"""
Given a file path and an acceptable list of templates, return the
best-matching template's path relative to the configured template
directory.
Arguments:
category -- The path to map
template_list -- A template to look up (as a string), or a li... | python | {
"resource": ""
} |
q11194 | get_template | train | def get_template(template, relation):
""" Given an entry or a category, return the path to a related template """
if isinstance(relation, Entry):
path = relation.category.path
elif isinstance(relation, Category):
path = relation.path
else:
path = relation
tmpl = map_template... | python | {
"resource": ""
} |
q11195 | image_function | train | def image_function(template=None, entry=None, category=None):
""" Get a function that gets an image """
path = []
if entry is not None:
path += entry.search_path
if category is not None:
# Since the category might be different than the entry's category we add
# this too
... | python | {
"resource": ""
} |
q11196 | render_publ_template | train | 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,
... | python | {
"resource": ""
} |
q11197 | render_error | train | 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... | python | {
"resource": ""
} |
q11198 | render_exception | train | 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, "Sit... | python | {
"resource": ""
} |
q11199 | render_category | train | 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:
... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.