_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q7200 | NTEnum.assign | train | def assign(self, V, py):
"""Store python value in Value
"""
if isinstance(py, (bytes, unicode)):
for i,C in enumerate(V['value.choices'] or self._choices):
if py==C:
V['value.index'] = i
return
# attempt to parse as int... | python | {
"resource": ""
} |
q7201 | periodic | train | def periodic(period=60.0, file=sys.stderr):
"""Start a daemon thread which will periodically print GC stats
:param period: Update period in seconds
:param file: A writable file-like object
"""
import threading
import time
S = _StatsThread(period=period, file=file)
T = threading.Thread(t... | python | {
"resource": ""
} |
q7202 | StatsDelta.collect | train | def collect(self, file=sys.stderr):
"""Collect stats and print results to file
:param file: A writable file-like object
"""
cur = gcstats()
Ncur = len(cur)
if self.stats is not None and file is not None:
prev = self.stats
Nprev = self.ntypes # ma... | python | {
"resource": ""
} |
q7203 | MembersClient.filter | train | def filter(self, chamber, congress=CURRENT_CONGRESS, **kwargs):
"""
Takes a chamber and Congress,
OR state and district, returning a list of members
"""
check_chamber(chamber)
kwargs.update(chamber=chamber, congress=congress)
if 'state' in kwargs and 'district' ... | python | {
"resource": ""
} |
q7204 | MembersClient.bills | train | def bills(self, member_id, type='introduced'):
"Same as BillsClient.by_member"
path = "members/{0}/bills/{1}.json".format(member_id, type)
return self.fetch(path) | python | {
"resource": ""
} |
q7205 | MembersClient.compare | train | def compare(self, first, second, chamber, type='votes', congress=CURRENT_CONGRESS):
"""
See how often two members voted together in a given Congress.
Takes two member IDs, a chamber and a Congress number.
"""
check_chamber(chamber)
path = "members/{first}/{type}/{second}/... | python | {
"resource": ""
} |
q7206 | BillsClient.upcoming | train | def upcoming(self, chamber, congress=CURRENT_CONGRESS):
"Shortcut for upcoming bills"
path = "bills/upcoming/{chamber}.json".format(chamber=chamber)
return self.fetch(path) | python | {
"resource": ""
} |
q7207 | VotesClient.by_month | train | def by_month(self, chamber, year=None, month=None):
"""
Return votes for a single month, defaulting to the current month.
"""
check_chamber(chamber)
now = datetime.datetime.now()
year = year or now.year
month = month or now.month
path = "{chamber}/votes/... | python | {
"resource": ""
} |
q7208 | VotesClient.by_range | train | def by_range(self, chamber, start, end):
"""
Return votes cast in a chamber between two dates,
up to one month apart.
"""
check_chamber(chamber)
start, end = parse_date(start), parse_date(end)
if start > end:
start, end = end, start
path = "{... | python | {
"resource": ""
} |
q7209 | VotesClient.by_date | train | def by_date(self, chamber, date):
"Return votes cast in a chamber on a single day"
date = parse_date(date)
return self.by_range(chamber, date, date) | python | {
"resource": ""
} |
q7210 | VotesClient.today | train | def today(self, chamber):
"Return today's votes in a given chamber"
now = datetime.date.today()
return self.by_range(chamber, now, now) | python | {
"resource": ""
} |
q7211 | VotesClient.nominations | train | def nominations(self, congress=CURRENT_CONGRESS):
"Return votes on nominations from a given Congress"
path = "{congress}/nominations.json".format(congress=congress)
return self.fetch(path) | python | {
"resource": ""
} |
q7212 | Client.fetch | train | def fetch(self, path, parse=lambda r: r['results'][0]):
"""
Make an API request, with authentication.
This method can be used directly to fetch new endpoints
or customize parsing.
::
>>> from congress import Congress
>>> client = Congress()
... | python | {
"resource": ""
} |
q7213 | parse_date | train | def parse_date(s):
"""
Parse a date using dateutil.parser.parse if available,
falling back to datetime.datetime.strptime if not
"""
if isinstance(s, (datetime.datetime, datetime.date)):
return s
try:
from dateutil.parser import parse
except ImportError:
parse = lambda... | python | {
"resource": ""
} |
q7214 | GroupBy._prep_spark_sql_groupby | train | def _prep_spark_sql_groupby(self):
"""Used Spark SQL group approach"""
# Strip the index info
non_index_columns = filter(lambda x: x not in self._prdd._index_names,
self._prdd._column_names())
self._grouped_spark_sql = (self._prdd.to_spark_sql()
... | python | {
"resource": ""
} |
q7215 | GroupBy._prep_pandas_groupby | train | def _prep_pandas_groupby(self):
"""Prepare the old school pandas group by based approach."""
myargs = self._myargs
mykwargs = self._mykwargs
def extract_keys(groupedFrame):
for key, group in groupedFrame:
yield (key, group)
def group_and_extract(fram... | python | {
"resource": ""
} |
q7216 | GroupBy._group | train | def _group(self, rdd):
"""Group together the values with the same key."""
return rdd.reduceByKey(lambda x, y: x.append(y)) | python | {
"resource": ""
} |
q7217 | GroupBy.ngroups | train | def ngroups(self):
"""Number of groups."""
if self._can_use_new_school():
return self._grouped_spark_sql.count()
self._prep_pandas_groupby()
return self._mergedRDD.count() | python | {
"resource": ""
} |
q7218 | GroupBy.sum | train | def sum(self):
"""Compute the sum for each group."""
if self._can_use_new_school():
self._prep_spark_sql_groupby()
import pyspark.sql.functions as func
return self._use_aggregation(func.sum)
self._prep_pandas_groupby()
myargs = self._myargs
myk... | python | {
"resource": ""
} |
q7219 | GroupBy._create_exprs_using_func | train | def _create_exprs_using_func(self, f, columns):
"""Create aggregate expressions using the provided function
with the result coming back as the original column name."""
expressions = map(lambda c: f(c).alias(c),
self._columns)
return expressions | python | {
"resource": ""
} |
q7220 | GroupBy._use_aggregation | train | def _use_aggregation(self, agg, columns=None):
"""Compute the result using the aggregation function provided.
The aggregation name must also be provided so we can strip of the extra
name that Spark SQL adds."""
if not columns:
columns = self._columns
from pyspark.sql ... | python | {
"resource": ""
} |
q7221 | GroupBy._regroup_mergedRDD | train | def _regroup_mergedRDD(self):
"""A common pattern is we want to call groupby again on the dataframes
so we can use the groupby functions.
"""
myargs = self._myargs
mykwargs = self._mykwargs
self._prep_pandas_groupby()
def regroup(df):
return df.groupb... | python | {
"resource": ""
} |
q7222 | GroupBy.nth | train | def nth(self, n, *args, **kwargs):
"""Take the nth element of each grouby."""
# TODO: Stop collecting the entire frame for each key.
self._prep_pandas_groupby()
myargs = self._myargs
mykwargs = self._mykwargs
nthRDD = self._regroup_mergedRDD().mapValues(
lambd... | python | {
"resource": ""
} |
q7223 | GroupBy.apply | train | def apply(self, func, *args, **kwargs):
"""Apply the provided function and combine the results together in the
same way as apply from groupby in pandas.
This returns a DataFrame.
"""
self._prep_pandas_groupby()
def key_by_index(data):
"""Key each row by its ... | python | {
"resource": ""
} |
q7224 | _create_function | train | def _create_function(name, doc=""):
""" Create a function for aggregator by name"""
def _(col):
spark_ctx = SparkContext._active_spark_context
java_ctx = (getattr(spark_ctx._jvm.com.sparklingpandas.functions,
name)
(col._java_ctx if isinstance(col,... | python | {
"resource": ""
} |
q7225 | PStatCounter.merge | train | def merge(self, frame):
"""
Add another DataFrame to the PStatCounter.
"""
for column, values in frame.iteritems():
# Temporary hack, fix later
counter = self._counters.get(column)
for value in values:
if counter is not None:
... | python | {
"resource": ""
} |
q7226 | PStatCounter.merge_pstats | train | def merge_pstats(self, other):
"""
Merge all of the stats counters of the other PStatCounter with our
counters.
"""
if not isinstance(other, PStatCounter):
raise Exception("Can only merge PStatcounters!")
for column, counter in self._counters.items():
... | python | {
"resource": ""
} |
q7227 | _update_index_on_df | train | def _update_index_on_df(df, index_names):
"""Helper function to restore index information after collection. Doesn't
use self so we can serialize this."""
if index_names:
df = df.set_index(index_names)
# Remove names from unnamed indexes
index_names = _denormalize_index_names(index_na... | python | {
"resource": ""
} |
q7228 | DataFrame._rdd | train | def _rdd(self):
"""Return an RDD of Panda DataFrame objects. This can be expensive
especially if we don't do a narrow transformation after and get it back
to Spark SQL land quickly."""
columns = self._schema_rdd.columns
index_names = self._index_names
def fromRecords(rec... | python | {
"resource": ""
} |
q7229 | DataFrame._column_names | train | def _column_names(self):
"""Return the column names"""
index_names = set(_normalize_index_names(self._index_names))
column_names = [col_name for col_name in self._schema_rdd.columns if
col_name not in index_names]
return column_names | python | {
"resource": ""
} |
q7230 | DataFrame._evil_apply_with_dataframes | train | def _evil_apply_with_dataframes(self, func, preserves_cols=False):
"""Convert the underlying SchmeaRDD to an RDD of DataFrames.
apply the provide function and convert the result back.
This is hella slow."""
source_rdd = self._rdd()
result_rdd = func(source_rdd)
# By defau... | python | {
"resource": ""
} |
q7231 | DataFrame._first_as_df | train | def _first_as_df(self):
"""Gets the first row as a Panda's DataFrame. Useful for functions like
dtypes & ftypes"""
columns = self._schema_rdd.columns
df = pd.DataFrame.from_records(
[self._schema_rdd.first()],
columns=self._schema_rdd.columns)
df = _update... | python | {
"resource": ""
} |
q7232 | DataFrame.fromDataFrameRDD | train | def fromDataFrameRDD(cls, rdd, sql_ctx):
"""Construct a DataFrame from an RDD of DataFrames.
No checking or validation occurs."""
result = DataFrame(None, sql_ctx)
return result.from_rdd_of_dataframes(rdd) | python | {
"resource": ""
} |
q7233 | DataFrame.applymap | train | def applymap(self, f, **kwargs):
"""Return a new DataFrame by applying a function to each element of each
Panda DataFrame."""
def transform_rdd(rdd):
return rdd.map(lambda data: data.applymap(f), **kwargs)
return self._evil_apply_with_dataframes(transform_rdd,
... | python | {
"resource": ""
} |
q7234 | DataFrame.groupby | train | def groupby(self, by=None, axis=0, level=None, as_index=True, sort=True,
group_keys=True, squeeze=False):
"""Returns a groupby on the schema rdd. This returns a GroupBy object.
Note that grouping by a column name will be faster than most other
options due to implementation."""
... | python | {
"resource": ""
} |
q7235 | DataFrame.collect | train | def collect(self):
"""Collect the elements in an DataFrame
and concatenate the partition."""
local_df = self._schema_rdd.toPandas()
correct_idx_df = _update_index_on_df(local_df, self._index_names)
return correct_idx_df | python | {
"resource": ""
} |
q7236 | PRDD.applymap | train | def applymap(self, func, **kwargs):
"""Return a new PRDD by applying a function to each element of each
pandas DataFrame."""
return self.from_rdd(
self._rdd.map(lambda data: data.applymap(func), **kwargs)) | python | {
"resource": ""
} |
q7237 | PRDD.collect | train | def collect(self):
"""Collect the elements in an PRDD and concatenate the partition."""
# The order of the frame order appends is based on the implementation
# of reduce which calls our function with
# f(valueToBeAdded, accumulator) so we do our reduce implementation.
def append_... | python | {
"resource": ""
} |
q7238 | PRDD._custom_rdd_reduce | train | def _custom_rdd_reduce(self, reduce_func):
"""Provides a custom RDD reduce which preserves ordering if the RDD has
been sorted. This is useful for us because we need this functionality
as many pandas operations support sorting the results. The standard
reduce in PySpark does not have thi... | python | {
"resource": ""
} |
q7239 | PSparkContext.read_csv | train | def read_csv(self, file_path, use_whole_file=False, names=None, skiprows=0,
*args, **kwargs):
"""Read a CSV file in and parse it into Pandas DataFrames. By default,
the first row from the first partition of that data is parsed and used
as the column names for the data from. If n... | python | {
"resource": ""
} |
q7240 | PSparkContext.read_json | train | def read_json(self, file_path,
*args, **kwargs):
"""Read a json file in and parse it into Pandas DataFrames.
If no names is provided we use the first row for the names.
Currently, it is not possible to skip the first n rows of a file.
Headers are provided in the json fi... | python | {
"resource": ""
} |
q7241 | IIIFManipulatorGen.do_first | train | def do_first(self):
"""Load generator, set size.
We take the generator module name from self.srcfile so that
this manipulator will work with different generators in a
similar way to how the ordinary generators work with
different images
"""
# Load generator modul... | python | {
"resource": ""
} |
q7242 | IIIFManipulatorGen.do_region | train | def do_region(self, x, y, w, h):
"""Record region."""
if (x is None):
self.rx = 0
self.ry = 0
self.rw = self.width
self.rh = self.height
else:
self.rx = x
self.ry = y
self.rw = w
self.rh = h | python | {
"resource": ""
} |
q7243 | IIIFManipulatorGen.do_size | train | def do_size(self, w, h):
"""Record size."""
if (w is None):
self.sw = self.rw
self.sh = self.rh
else:
self.sw = w
self.sh = h
# Now we have region and size, generate the image
image = Image.new("RGB", (self.sw, self.sh), self.gen.ba... | python | {
"resource": ""
} |
q7244 | IIIFAuthBasic.login_handler | train | def login_handler(self, config=None, prefix=None, **args):
"""HTTP Basic login handler.
Respond with 401 and WWW-Authenticate header if there are no
credentials or bad credentials. If there are credentials then
simply check for username equal to password for validity.
"""
... | python | {
"resource": ""
} |
q7245 | IIIFAuthClickthrough.login_service_description | train | def login_service_description(self):
"""Clickthrough login service description.
The login service description _MUST_ include the token service
description. Additionally, for a clickthroudh loginThe authentication pattern is indicated via the
profile URI which is built using self.auth_pa... | python | {
"resource": ""
} |
q7246 | IIIFRequest.clear | train | def clear(self):
"""Clear all data that might pertain to an individual IIIF URL.
Does not change/reset the baseurl or API version which might be
useful in a sequence of calls.
"""
# API parameters
self.identifier = None
self.region = None
self.size = None... | python | {
"resource": ""
} |
q7247 | IIIFRequest.api_version | train | def api_version(self, v):
"""Set the api_version and associated configurations."""
self._api_version = v
if (self._api_version >= '2.0'):
self.default_quality = 'default'
self.allowed_qualities = ['default', 'color', 'bitonal', 'gray']
else: # versions 1.0 and 1.... | python | {
"resource": ""
} |
q7248 | IIIFRequest.url | train | def url(self, **params):
"""Build a URL path for image or info request.
An IIIF Image request with parameterized form is assumed unless
the info parameter is specified, in which case an Image Information
request URI is constructred.
"""
self._setattrs(**params)
p... | python | {
"resource": ""
} |
q7249 | IIIFRequest.parse_url | train | def parse_url(self, url):
"""Parse an IIIF API URL path and each component.
Will parse a URL or URL path that accords with either the
parametrized or info request forms. Will raise an
IIIFRequestError on failure. A wrapper for the split_url()
and parse_parameters() methods.
... | python | {
"resource": ""
} |
q7250 | IIIFRequest.split_url | train | def split_url(self, url):
"""Parse an IIIF API URL path into components.
Will parse a URL or URL path that accords with either the
parametrized or info API forms. Will raise an IIIFRequestError on
failure.
If self.identifier is set then url is assumed not to include the
... | python | {
"resource": ""
} |
q7251 | IIIFRequest.strip_format | train | def strip_format(self, str_and_format):
"""Look for optional .fmt at end of URI.
The format must start with letter. Note that we want to catch
the case of a dot and no format (format='') which is different
from no dot (format=None)
Sets self.format as side effect, returns possi... | python | {
"resource": ""
} |
q7252 | IIIFRequest.parse_parameters | train | def parse_parameters(self):
"""Parse the parameters of an Image Information request.
Will throw an IIIFRequestError on failure, set attributes on
success. Care is taken not to change any of the artibutes
which store path components. All parsed values are stored
in new attributes... | python | {
"resource": ""
} |
q7253 | IIIFRequest.parse_region | train | def parse_region(self):
"""Parse the region component of the path.
/full/ -> self.region_full = True (test this first)
/square/ -> self.region_square = True (test this second)
/x,y,w,h/ -> self.region_xywh = (x,y,w,h)
/pct:x,y,w,h/ -> self.region_xywh and self.region_pct = True
... | python | {
"resource": ""
} |
q7254 | IIIFRequest.parse_size | train | def parse_size(self, size=None):
"""Parse the size component of the path.
/full/ -> self.size_full = True
/max/ -> self.size_mac = True (2.1 and up)
/w,/ -> self.size_wh = (w,None)
/,h/ -> self.size_wh = (None,h)
/w,h/ -> self.size_wh = (w,h)
/pct:p/ -> self.siz... | python | {
"resource": ""
} |
q7255 | IIIFRequest._parse_w_comma_h | train | def _parse_w_comma_h(self, whstr, param):
"""Utility to parse "w,h" "w," or ",h" values.
Returns (w,h) where w,h are either None or ineteger. Will
throw a ValueError if there is a problem with one or both.
"""
try:
(wstr, hstr) = whstr.split(',', 2)
w = s... | python | {
"resource": ""
} |
q7256 | IIIFRequest.parse_quality | train | def parse_quality(self):
"""Check quality paramater.
Sets self.quality_val based on simple substitution of
'native' for default. Checks for the three valid values
else throws an IIIFRequestError.
"""
if (self.quality is None):
self.quality_val = self.default_... | python | {
"resource": ""
} |
q7257 | IIIFRequest.parse_format | train | def parse_format(self):
"""Check format parameter.
All formats values listed in the specification are lowercase
alphanumeric value commonly used as file extensions. To leave
opportunity for extension here just do a limited sanity check
on characters and length.
"""
... | python | {
"resource": ""
} |
q7258 | IIIFRequest.is_scaled_full_image | train | def is_scaled_full_image(self):
"""True if this request is for a scaled full image.
To be used to determine whether this request should be used
in the set of `sizes` specificed in the Image Information.
"""
return(self.region_full and
self.size_wh[0] is not None a... | python | {
"resource": ""
} |
q7259 | create_reference_server_flask_app | train | def create_reference_server_flask_app(cfg):
"""Create referece server Flask application with one or more IIIF handlers."""
# Create Flask app
app = Flask(__name__)
Flask.secret_key = "SECRET_HERE"
app.debug = cfg.debug
# Install request handlers
client_prefixes = dict()
for api_version i... | python | {
"resource": ""
} |
q7260 | IIIFInfo.id | train | def id(self):
"""id property based on server_and_prefix and identifier."""
id = ''
if (self.server_and_prefix is not None and
self.server_and_prefix != ''):
id += self.server_and_prefix + '/'
if (self.identifier is not None):
id += self.identifier
... | python | {
"resource": ""
} |
q7261 | IIIFInfo.id | train | def id(self, value):
"""Split into server_and_prefix and identifier."""
i = value.rfind('/')
if (i > 0):
self.server_and_prefix = value[:i]
self.identifier = value[(i + 1):]
elif (i == 0):
self.server_and_prefix = ''
self.identifier = value... | python | {
"resource": ""
} |
q7262 | IIIFInfo.set_version_info | train | def set_version_info(self, api_version=None):
"""Set up normal values for given api_version.
Will use current value of self.api_version if a version number
is not specified in the call. Will raise an IIIFInfoError
"""
if (api_version is None):
api_version = self.api_... | python | {
"resource": ""
} |
q7263 | IIIFInfo.compliance | train | def compliance(self, value):
"""Set the compliance profile URI."""
if (self.api_version < '2.0'):
self.profile = value
else:
try:
self.profile[0] = value
except AttributeError:
# handle case where profile not initialized as arra... | python | {
"resource": ""
} |
q7264 | IIIFInfo.level | train | def level(self):
"""Extract level number from compliance profile URI.
Returns integer level number or raises IIIFInfoError
"""
m = re.match(
self.compliance_prefix +
r'(\d)' +
self.compliance_suffix +
r'$',
self.compliance)
... | python | {
"resource": ""
} |
q7265 | IIIFInfo.level | train | def level(self, value):
"""Build profile URI from level.
Level should be an integer 0,1,2
"""
self.compliance = self.compliance_prefix + \
("%d" % value) + self.compliance_suffix | python | {
"resource": ""
} |
q7266 | IIIFInfo.add_service | train | def add_service(self, service):
"""Add a service description.
Handles transition from self.service=None, self.service=dict for a
single service, and then self.service=[dict,dict,...] for multiple
"""
if (self.service is None):
self.service = service
elif (isi... | python | {
"resource": ""
} |
q7267 | IIIFInfo.validate | train | def validate(self):
"""Validate this object as Image API data.
Raise IIIFInfoError with helpful message if not valid.
"""
errors = []
for param in self.required_params:
if (not hasattr(self, param) or getattr(self, param) is None):
errors.append("miss... | python | {
"resource": ""
} |
q7268 | IIIFInfo.as_json | train | def as_json(self, validate=True):
"""Return JSON serialization.
Will raise IIIFInfoError if insufficient parameters are present to
have a valid info.json response (unless validate is False).
"""
if (validate):
self.validate()
json_dict = {}
if (self.a... | python | {
"resource": ""
} |
q7269 | IIIFInfo.read | train | def read(self, fh, api_version=None):
"""Read info.json from file like object.
Parameters:
fh -- file like object supporting fh.read()
api_version -- IIIF Image API version expected
If api_version is set then the parsing will assume this API version,
else the version wi... | python | {
"resource": ""
} |
q7270 | IIIFManipulatorPIL.set_max_image_pixels | train | def set_max_image_pixels(self, pixels):
"""Set PIL limit on pixel size of images to load if non-zero.
WARNING: This is a global setting in PIL, it is
not local to this manipulator instance!
Setting a value here will not only set the given limit but
also convert the PIL "Decompr... | python | {
"resource": ""
} |
q7271 | IIIFManipulatorPIL.do_first | train | def do_first(self):
"""Create PIL object from input image file.
Image location must be in self.srcfile. Will result in
self.width and self.height being set to the image dimensions.
Will raise an IIIFError on failure to load the image
"""
self.logger.debug("do_first: src... | python | {
"resource": ""
} |
q7272 | html_page | train | def html_page(title="Page Title", body=""):
"""Create HTML page as string."""
html = "<html>\n<head><title>%s</title></head>\n<body>\n" % (title)
html += "<h1>%s</h1>\n" % (title)
html += body
html += "</body>\n</html>\n"
return html | python | {
"resource": ""
} |
q7273 | top_level_index_page | train | def top_level_index_page(config):
"""HTML top-level index page which provides a link to each handler."""
title = "IIIF Test Server on %s" % (config.host)
body = "<ul>\n"
for prefix in sorted(config.prefixes.keys()):
body += '<li><a href="/%s">%s</a></li>\n' % (prefix, prefix)
body += "</ul>\... | python | {
"resource": ""
} |
q7274 | identifiers | train | def identifiers(config):
"""Show list of identifiers for this prefix.
Handles both the case of local file based identifiers and
also image generators.
Arguments:
config - configuration object in which:
config.klass_name - 'gen' if a generator function
config.generator_d... | python | {
"resource": ""
} |
q7275 | prefix_index_page | train | def prefix_index_page(config):
"""HTML index page for a specific prefix.
The prefix seen by the client is obtained from config.client_prefix
as opposed to the local server prefix in config.prefix. Also uses
the identifiers(config) function to get identifiers available.
Arguments:
config - ... | python | {
"resource": ""
} |
q7276 | osd_page_handler | train | def osd_page_handler(config=None, identifier=None, prefix=None, **args):
"""Flask handler to produce HTML response for OpenSeadragon view of identifier.
Arguments:
config - Config object for this IIIF handler
identifier - identifier of image/generator
prefix - path prefix
**args... | python | {
"resource": ""
} |
q7277 | iiif_info_handler | train | def iiif_info_handler(prefix=None, identifier=None,
config=None, klass=None, auth=None, **args):
"""Handler for IIIF Image Information requests."""
if (not auth or degraded_request(identifier) or auth.info_authz()):
# go ahead with request as made
if (auth):
log... | python | {
"resource": ""
} |
q7278 | iiif_image_handler | train | def iiif_image_handler(prefix=None, identifier=None,
path=None, config=None, klass=None, auth=None, **args):
"""Handler for IIIF Image Requests.
Behaviour for case of a non-authn or non-authz case is to
return 403.
"""
if (not auth or degraded_request(identifier) or auth.imag... | python | {
"resource": ""
} |
q7279 | parse_accept_header | train | def parse_accept_header(accept):
"""Parse an HTTP Accept header.
Parses *accept*, returning a list with pairs of
(media_type, q_value), ordered by q values.
Adapted from <https://djangosnippets.org/snippets/1042/>
"""
result = []
for media_range in accept.split(","):
parts = media_... | python | {
"resource": ""
} |
q7280 | parse_authorization_header | train | def parse_authorization_header(value):
"""Parse the Authenticate header.
Returns nothing on failure, opts hash on success with type='basic' or 'digest'
and other params.
<http://nullege.com/codes/search/werkzeug.http.parse_authorization_header>
<http://stackoverflow.com/questions/1349367/parse-an-... | python | {
"resource": ""
} |
q7281 | do_conneg | train | def do_conneg(accept, supported):
"""Parse accept header and look for preferred type in supported list.
Arguments:
accept - HTTP Accept header
supported - list of MIME type supported by the server
Returns:
supported MIME type with highest q value in request, else None.
FIXME -... | python | {
"resource": ""
} |
q7282 | setup_auth_paths | train | def setup_auth_paths(app, auth, prefix, params):
"""Add URL rules for auth paths."""
base = urljoin('/', prefix + '/') # Must end in slash
app.add_url_rule(base + 'login', prefix + 'login_handler',
auth.login_handler, defaults=params)
app.add_url_rule(base + 'logout', prefix + 'log... | python | {
"resource": ""
} |
q7283 | make_prefix | train | def make_prefix(api_version, manipulator, auth_type):
"""Make prefix string based on configuration parameters."""
prefix = "%s_%s" % (api_version, manipulator)
if (auth_type and auth_type != 'none'):
prefix += '_' + auth_type
return prefix | python | {
"resource": ""
} |
q7284 | split_comma_argument | train | def split_comma_argument(comma_sep_str):
"""Split a comma separated option into a list."""
terms = []
for term in comma_sep_str.split(','):
if term:
terms.append(term)
return terms | python | {
"resource": ""
} |
q7285 | write_pid_file | train | def write_pid_file():
"""Write a file with the PID of this server instance.
Call when setting up a command line testserver.
"""
pidfile = os.path.basename(sys.argv[0])[:-3] + '.pid' # strip .py, add .pid
with open(pidfile, 'w') as fh:
fh.write("%d\n" % os.getpid())
fh.close() | python | {
"resource": ""
} |
q7286 | setup_app | train | def setup_app(app, cfg):
"""Setup Flask app and handle reverse proxy setup if configured.
Arguments:
app - Flask application
cfg - configuration data
"""
# Set up app_host and app_port in case that we are running
# under reverse proxy setup, otherwise they default to
# config.ho... | python | {
"resource": ""
} |
q7287 | IIIFHandler.server_and_prefix | train | def server_and_prefix(self):
"""Server and prefix from config."""
return(host_port_prefix(self.config.host, self.config.port, self.prefix)) | python | {
"resource": ""
} |
q7288 | IIIFHandler.json_mime_type | train | def json_mime_type(self):
"""Return the MIME type for a JSON response.
For version 2.0+ the server must return json-ld MIME type if that
format is requested. Implement for 1.1 also.
http://iiif.io/api/image/2.1/#information-request
"""
mime_type = "application/json"
... | python | {
"resource": ""
} |
q7289 | IIIFHandler.file | train | def file(self):
"""Filename property for the source image for the current identifier."""
file = None
if (self.config.klass_name == 'gen'):
for ext in ['.py']:
file = os.path.join(
self.config.generator_dir, self.identifier + ext)
if... | python | {
"resource": ""
} |
q7290 | IIIFHandler.add_compliance_header | train | def add_compliance_header(self):
"""Add IIIF Compliance level header to response."""
if (self.manipulator.compliance_uri is not None):
self.headers['Link'] = '<' + \
self.manipulator.compliance_uri + '>;rel="profile"' | python | {
"resource": ""
} |
q7291 | IIIFHandler.make_response | train | def make_response(self, content, code=200, headers=None):
"""Wrapper around Flask.make_response which also adds any local headers."""
if headers:
for header in headers:
self.headers[header] = headers[header]
return make_response(content, code, self.headers) | python | {
"resource": ""
} |
q7292 | IIIFHandler.image_information_response | train | def image_information_response(self):
"""Parse image information request and create response."""
dr = degraded_request(self.identifier)
if (dr):
self.logger.info("image_information: degraded %s -> %s" %
(self.identifier, dr))
self.degraded = s... | python | {
"resource": ""
} |
q7293 | IIIFHandler.image_request_response | train | def image_request_response(self, path):
"""Parse image request and create response."""
# Parse the request in path
if (len(path) > 1024):
raise IIIFError(code=414,
text="URI Too Long: Max 1024 chars, got %d\n" % len(path))
try:
self.iii... | python | {
"resource": ""
} |
q7294 | IIIFHandler.error_response | train | def error_response(self, e):
"""Make response for an IIIFError e.
Also add compliance header.
"""
self.add_compliance_header()
return self.make_response(*e.image_server_response(self.api_version)) | python | {
"resource": ""
} |
q7295 | IIIFRequestHandler.error_response | train | def error_response(self, code, content=''):
"""Construct and send error response."""
self.send_response(code)
self.send_header('Content-Type', 'text/xml')
self.add_compliance_header()
self.end_headers()
self.wfile.write(content) | python | {
"resource": ""
} |
q7296 | IIIFRequestHandler.do_GET | train | def do_GET(self):
"""Implement the HTTP GET method.
The bulk of this code is wrapped in a big try block and anywhere
within the code may raise an IIIFError which then results in an
IIIF error response (section 5 of spec).
"""
self.compliance_uri = None
self.iiif ... | python | {
"resource": ""
} |
q7297 | IIIFRequestHandler.do_GET_body | train | def do_GET_body(self):
"""Create body of GET."""
iiif = self.iiif
if (len(self.path) > 1024):
raise IIIFError(code=414,
text="URI Too Long: Max 1024 chars, got %d\n" % len(self.path))
try:
# self.path has leading / then identifier/param... | python | {
"resource": ""
} |
q7298 | IIIFAuth.set_cookie_prefix | train | def set_cookie_prefix(self, cookie_prefix=None):
"""Set a random cookie prefix unless one is specified.
In order to run multiple demonstration auth services on the
same server we need to have different cookie names for each
auth domain. Unless cookie_prefix is set, generate a random
... | python | {
"resource": ""
} |
q7299 | IIIFAuth.add_services | train | def add_services(self, info):
"""Add auth service descriptions to an IIIFInfo object.
Login service description is the wrapper for all other
auth service descriptions so we have nothing unless
self.login_uri is specified. If we do then add any other
auth services at children.
... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.