_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q15300 | setup | train | def setup(service_manager, conf, reload_method="reload"):
"""Load services configuration from oslo config object.
It reads ServiceManager and Service configuration options from an
oslo_config.ConfigOpts() object. Also It registers a ServiceManager hook to
reload the configuration file on reload in the master process and in all
children. And then when each child start or reload, the configuration
options are logged if the oslo config option 'log_options' is True.
On children, the configuration file is reloaded before the running the
application reload method.
Options currently supported on ServiceManager and Service:
* graceful_shutdown_timeout
:param service_manager: ServiceManager instance
:type service_manager: cotyledon.ServiceManager
:param conf: Oslo Config object
:type conf: oslo_config.ConfigOpts()
:param reload_method: reload or mutate the config files
:type reload_method: str "reload/mutate"
"""
conf.register_opts(service_opts)
| python | {
"resource": ""
} |
q15301 | ServiceManager.register_hooks | train | def register_hooks(self, on_terminate=None, on_reload=None,
on_new_worker=None, on_dead_worker=None):
"""Register hook methods
This can be callable multiple times to add more hooks, hooks are
executed in added order. If a hook raised an exception, next hooks
will be not executed.
:param on_terminate: method called on SIGTERM
:type on_terminate: callable()
:param on_reload: method called on SIGHUP
:type on_reload: callable()
:param on_new_worker: method called in the child process when this one
is ready
:type on_new_worker: callable(service_id, worker_id, service_obj)
:param on_new_worker: method called when a child died
:type on_new_worker: callable(service_id, worker_id, exit_code)
If window support is planned, hooks callable must support
to be pickle.pickle(). See CPython multiprocessing module documentation
| python | {
"resource": ""
} |
q15302 | ServiceManager.add | train | def add(self, service, workers=1, args=None, kwargs=None):
"""Add a new service to the ServiceManager
:param service: callable that return an instance of :py:class:`Service`
:type service: callable
:param workers: number of processes/workers for this service
:type workers: int
:param args: additional positional arguments for this service
:type args: tuple
:param kwargs: additional keywoard arguments for this service
:type kwargs: dict
:return: a service id
:rtype: uuid.uuid4
| python | {
"resource": ""
} |
q15303 | ServiceManager.reconfigure | train | def reconfigure(self, service_id, workers):
"""Reconfigure a service registered in ServiceManager
:param service_id: the service id
:type service_id: uuid.uuid4
:param workers: number of processes/workers for this service
:type workers: int
:raises: ValueError
"""
try:
sc = self._services[service_id]
except KeyError:
raise ValueError("%s service id doesn't exists" % | python | {
"resource": ""
} |
q15304 | ServiceManager.run | train | def run(self):
"""Start and supervise services workers
This method will start and supervise all children processes
until the master process asked to shutdown by a SIGTERM.
All spawned processes are part of the same unix process group.
"""
| python | {
"resource": ""
} |
q15305 | ServiceManager._reload | train | def _reload(self):
"""reload all children
posix only
"""
self._run_hooks('reload')
# Reset forktimes to respawn services quickly
self._forktimes = []
| python | {
"resource": ""
} |
q15306 | ServiceManager._get_last_worker_died | train | def _get_last_worker_died(self):
"""Return the last died worker information or None"""
for service_id in list(self._running_services.keys()):
# We copy the list to clean the orignal one
processes = list(self._running_services[service_id].items())
for process, worker_id in processes:
if not process.is_alive():
self._run_hooks('dead_worker', service_id, worker_id,
process.exitcode)
if process.exitcode < 0:
sig = _utils.signal_to_name(process.exitcode)
LOG.info('Child %(pid)d killed by signal %(sig)s',
| python | {
"resource": ""
} |
q15307 | ServiceManager._systemd_notify_once | train | def _systemd_notify_once():
"""Send notification once to Systemd that service is ready.
Systemd sets NOTIFY_SOCKET environment variable with the name of the
socket listening for notifications from services.
This method removes the NOTIFY_SOCKET environment variable to ensure
notification is sent only once.
"""
notify_socket = os.getenv('NOTIFY_SOCKET')
if notify_socket:
if notify_socket.startswith('@'):
# abstract namespace socket
notify_socket = '\0%s' % notify_socket[1:]
| python | {
"resource": ""
} |
q15308 | accepts | train | def accepts(*argtypes, **kwargtypes):
"""A function decorator to specify argument types of the function.
Types may be specified either in the order that they appear in the
function or via keyword arguments (just as if you were calling the
function).
Example usage:
| @accepts(Positive0)
| def square_root(x):
| ...
"""
theseargtypes = [T.TypeFactory(a) for a in argtypes]
thesekwargtypes = {k : T.TypeFactory(a) for k,a in kwargtypes.items()}
def _decorator(func):
# @accepts decorator
f = func.__wrapped__ if hasattr(func, "__wrapped__") else func
try:
argtypes = inspect.getcallargs(f, *theseargtypes, **thesekwargtypes)
argtypes = {k: v if issubclass(type(v), T.Type) else T.Constant(v)
for k,v in argtypes.items()}
except TypeError:
raise E.ArgumentTypeError("Invalid argument specification to @accepts in %s" % func.__qualname__)
# Support keyword arguments. Find the name of the **kwargs
# parameter (not necessarily "kwargs") and set it to be a
# dictionary of unspecified types.
kwargname = U.get_func_kwargs_name(func)
if kwargname in argtypes.keys():
| python | {
"resource": ""
} |
q15309 | returns | train | def returns(returntype):
"""A function decorator to specify return type of the function.
Example usage:
| @accepts(Positive0)
| @returns(Positive0)
| def square_root(x):
| ...
"""
returntype = T.TypeFactory(returntype)
def _decorator(func):
# @returns decorator
| python | {
"resource": ""
} |
q15310 | requires | train | def requires(condition):
"""A function decorator to specify entry conditions for the function.
Entry conditions should be a string, which will be evaluated as
Python code. Arguments of the function may be accessed by their
name.
The special syntax "-->" and "<-->" may be used to mean "if" and
"if and only if", respectively. They may not be contained within
sub-expressions.
Note that globals will not be included by default, and must be
manually included using the "namespace" setting, set via
settings.Settings.
Example usage:
| @requires("x >= y")
| def subtract(x, y):
| ...
| @accepts(l=List(Number), log_transform=Boolean)
| @requires("log_transform == True --> min(l) > 0")
| def process_list(l, log_transform=False):
| ...
"""
def _decorator(func, condition=condition):
# @requires decorator
if U.has_fun_prop(func, "requires"):
if not isinstance(U.get_fun_prop(func, "requires"), list):
raise E.InternalError("Invalid requires structure")
base_requires = U.get_fun_prop(func, "requires")
else:
base_requires = []
base_condition = condition
if "<-->" in condition:
condition_parts = | python | {
"resource": ""
} |
q15311 | ensures | train | def ensures(condition):
"""A function decorator to specify exit conditions for the function.
Exit conditions should be a string, which will be evaluated as
Python code. Arguments of the function may be accessed by their
name. The return value of the function may be accessed using the
special variable name "return".
The special syntax "-->" and "<-->" may be used to mean "if" and
"if and only if", respectively. They may not be contained within
sub-expressions.
Values may be compared to previous executions of the function by
including a "`" or "``" after them to check for higher order
properties of the function.
Note that globals will not be included by default, and must be
manually included using the "namespace" setting, set via
settings.Settings.
Example usage:
| @ensures("lower_bound <= return <= upper_bound")
| def search(lower_bound, upper_bound):
| ...
| @ensures("x <= x` --> return <= return`")
| def monotonic(x):
| ...
"""
def _decorator(func, condition=condition):
# @ensures decorator
if U.has_fun_prop(func, "ensures"):
if not isinstance(U.get_fun_prop(func, "ensures"), list):
raise E.InternalError("Invalid ensures strucutre")
ensures_statements = U.get_fun_prop(func, "ensures")
else:
ensures_statements = []
e = condition.replace("return", "__RETURN__")
if "<-->" in e:
e_parts = e.split("<-->")
assert len(e_parts) == 2, "Only one implies per statement in %s condition %s" % (ensurement, func.__qualname__) | python | {
"resource": ""
} |
q15312 | paranoidclass | train | def paranoidclass(cls):
"""A class decorator to specify that class methods contain paranoid decorators.
Example usage:
| @paranoidclass
| class Point:
| def __init__(self, x, y):
| ...
| @returns(Number)
| def distance_from_zero():
| ...
"""
for methname in dir(cls):
meth = getattr(cls, methname)
if U.has_fun_prop(meth, "argtypes"):
argtypes = U.get_fun_prop(meth, "argtypes")
if "self" in argtypes and isinstance(argtypes["self"], T.Self):
argtypes["self"] = T.Generic(cls)
| python | {
"resource": ""
} |
q15313 | paranoidconfig | train | def paranoidconfig(**kwargs):
"""A function decorator to set a local setting.
Settings may be set either globally (using
settings.Settings.set()) or locally using this decorator. The
setting name should be passed as a keyword argument, and the value
to assign the setting should be passed as the value. See
settings.Settings for the different settings which can be set.
Example usage:
| python | {
"resource": ""
} |
q15314 | TypeFactory | train | def TypeFactory(v):
"""Ensure `v` is a valid Type.
This function is used to convert user-specified types into
internal types for the verification engine. It allows Type
subclasses, Type subclass instances, Python type, and user-defined
classes to be passed. Returns an instance of the type of `v`.
Users should never access this function directly.
"""
if v | python | {
"resource": ""
} |
q15315 | profile_v3_to_proofs | train | def profile_v3_to_proofs(profile, fqdn, refresh=False, address = None):
"""
Convert profile format v3 to proofs
"""
proofs = []
try:
test = profile.items()
except:
return proofs
if 'account' in profile:
accounts = profile['account']
else:
return proofs
for account in accounts:
# skip if proof service is not supported
if 'service' in account and account['service'].lower() not in SITES:
| python | {
"resource": ""
} |
q15316 | has_fun_prop | train | def has_fun_prop(f, k):
"""Test whether function `f` has property `k`.
We define properties as annotations added to a function throughout
the process of defining a function for verification, e.g. the
argument types. If `f` is an unannotated function, this returns
False. If `f` has the property named `k`, it returns True.
Otherwise, it returns False.
Users should never access this | python | {
"resource": ""
} |
q15317 | get_fun_prop | train | def get_fun_prop(f, k):
"""Get the value of property `k` from function `f`.
We define properties as annotations added to a function throughout
the process of defining a function for verification, e.g. the
argument types. If `f` does not have a property named `k`, this
throws an error. If `f` has the property named `k`, it returns
the value of it. | python | {
"resource": ""
} |
q15318 | set_fun_prop | train | def set_fun_prop(f, k, v):
"""Set the value of property `k` to be `v` in function `f`.
We define properties as annotations added to a function throughout
the process of defining a function for verification, e.g. the
argument types. This sets function `f`'s property named `k` to be
value `v`.
Users should never access this function directly.
"""
| python | {
"resource": ""
} |
q15319 | Settings.set | train | def set(**kwargs):
"""Set configuration parameters.
Pass keyword arguments for the parameters you would like to
set.
This function is particularly useful to call at the head of
your script file to disable particular features. For example,
>>> from paranoid.settings import Settings
| python | {
"resource": ""
} |
q15320 | Settings._set | train | def _set(name, value, function=None):
"""Internally set a config parameter.
If you call it with no function, it sets the global parameter.
If you call it with a function argument, it sets the value for
the specified function. Normally, this should only be called
with a function argument for internal code.
This should not be called by code outside of the paranoid
module.
"""
if name not in Settings.__global_setting_values.keys():
raise NameError("Invalid setting value")
if name in Settings.__validate_settings.keys():
if not Settings.__validate_settings[name](value):
raise ValueError("Invalid setting: %s = %s" %
(name, value))
# Set the setting either globally (if no function is passed)
# or else locally to the function (if a function is passed).
if function:
if not hasattr(function, Settings.FUNCTION_SETTINGS_NAME):
setattr(function, Settings.FUNCTION_SETTINGS_NAME, {})
# Test if this wraps something. TODO this will fail
# for nested decorators. This also assumes that, if
| python | {
"resource": ""
} |
q15321 | Settings.get | train | def get(name, function=None):
"""Get a setting.
`name` should be the name of the setting to look for. If the
optional argument `function` is passed, this will look for a
value local to the function before retrieving the global
| python | {
"resource": ""
} |
q15322 | Demon.__read_graph | train | def __read_graph(self, network_filename):
"""
Read .ncol network file
:param network_filename: complete | python | {
"resource": ""
} |
q15323 | Demon.execute | train | def execute(self):
"""
Execute Demon algorithm
"""
for n in self.g.nodes():
self.g.node[n]['communities'] = [n]
all_communities = {}
for ego in tqdm.tqdm(nx.nodes(self.g), ncols=35, bar_format='Exec: {l_bar}{bar}'):
ego_minus_ego = nx.ego_graph(self.g, ego, 1, False)
community_to_nodes = self.__overlapping_label_propagation(ego_minus_ego, ego)
# merging phase
for c in community_to_nodes.keys():
if len(community_to_nodes[c]) > self.min_community_size:
| python | {
"resource": ""
} |
q15324 | get_declared_enums | train | def get_declared_enums(metadata, schema, default):
"""
Return a dict mapping SQLAlchemy enumeration types to the set of their
declared values.
:param metadata:
...
:param str schema:
Schema name (e.g. "public").
:returns dict:
{
"my_enum": frozenset(["a", "b", "c"]),
}
"""
types = set(column.type
for table in metadata.tables.values()
| python | {
"resource": ""
} |
q15325 | compare_enums | train | def compare_enums(autogen_context, upgrade_ops, schema_names):
"""
Walk the declared SQLAlchemy schema for every referenced Enum, walk the PG
schema for every definde Enum, then generate SyncEnumValuesOp migrations
for each defined enum that has grown new entries when compared to its
declared version.
Enums that don't exist in the database yet are ignored, since
SQLAlchemy/Alembic will create them as part of the usual migration process.
"""
to_add = set()
for schema in schema_names:
default = autogen_context.dialect.default_schema_name
if schema is None:
schema = default
defined = get_defined_enums(autogen_context.connection, schema)
declared = get_declared_enums(autogen_context.metadata, schema, default)
for | python | {
"resource": ""
} |
q15326 | Memoizer.get | train | def get(self, key, func=None, args=(), kwargs=None, **opts):
"""Manually retrieve a value from the cache, calculating as needed.
Params:
key -> string to store/retrieve value from.
func -> callable to generate value if it does not exist, or has
expired.
args -> positional arguments to call the function with.
kwargs -> keyword arguments to call the function with.
Keyword Params (options):
These will be combined with region values (as selected by the
"region" keyword argument, and then selected by "parent" values
of those regions all the way up the chain to the "default" region).
namespace -> string prefix to apply to the key before get/set.
lock -> lock constructor. See README.
expiry -> float unix expiration time.
max_age -> float number of seconds until the value expires. Only
provide expiry OR max_age, not both.
"""
kwargs = kwargs or {}
key, store = self._expand_opts(key, opts)
# Resolve the etag.
opts['etag'] = call_or_pass(opts.get('etag') or opts.get('etagger'), args, kwargs)
if not isinstance(key, str):
raise TypeError('non-string key of type %s' % type(key))
data = store.get(key)
if data is not None:
| python | {
"resource": ""
} |
q15327 | Memoizer.expire_at | train | def expire_at(self, key, expiry, **opts):
"""Set the explicit unix expiry time of a key."""
key, store = self._expand_opts(key, opts)
data = store.get(key)
if data is not None:
| python | {
"resource": ""
} |
q15328 | Memoizer.expire | train | def expire(self, key, max_age, **opts):
"""Set the maximum age of a given key, in seconds."""
| python | {
"resource": ""
} |
q15329 | Memoizer.ttl | train | def ttl(self, key, **opts):
"""Get the time-to-live of a given key; None if not set."""
key, store = self._expand_opts(key, opts)
if hasattr(store, 'ttl'):
return store.ttl(key)
data = store.get(key)
if data | python | {
"resource": ""
} |
q15330 | Memoizer.exists | train | def exists(self, key, **opts):
"""Return if a key exists in the cache."""
key, store = self._expand_opts(key, opts)
data = store.get(key)
# Note that we do not actually delete the thing here as the max_age
# just for this call may | python | {
"resource": ""
} |
q15331 | WindowCursor._destroy | train | def _destroy(self):
"""Destruction code to decrement counters"""
self.unuse_region()
if self._rlist is not None:
# Actual client count, which doesn't include the reference kept by the manager, nor ours
# as we are about to be deleted
try:
if len(self._rlist) == 0:
# Free all resources associated with the mapped file
self._manager._fdict.pop(self._rlist.path_or_fd())
# END remove regions list from manager
except (TypeError, KeyError):
| python | {
"resource": ""
} |
q15332 | WindowCursor._copy_from | train | def _copy_from(self, rhs):
"""Copy all data from rhs into this instance, handles usage count"""
self._manager = rhs._manager
self._rlist = type(rhs._rlist)(rhs._rlist)
self._region = rhs._region
self._ofs = rhs._ofs
self._size = rhs._size
| python | {
"resource": ""
} |
q15333 | WindowCursor.use_region | train | def use_region(self, offset=0, size=0, flags=0):
"""Assure we point to a window which allows access to the given offset into the file
:param offset: absolute offset in bytes into the file
:param size: amount of bytes to map. If 0, all available bytes will be mapped
:param flags: additional flags to be given to os.open in case a file handle is initially opened
for mapping. Has no effect if a region can actually be reused.
:return: this instance - it should be queried for whether it points to a valid memory region.
This is not the case if the mapping failed because we reached the end of the file
**Note:**: The size actually mapped may be smaller than the given size. If that is the case,
either the file has reached its end, or the map was created between two existing regions"""
need_region = True
man = self._manager
fsize = self._rlist.file_size()
size = min(size or fsize, man.window_size() or fsize) # clamp size to window size
if self._region is not None:
if self._region.includes_ofs(offset):
need_region = False
| python | {
"resource": ""
} |
q15334 | StaticWindowMapManager.num_open_files | train | def num_open_files(self):
"""Amount of opened files in the system"""
| python | {
"resource": ""
} |
q15335 | align_to_mmap | train | def align_to_mmap(num, round_up):
"""
Align the given integer number to the closest page offset, which usually is 4096 bytes.
:param round_up: if True, the next higher multiple of page size is used, otherwise
the lower page_size will be used (i.e. if True, 1 becomes 4096, otherwise it becomes 0)
:return: num rounded to closest page"""
| python | {
"resource": ""
} |
q15336 | MapWindow.align | train | def align(self):
"""Assures the previous window area is contained in the new one"""
nofs = align_to_mmap(self.ofs, 0)
self.size += self.ofs - nofs | python | {
"resource": ""
} |
q15337 | MapWindow.extend_left_to | train | def extend_left_to(self, window, max_size):
"""Adjust the offset to start where the given window on our left ends if possible,
but don't make yourself larger than max_size.
The resize will assure that the new window still contains the old window area"""
rofs = self.ofs - window.ofs_end()
| python | {
"resource": ""
} |
q15338 | MapWindow.extend_right_to | train | def extend_right_to(self, window, max_size):
"""Adjust the size to make our window end where the right window begins, but don't
get larger than max_size""" | python | {
"resource": ""
} |
q15339 | SlidingWindowMapBuffer.begin_access | train | def begin_access(self, cursor=None, offset=0, size=sys.maxsize, flags=0):
"""Call this before the first use of this instance. The method was already
called by the constructor in case sufficient information was provided.
For more information no the parameters, see the __init__ method
:param path: if cursor is None the existing one will be used.
:return: True if the buffer can be used"""
if cursor:
self._c = cursor
# END update our cursor
| python | {
"resource": ""
} |
q15340 | make_parser | train | def make_parser():
"""
Returns an argparse instance for this script.
"""
parser = argparse.ArgumentParser(description="generate HTML from crawler JSON")
parser.add_argument(
| python | {
"resource": ""
} |
q15341 | render_template | train | def render_template(env, html_path, template_filename, context):
"""
Render a template file into the given output location.
"""
template = env.get_template(template_filename)
rendered_html = | python | {
"resource": ""
} |
q15342 | render_html | train | def render_html(data_dir, output_dir):
"""
The main workhorse of this script. Finds all the JSON data files
from pa11ycrawler, and transforms them into HTML files via Jinja2 templating.
"""
env = Environment(loader=PackageLoader('pa11ycrawler', 'templates'))
env.globals["wcag_refs"] = wcag_refs
pages = []
counter = collections.Counter()
grouped_violations = collections.defaultdict(dict)
# render detail templates
for data_file in data_dir.files('*.json'):
data = json.load(data_file.open())
num_error, num_warning, num_notice = pa11y_counts(data['pa11y'])
data["num_error"] = num_error
data["num_warning"] = num_warning
data["num_notice"] = num_notice
fname = data_file.namebase + ".html"
html_path = output_dir / fname
render_template(env, html_path, 'detail.html', data)
data["filename"] = fname
pages.append(data)
for violation in data['pa11y']:
violation_id = hashlib.md5(
| python | {
"resource": ""
} |
q15343 | ignore_rules_for_url | train | def ignore_rules_for_url(spider, url):
"""
Returns a list of ignore rules from the given spider,
that are relevant to the given URL.
"""
ignore_rules = getattr(spider, "pa11y_ignore_rules", {}) or {}
return itertools.chain.from_iterable(
| python | {
"resource": ""
} |
q15344 | load_pa11y_results | train | def load_pa11y_results(stdout, spider, url):
"""
Load output from pa11y, filtering out the ignored messages.
The `stdout` parameter is a bytestring, not a unicode string.
"""
if not stdout:
| python | {
"resource": ""
} |
q15345 | write_pa11y_config | train | def write_pa11y_config(item):
"""
The only way that pa11y will see the same page that scrapy sees
is to make sure that pa11y requests the page with the same headers.
However, the only way to configure request headers with pa11y is to
write them into a config file.
This function will create a config file, write the config into it,
and return a reference to that file.
"""
config = {
"page": {
"headers": item["request_headers"],
},
}
| python | {
"resource": ""
} |
q15346 | write_pa11y_results | train | def write_pa11y_results(item, pa11y_results, data_dir):
"""
Write the output from pa11y into a data file.
"""
data = dict(item)
data['pa11y'] = pa11y_results
# it would be nice to use the URL as the filename,
# but that gets complicated (long URLs, special characters, etc)
# so we'll make the filename a hash of the URL instead,
# and throw in the access time so that we can store the same URL
# multiple times in this data directory | python | {
"resource": ""
} |
q15347 | Pa11yPipeline.process_item | train | def process_item(self, item, spider):
"""
Use the Pa11y command line tool to get an a11y report.
"""
config_file = write_pa11y_config(item)
args = [
self.pa11y_path,
item["url"],
'--config={file}'.format(file=config_file.name),
]
for flag, value in self.cli_flags.items():
args.append("--{flag}={value}".format(flag=flag, value=value))
retries_remaining = 3
while retries_remaining:
logline = " ".join(args)
if retries_remaining != 3:
logline += u" # (retry {num})".format(num=3-retries_remaining)
spider.logger.info(logline)
proc = sp.Popen(
args, shell=False,
stdout=sp.PIPE, stderr=sp.PIPE,
)
stdout, stderr = proc.communicate()
if proc.returncode in (0, 2):
| python | {
"resource": ""
} |
q15348 | watched_extension | train | def watched_extension(extension):
"""Return True if the given extension is one of the watched extensions"""
for ext in hamlpy.VALID_EXTENSIONS:
if | python | {
"resource": ""
} |
q15349 | _watch_folder | train | def _watch_folder(folder, destination, compiler_args):
"""Compares "modified" timestamps against the "compiled" dict, calls compiler
if necessary."""
for dirpath, dirnames, filenames in os.walk(folder):
for filename in filenames:
# Ignore filenames starting with ".#" for Emacs compatibility
if watched_extension(filename) and not filename.startswith('.#'):
fullpath = os.path.join(dirpath, filename)
subfolder = os.path.relpath(dirpath, folder)
| python | {
"resource": ""
} |
q15350 | compile_file | train | def compile_file(fullpath, outfile_name, compiler_args):
"""Calls HamlPy compiler."""
if Options.VERBOSE:
print '%s %s -> %s' % (strftime("%H:%M:%S"), fullpath, outfile_name)
try:
if Options.DEBUG:
print "Compiling %s -> %s" % (fullpath, outfile_name)
haml_lines = codecs.open(fullpath, 'r', encoding = 'utf-8').read().splitlines()
compiler = hamlpy.Compiler(compiler_args)
output = | python | {
"resource": ""
} |
q15351 | DuplicatesPipeline.process_item | train | def process_item(self, item, spider): # pylint: disable=unused-argument
"""
Stops processing item if we've already seen this URL before.
"""
url = self.clean_url(item["url"])
if self.is_sequence_start_page(url):
url = url.parent
if | python | {
"resource": ""
} |
q15352 | DropDRFPipeline.process_item | train | def process_item(self, item, spider): # pylint: disable=unused-argument
"Check for DRF urls."
url = URLObject(item["url"])
if url.path.startswith("/api/"):
| python | {
"resource": ""
} |
q15353 | get_csrf_token | train | def get_csrf_token(response):
"""
Extract the CSRF token out of the "Set-Cookie" header of a response.
"""
cookie_headers = [
h.decode('ascii') for h in response.headers.getlist("Set-Cookie")
]
if not cookie_headers:
return None
csrf_headers = [
| python | {
"resource": ""
} |
q15354 | load_pa11y_ignore_rules | train | def load_pa11y_ignore_rules(file=None, url=None): # pylint: disable=redefined-builtin
"""
Load the pa11y ignore rules from the given file or URL.
"""
if not file and not url:
return None
if file:
file = Path(file)
if not file.isfile():
msg = (
u"pa11y_ignore_rules_file specified, but file does not exist! {file}"
).format(file=file)
raise ValueError(msg)
return yaml.safe_load(file.text())
# must be URL
resp = requests.get(url)
if not resp.ok:
| python | {
"resource": ""
} |
q15355 | EdxSpider.handle_error | train | def handle_error(self, failure):
"""
Provides basic error information for bad requests.
If the error was an HttpError or DNSLookupError, it
prints more specific information.
"""
self.logger.error(repr(failure))
if failure.check(HttpError):
response = failure.value.response
self.logger.error(u'HttpError on %s', response.url)
self.logger.error(u'HttpError Code: %s', response.status)
if response.status in (401, 403):
# If the error is from invalid login, tell the user
| python | {
"resource": ""
} |
q15356 | EdxSpider.parse_item | train | def parse_item(self, response):
"""
Get basic information about a page, so that it can be passed to the
`pa11y` tool for further testing.
@url https://www.google.com/
@returns items 1 1
@returns requests 0 0
@scrapes url request_headers accessed_at page_title
"""
# if we got redirected to a login page, then login
if URLObject(response.url).path == LOGIN_HTML_PATH:
reqs = self.handle_unexpected_redirect_to_login_page(response)
for req in reqs:
yield req
title = response.xpath("//title/text()").extract_first()
if title:
title = title.strip()
# `response.request.headers` is a dictionary where the key is the
# header name, and the value is a *list*, containing one item,
# which is the header value. We need to get rid of this list, and just
# have key-value pairs. (This list probably exists in case the same
# header is sent multiple times, but that's not happening in this case,
# and the list construct is getting in the way.)
#
# We also need to convert bytes to ASCII. In practice, headers can | python | {
"resource": ""
} |
q15357 | EdxSpider.handle_unexpected_redirect_to_login_page | train | def handle_unexpected_redirect_to_login_page(self, response):
"""
This method is called if the crawler has been unexpectedly logged out.
If that happens, and the crawler requests a page that requires a
logged-in user, the crawler will be redirected to a login page,
with the originally-requested URL as the `next` query parameter.
This method simply causes the crawler to log back in using the saved
email and password credentials. We rely on the fact that the login
page will redirect the user to the URL in the `next` query parameter
if the login is successful -- this will allow the crawl to resume
where it left off.
This is method is very much like the `get_initial_login()` method,
but the callback is `self.after_login` instead of
`self.after_initial_login`.
"""
next_url = URLObject(response.url).query_dict.get("next")
login_url = (
URLObject("http://")
.with_hostname(self.domain)
.with_port(self.port)
.with_path(LOGIN_API_PATH)
| python | {
"resource": ""
} |
q15358 | Element._escape_attribute_quotes | train | def _escape_attribute_quotes(self, v):
'''
Escapes quotes with a backslash, except those inside a Django tag
'''
escaped = []
inside_tag = False
for i, _ in enumerate(v):
if v[i:i + 2] == '{%':
inside_tag = True
elif v[i:i + 2] == '%}':
inside_tag = | python | {
"resource": ""
} |
q15359 | RootNode.add_child | train | def add_child(self, child):
'''Add child node, and copy all options to it'''
| python | {
"resource": ""
} |
q15360 | ElementNode._render_before | train | def _render_before(self, element):
'''Render opening tag and inline content'''
start = ["%s<%s" % (self.spaces, element.tag)]
if element.id:
start.append(" id=%s" % self.element.attr_wrap(self.replace_inline_variables(element.id)))
if element.classes:
start.append(" class=%s" % self.element.attr_wrap(self.replace_inline_variables(element.classes)))
if element.attributes:
start.append(' ' + self.replace_inline_variables(element.attributes))
content = self._render_inline_content(self.element.inline_content)
if element.nuke_inner_whitespace and content:
content = content.strip()
| python | {
"resource": ""
} |
q15361 | ElementNode._render_after | train | def _render_after(self, element):
'''Render closing tag'''
if element.inline_content:
return "</%s>%s" % (element.tag, self.render_newlines())
| python | {
"resource": ""
} |
q15362 | Simplenote.authenticate | train | def authenticate(self, user, password):
""" Method to get simplenote auth token
Arguments:
- user (string): simplenote email address
- password (string): simplenote password
Returns:
Simplenote API token as string
"""
request = Request(AUTH_URL)
request.add_header('X-Simperium-API-Key', API_KEY)
if sys.version_info < (3, 3):
request.add_data(json.dumps({'username': user, 'password': password}))
else:
request.data = json.dumps({'username': user, 'password': password}).encode()
try:
| python | {
"resource": ""
} |
q15363 | Simplenote.get_token | train | def get_token(self):
""" Method to retrieve an auth token.
The cached global token is looked up and returned if it exists. If it
is `None` a new one is requested and returned.
| python | {
"resource": ""
} |
q15364 | Simplenote.get_note | train | def get_note(self, noteid, version=None):
""" Method to get a specific note
Arguments:
- noteid (string): ID of the note to get
- version (int): optional version of the note to get
Returns:
A tuple `(note, status)`
- note (dict): note object
- status (int): 0 on success and -1 otherwise
"""
# request note
params_version = ""
if version is not None:
params_version = '/v/' + str(version)
params = '/i/%s%s' % (str(noteid), params_version)
| python | {
"resource": ""
} |
q15365 | Simplenote.update_note | train | def update_note(self, note):
""" Method to update a specific note object, if the note object does not
have a "key" field, a new note is created
Arguments
- note (dict): note object to update
Returns:
A tuple `(note, status)`
- note (dict): note object
- status (int): 0 on success and -1 otherwise
"""
# determine whether to create a new note or update an existing one
# Also need to add/remove key field to keep simplenote.py consistency
if "key" in note:
# Then already have a noteid we need to remove before passing to Simperium API
noteid = note.pop("key", None)
else:
# Adding a new note
noteid = uuid.uuid4().hex
# TODO: Set a ccid?
# ccid = uuid.uuid4().hex
if "version" in note:
version = note.pop("version", None)
url = '%s/i/%s/v/%s?response=1' % (DATA_URL, noteid, version)
else:
url = '%s/i/%s?response=1' % (DATA_URL, noteid)
# TODO: Could do with being consistent here. Everywhere else is Request(DATA_URL+params)
note = self.__remove_simplenote_api_fields(note)
request = Request(url, data=json.dumps(note).encode('utf-8'))
| python | {
"resource": ""
} |
q15366 | Simplenote.add_note | train | def add_note(self, note):
""" Wrapper method to add a note
The method can be passed the note as a dict with the `content`
property set, which is then directly send to the web service for
creation. Alternatively, only the body as string can also be passed. In
this case the parameter is used as `content` for the new note.
Arguments:
- note (dict or string): the note to add
Returns:
A tuple `(note, status)`
| python | {
"resource": ""
} |
q15367 | Simplenote.get_note_list | train | def get_note_list(self, data=True, since=None, tags=[]):
""" Method to get the note list
The method can be passed optional arguments to limit the list to
notes containing a certain tag, or only updated since a certain
Simperium cursor. If omitted a list of all notes is returned.
By default data objects are returned. If data is set to false only
keys/ids and versions are returned. An empty data object is inserted
for compatibility.
Arguments:
- tags=[] list of tags as string: return notes that have
at least one of these tags
- since=cursor Simperium cursor as string: return only changes
since this cursor
- data=True If false only return keys/ids and versions
Returns:
A tuple `(notes, status)`
- notes (list): A list of note objects with all properties set except
`content`.
- status (int): 0 on success and -1 otherwise
"""
# initialize data
status = 0
ret = []
response_notes = {}
notes = { "index" : [] }
# get the note index
params = '/index?limit=%s' % (str(NOTE_FETCH_LENGTH))
if since is not None:
params += '&since=%s' % (since)
# Fetching data is the default
if data:
params += '&data=true'
# perform initial HTTP request
request = Request(DATA_URL+params)
request.add_header(self.header, self.get_token())
try:
response = urllib2.urlopen(request)
response_notes = json.loads(response.read().decode('utf-8'))
# re-write for v1 consistency
note_objects = []
for n in response_notes["index"]:
# If data=False then can't do this bit... or not all of it, just have id and version. Add empty data object.
if not data:
n['d'] = {}
note_object = self.__add_simplenote_api_fields(n['d'], n['id'], n['v'])
note_objects.append(note_object)
notes["index"].extend(note_objects)
except HTTPError as e:
if e.code == 401:
raise SimplenoteLoginFailed('Login to Simplenote API failed! Check Token.')
else:
return e, -1
| python | {
"resource": ""
} |
q15368 | Simplenote.trash_note | train | def trash_note(self, note_id):
""" Method to move a note to the trash
Arguments:
- note_id (string): key of the note to trash
Returns:
A tuple `(note, status)`
- note (dict): the newly created note or an error message
- status (int): 0 on success and -1 otherwise
"""
# get note
note, status = self.get_note(note_id)
if (status == -1):
return note, status
# set deleted property, but only if not already trashed
# TODO: A 412 | python | {
"resource": ""
} |
q15369 | Simplenote.delete_note | train | def delete_note(self, note_id):
""" Method to permanently delete a note
Arguments:
- note_id (string): key of the note to trash
Returns:
A tuple `(note, status)`
- note (dict): an empty dict or an error message
- status (int): 0 on success and -1 otherwise
"""
# notes have to be trashed before deletion
note, status = self.trash_note(note_id)
if (status == -1):
return note, status
params = '/i/%s' % (str(note_id))
request = Request(url=DATA_URL+params, method='DELETE')
request.add_header(self.header, self.get_token())
| python | {
"resource": ""
} |
q15370 | BearerAuthentication.authenticate_credentials | train | def authenticate_credentials(self, token):
"""
Validate the bearer token against the OAuth provider.
Arguments:
token (str): Access token to validate
Returns:
(tuple): tuple containing:
user (User): User associated with the access token
access_token (str): Access token
Raises:
AuthenticationFailed: The user is inactive, or retrieval of user info failed.
"""
try:
user_info = self.get_user_info(token)
except UserInfoRetrievalFailed:
msg = 'Failed to retrieve user info. | python | {
"resource": ""
} |
q15371 | BearerAuthentication.get_user_info | train | def get_user_info(self, token):
"""
Retrieves the user info from the OAuth provider.
Arguments:
token (str): OAuth2 access token.
Returns:
dict
Raises:
UserInfoRetrievalFailed: Retrieval of user info from the remote server failed.
"""
url = self.get_user_info_url()
try:
headers = {'Authorization': 'Bearer {}'.format(token)}
response = requests.get(url, headers=headers)
except requests.RequestException:
logger.exception('Failed to retrieve user info due to a request exception.')
raise UserInfoRetrievalFailed
| python | {
"resource": ""
} |
q15372 | BearerAuthentication.process_user_info_response | train | def process_user_info_response(self, response):
"""
Process the user info response data.
By default, this simply maps the edX user info key-values (example below) to Django-friendly names. If your
provider returns different fields, you should sub-class this class and override this method.
.. code-block:: python
{
| python | {
"resource": ""
} |
q15373 | JwtAuthentication.authenticate_credentials | train | def authenticate_credentials(self, payload):
"""Get or create an active user with the username contained in the payload."""
username = payload.get('preferred_username') or payload.get('username')
if username is None:
raise exceptions.AuthenticationFailed('JWT must include a preferred_username or username claim!')
else:
try:
user, __ = get_user_model().objects.get_or_create(username=username)
attributes_updated = False
for claim, attr in self.get_jwt_claim_attribute_map().items():
payload_value = payload.get(claim)
| python | {
"resource": ""
} |
q15374 | EnsureJWTAuthSettingsMiddleware._includes_base_class | train | def _includes_base_class(self, iter_classes, base_class):
"""
Returns whether any class in iter_class is a | python | {
"resource": ""
} |
q15375 | EnsureJWTAuthSettingsMiddleware._add_missing_jwt_permission_classes | train | def _add_missing_jwt_permission_classes(self, view_class):
"""
Adds permissions classes that should exist for Jwt based authentication,
if needed.
"""
view_permissions = list(getattr(view_class, 'permission_classes', []))
# Not all permissions are classes, some will be ConditionalPermission
# objects from the rest_condition library. So we have to crawl all those
# and expand them to see if our target classes are inside the
# conditionals somewhere.
permission_classes = []
classes_to_add = []
| python | {
"resource": ""
} |
q15376 | JwtAuthCookieMiddleware.process_request | train | def process_request(self, request):
"""
Reconstitute the full JWT and add a new cookie on the request object.
"""
use_jwt_cookie_requested = request.META.get(USE_JWT_COOKIE_HEADER)
header_payload_cookie = request.COOKIES.get(jwt_cookie_header_payload_name())
signature_cookie = request.COOKIES.get(jwt_cookie_signature_name())
if not use_jwt_cookie_requested:
metric_value = 'not-requested'
elif header_payload_cookie and signature_cookie:
# Reconstitute JWT auth cookie if split cookies are available and jwt cookie
# authentication was requested by the client.
request.COOKIES[jwt_cookie_name()] = '{}{}{}'.format(
header_payload_cookie,
JWT_DELIMITER,
signature_cookie,
)
metric_value = 'success'
elif header_payload_cookie or signature_cookie:
# Log unexpected case of only finding one cookie.
if not | python | {
"resource": ""
} |
q15377 | _set_token_defaults | train | def _set_token_defaults(token):
"""
Returns an updated token that includes default values for
fields that were introduced since the token was created
by checking its version number.
"""
def _verify_version(jwt_version):
supported_version = Version(
settings.JWT_AUTH.get('JWT_SUPPORTED_VERSION', JwtTokenVersion.default_latest_supported)
)
if jwt_version.major > supported_version.major:
logger.info('Token decode failed due to unsupported JWT version number [%s]', str(jwt_version))
raise jwt.InvalidTokenError('JWT version number [%s] is unsupported', str(jwt_version))
def _get_and_set_version(token):
"""
Tokens didn't always contain a version number so we
default to a nominal starting number.
"""
if 'version' not in token:
token['version'] = str(JwtTokenVersion.starting_version)
return Version(token['version'])
def _set_is_restricted(token):
"""
We can safely default to False since all "restricted" tokens
created prior to the addition of the `is_restricted` flag were
always created as expired tokens. Expired tokens would not
validate and so would not | python | {
"resource": ""
} |
q15378 | _get_signing_jwk_key_set | train | def _get_signing_jwk_key_set(jwt_issuer):
"""
Returns a JWK Keyset containing all active keys that are configured
for verifying signatures.
"""
key_set = KEYS()
# asymmetric keys
signing_jwk_set = settings.JWT_AUTH.get('JWT_PUBLIC_SIGNING_JWK_SET')
| python | {
"resource": ""
} |
q15379 | paginate_search_results | train | def paginate_search_results(object_class, search_results, page_size, page):
"""
Takes edx-search results and returns a Page object populated
with db objects for that page.
:param object_class: Model class to use when querying the db for objects.
:param search_results: edX-search results.
:param page_size: Number of results per page.
:param page: Page number.
:return: Paginator object with model objects
"""
paginator = Paginator(search_results['results'], page_size)
# This code is taken from within the GenericAPIView#paginate_queryset method.
# It is common code, but
try:
page_number = paginator.validate_number(page)
except InvalidPage:
if page == 'last':
page_number = paginator.num_pages
else:
raise Http404("Page is not 'last', nor can it be converted to an int.")
try:
paged_results = paginator.page(page_number)
except InvalidPage as exception:
raise Http404(
"Invalid page {page_number}: {message}".format(
page_number=page_number,
message=str(exception) | python | {
"resource": ""
} |
q15380 | DefaultPagination.get_paginated_response | train | def get_paginated_response(self, data):
"""
Annotate the response with pagination information.
"""
return Response({
'next': self.get_next_link(),
'previous': self.get_previous_link(),
'count': self.page.paginator.count,
'num_pages': self.page.paginator.num_pages,
| python | {
"resource": ""
} |
q15381 | NamespacedPageNumberPagination.get_paginated_response | train | def get_paginated_response(self, data):
"""
Annotate the response with pagination information
"""
metadata = {
'next': self.get_next_link(),
'previous': self.get_previous_link(),
'count': self.get_result_count(),
| python | {
"resource": ""
} |
q15382 | get_decoded_jwt | train | def get_decoded_jwt(request):
"""
Grab jwt from jwt cookie in request if possible.
Returns a decoded jwt dict if it can be found.
Returns None if the jwt is not found.
"""
| python | {
"resource": ""
} |
q15383 | SessionAuthenticationAllowInactiveUser.authenticate | train | def authenticate(self, request):
"""Authenticate the user, requiring a logged-in account and CSRF.
This is exactly the same as the `SessionAuthentication` implementation,
with the `user.is_active` check removed.
Args:
request (HttpRequest)
Returns:
Tuple of `(user, token)`
Raises:
PermissionDenied: The CSRF token check failed.
"""
# Get the underlying HttpRequest object
request = request._request # pylint: disable=protected-access
user = getattr(request, 'user', None)
# Unauthenticated, CSRF validation not required
# This is where regular `SessionAuthentication` checks that | python | {
"resource": ""
} |
q15384 | JwtHasContentOrgFilterForRequestedCourse.has_permission | train | def has_permission(self, request, view):
"""
Ensure that the course_id kwarg provided to the view contains one
of the organizations specified in the content provider filters
in the JWT used to authenticate.
"""
course_key = CourseKey.from_string(view.kwargs.get('course_id'))
jwt_filters = decode_jwt_filters(request.auth)
for filter_type, filter_value in jwt_filters:
| python | {
"resource": ""
} |
q15385 | JwtHasUserFilterForRequestedUser.has_permission | train | def has_permission(self, request, view):
"""
If the JWT has a user filter, verify that the filtered
user value matches the user in the URL.
"""
user_filter = self._get_user_filter(request)
if not user_filter:
# no user filters are present in the | python | {
"resource": ""
} |
q15386 | RequestMetricsMiddleware.process_response | train | def process_response(self, request, response):
"""
Add metrics for various details of the request.
"""
self._set_request_auth_type_metric(request)
| python | {
"resource": ""
} |
q15387 | RequestMetricsMiddleware._set_request_user_id_metric | train | def _set_request_user_id_metric(self, request):
"""
Add request_user_id metric
Metrics:
request_user_id
"""
if | python | {
"resource": ""
} |
q15388 | RequestMetricsMiddleware._set_request_referer_metric | train | def _set_request_referer_metric(self, request):
"""
Add metric 'request_referer' for http referer.
"""
if 'HTTP_REFERER' in | python | {
"resource": ""
} |
q15389 | RequestMetricsMiddleware._set_request_user_agent_metrics | train | def _set_request_user_agent_metrics(self, request):
"""
Add metrics for user agent for python.
Metrics:
request_user_agent
request_client_name: The client name from edx-rest-api-client calls.
"""
if 'HTTP_USER_AGENT' in request.META and request.META['HTTP_USER_AGENT']:
user_agent = request.META['HTTP_USER_AGENT']
monitoring.set_custom_metric('request_user_agent', user_agent)
if user_agent:
# Example agent string from edx-rest-api-client:
# python-requests/2.9.1 edx-rest-api-client/1.7.2 ecommerce
| python | {
"resource": ""
} |
q15390 | RequestMetricsMiddleware._set_request_auth_type_metric | train | def _set_request_auth_type_metric(self, request):
"""
Add metric 'request_auth_type' for the authentication type used.
NOTE: This is a best guess at this point. Possible values include:
no-user
unauthenticated
jwt/bearer/other-token-type
session-or-unknown (catch all)
"""
if 'HTTP_AUTHORIZATION' in request.META and request.META['HTTP_AUTHORIZATION']:
token_parts = request.META['HTTP_AUTHORIZATION'].split()
# Example: "JWT eyJhbGciO..."
if len(token_parts) == 2:
auth_type = token_parts[0].lower() # 'jwt' or 'bearer' (for example) | python | {
"resource": ""
} |
q15391 | jsonrpc_request | train | def jsonrpc_request(method, identifier, params=None):
"""Produce a JSONRPC request."""
return '{}\r\n'.format(json.dumps({
'id': identifier,
| python | {
"resource": ""
} |
q15392 | SnapcastProtocol.handle_data | train | def handle_data(self, data):
"""Handle JSONRPC data."""
if 'id' | python | {
"resource": ""
} |
q15393 | SnapcastProtocol.handle_response | train | def handle_response(self, data):
"""Handle JSONRPC response."""
identifier = data.get('id')
| python | {
"resource": ""
} |
q15394 | SnapcastProtocol.handle_notification | train | def handle_notification(self, data):
"""Handle JSONRPC notification."""
if data.get('method') in self._callbacks:
| python | {
"resource": ""
} |
q15395 | SnapcastProtocol.request | train | def request(self, method, params):
"""Send a JSONRPC request."""
identifier = random.randint(1, 1000)
self._transport.write(jsonrpc_request(method, identifier, params))
self._buffer[identifier] = {'flag': asyncio.Event()}
| python | {
"resource": ""
} |
q15396 | Snapserver.start | train | def start(self):
"""Initiate server connection."""
yield from self._do_connect()
_LOGGER.info('connected to | python | {
"resource": ""
} |
q15397 | Snapserver._do_connect | train | def _do_connect(self):
"""Perform the connection to the server."""
_, self._protocol = | python | {
"resource": ""
} |
q15398 | Snapserver._reconnect_cb | train | def _reconnect_cb(self):
"""Callback to reconnect to the server."""
@asyncio.coroutine
def try_reconnect():
"""Actual coroutine ro try to reconnect or reschedule."""
| python | {
"resource": ""
} |
q15399 | Snapserver._transact | train | def _transact(self, method, params=None):
"""Wrap requests."""
result | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.