INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Actually do the request for activity filename This call is slow and therefore this method is memory cached. | def _request_activity_data(self, athlete, filename):
"""Actually do the request for activity filename
This call is slow and therefore this method is memory cached.
Keyword arguments:
athlete -- Full name of athlete
filename -- filename of request activity (e.g. \'2015_04_29_09_0... |
Construct athlete endpoint from host and athlete name | def _athlete_endpoint(self, athlete):
"""Construct athlete endpoint from host and athlete name
Keyword arguments:
athlete -- Full athlete name
"""
return '{host}{athlete}'.format(
host=self.host,
athlete=quote_plus(athlete)
) |
Construct activity endpoint from host athlete name and filename | def _activity_endpoint(self, athlete, filename):
"""Construct activity endpoint from host, athlete name and filename
Keyword arguments:
athlete -- Full athlete name
filename -- filename of request activity (e.g. \'2015_04_29_09_03_16.json\')
"""
return '{host}{athlete}/a... |
Do actual GET request to GC REST API Also validates responses. | def _get_request(self, endpoint):
"""Do actual GET request to GC REST API
Also validates responses.
Keyword arguments:
endpoint -- full endpoint for GET request
"""
try:
response = requests.get(endpoint)
except requests.exceptions.RequestException:
... |
Return package version as listed in __version__ in init. py. | def get_version():
"""
Return package version as listed in `__version__` in `init.py`.
"""
with open(os.path.join(os.path.dirname(__file__), 'argparsetree', '__init__.py')) as init_py:
return re.search('__version__ = [\'"]([^\'"]+)[\'"]', init_py.read()).group(1) |
Creates a Heroku app - setup build. | def create(self, tarball_url, env=None, app_name=None):
"""Creates a Heroku app-setup build.
:param tarball_url: URL of a tarball containing an ``app.json``.
:param env: (optional) Dict containing environment variable overrides.
:param app_name: (optional) Name of the Heroku app to crea... |
if view is string based must be a full path | def url_with_auth(regex, view, kwargs=None, name=None, prefix=''):
"""
if view is string based, must be a full path
"""
from djapiauth.auth import api_auth
if isinstance(view, six.string_types): # view is a string, must be full path
return url(regex, api_auth(import_by_path(prefix + "." + v... |
urlpattern: urlpattern object | def traverse_urls(urlpattern, prefixre=[], prefixname=[], patternFunc=None, resolverFunc=None):
"""
urlpattern: urlpattern object
prefix?? : for multiple level urls defined in different urls.py files
prefixre: compiled regex object
prefixnames: regex text
patternFunc: function to process Regex... |
returns a random title | def title(languages=None, genders=None):
"""
returns a random title
.. code-block:: python
>>> d.title()
u'Mrs.'
>>> d.title(['es'])
u'El Sr.'
>>> d.title(None, [GENDER_FEMALE])
u'Mrs.'
:param languages: list of allowed languages. ['en'] if None
:pa... |
returns a random tuple representing person information | def person(languages=None, genders=None):
"""
returns a random tuple representing person information
.. code-block:: python
>>> d.person()
(u'Derren', u'Powell', 'm')
>>> d.person(genders=['f'])
(u'Marge', u'Rodriguez', u'Mrs.', 'f')
>>> d.person(['es'],['m'])
... |
return a random first name: return: | def first_name(languages=None, genders=None):
"""
return a random first name
:return:
>>> from mock import patch
>>> with patch('%s._get_firstnamess' % __name__, lambda *args: ['aaa']):
... first_name()
'Aaa'
"""
choices = []
languages = languages or ['en']
genders =... |
return a random last name | def last_name(languages=None):
"""
return a random last name
>>> from mock import patch
>>> with patch('%s._get_lastnames' % __name__, lambda *args: ['aaa']):
... last_name()
'Aaa'
>>> with patch('%s.get_lastnames' % __name__, lambda lang: ['%s_lastname'% lang]):
... last_na... |
Returns the hex color for any valid css color name >>> lookup_color ( aliceblue ) F0F8FF | def lookup_color(color):
"""
Returns the hex color for any valid css color name
>>> lookup_color('aliceblue')
'F0F8FF'
"""
if color is None: return
color = color.lower()
if color in COLOR_MAP:
return COLOR_MAP[color]
return color |
Color a list of arguments on particular indexes >>> c = color_args ( [ None blue ] 1 ) >>> c. next () None >>> c. next () 0000FF | def color_args(args, *indexes):
"""
Color a list of arguments on particular indexes
>>> c = color_args([None,'blue'], 1)
>>> c.next()
None
>>> c.next()
'0000FF'
"""
for i,arg in enumerate(args):
if i in indexes:
yield lookup_color(arg)
else:
... |
Add tick marks in order of axes by width APIPARAM: chxtc <axis index > <length of tick mark > | def tick(self, index, length):
"""
Add tick marks in order of axes by width
APIPARAM: chxtc <axis index>,<length of tick mark>
"""
assert int(length) <= 25, 'Width cannot be more than 25'
self.data['ticks'].append('%s,%d'%(index,length))
return self.parent |
Define the type of axes you wish to use atype must be one of x t y r APIPARAM: chxt | def type(self, atype):
"""
Define the type of axes you wish to use
atype must be one of x,t,y,r
APIPARAM: chxt
"""
for char in atype:
assert char in 'xtyr', 'Invalid axes type: %s'%char
if not ',' in atype:
atype = ','.join(atype)
s... |
Label each axes one at a time args are of the form <label 1 >... <label n > APIPARAM: chxl | def label(self, index, *args):
"""
Label each axes one at a time
args are of the form <label 1>,...,<label n>
APIPARAM: chxl
"""
self.data['labels'].append(
str('%s:|%s'%(index, '|'.join(map(str,args)) )).replace('None','')
)
return self.parent |
Set the range of each axis one at a time args are of the form <start of range > <end of range > <interval > APIPARAM: chxr | def range(self, index, *args):
"""
Set the range of each axis, one at a time
args are of the form <start of range>,<end of range>,<interval>
APIPARAM: chxr
"""
self.data['ranges'].append('%s,%s'%(index,
','.join(map(smart_str, args))))
... |
Add style to your axis one at a time args are of the form:: <axis color > <font size > <alignment > <drawing control > <tick mark color > APIPARAM: chxs | def style(self, index, *args):
"""
Add style to your axis, one at a time
args are of the form::
<axis color>,
<font size>,
<alignment>,
<drawing control>,
<tick mark color>
APIPARAM: chxs
"""
args = color_args(ar... |
Render the axes data into the dict data | def render(self):
"""Render the axes data into the dict data"""
for opt,values in self.data.items():
if opt == 'ticks':
self['chxtc'] = '|'.join(values)
else:
self['chx%s'%opt[0]] = '|'.join(values)
return self |
Reverse a chart URL or dict into a GChart instance >>> G = GChart. fromurl ( http:// chart. apis. google. com/ chart?... ) >>> G <GChartWrapper. GChart instance at... > >>> G. image (). save ( chart. jpg JPEG ) | def fromurl(cls, qs):
"""
Reverse a chart URL or dict into a GChart instance
>>> G = GChart.fromurl('http://chart.apis.google.com/chart?...')
>>> G
<GChartWrapper.GChart instance at...>
>>> G.image().save('chart.jpg','JPEG')
"""
if isinstance(qs, ... |
Creates a map of the defined geography with the given country/ state codes Geography choices are africa asia europe middle_east south_america and world ISO country codes can be found at http:// code. google. com/ apis/ chart/ isocodes. html US state codes can be found at http:// code. google. com/ apis/ chart/ statecod... | def map(self, geo, country_codes):
"""
Creates a map of the defined geography with the given country/state codes
Geography choices are africa, asia, europe, middle_east, south_america, and world
ISO country codes can be found at http://code.google.com/apis/chart/isocodes.html
US ... |
Scales the data down to the given size args must be of the form:: <data set 1 minimum value > <data set 1 maximum value > <data set n minimum value > <data set n maximum value > will only work with text encoding! APIPARAM: chds | def scale(self, *args):
"""
Scales the data down to the given size
args must be of the form::
<data set 1 minimum value>,
<data set 1 maximum value>,
<data set n minimum value>,
<data set n maximum value>
will only work with text encoding!
... |
Update the chart s dataset can be two dimensional or contain string data | def dataset(self, data, series=''):
"""
Update the chart's dataset, can be two dimensional or contain string data
"""
self._dataset = data
self._series = series
return self |
Defines markers one at a time for your graph args are of the form:: <marker type > <color > <data set index > <data point > <size > <priority > see the official developers doc for the complete spec APIPARAM: chm | def marker(self, *args):
"""
Defines markers one at a time for your graph
args are of the form::
<marker type>,
<color>,
<data set index>,
<data point>,
<size>,
<priority>
see the official developers doc for the comp... |
Set margins for chart area args are of the form:: <left margin > <right margin > <top margin > <bottom margin > | <legend width > <legend height > APIPARAM: chma | def margin(self, left, right, top, bottom, lwidth=0, lheight=0):
"""
Set margins for chart area
args are of the form::
<left margin>,
<right margin>,
<top margin>,
<bottom margin>|
<legend width>,
<legend height>
... |
Called one at a time for each dataset args are of the form:: <data set n line thickness > <length of line segment > <length of blank segment > APIPARAM: chls | def line(self, *args):
"""
Called one at a time for each dataset
args are of the form::
<data set n line thickness>,
<length of line segment>,
<length of blank segment>
APIPARAM: chls
"""
self.lines.append(','.join(['%.1f'%x for x in ma... |
Apply a solid fill to your chart args are of the form <fill type > <fill style >... fill type must be one of c bg a fill style must be one of s lg ls the rest of the args refer to the particular style APIPARAM: chf | def fill(self, *args):
"""
Apply a solid fill to your chart
args are of the form <fill type>,<fill style>,...
fill type must be one of c,bg,a
fill style must be one of s,lg,ls
the rest of the args refer to the particular style
APIPARAM: chf
"""
a,b... |
Apply a grid to your chart args are of the form:: <x axis step size > <y axis step size > <length of line segment > <length of blank segment > <x offset > <y offset > APIPARAM: chg | def grid(self, *args):
"""
Apply a grid to your chart
args are of the form::
<x axis step size>,
<y axis step size>,
<length of line segment>,
<length of blank segment>
<x offset>,
<y offset>
APIPARAM: chg
""... |
Add a color for each dataset args are of the form <color 1 >... <color n > APIPARAM: chco | def color(self, *args):
"""
Add a color for each dataset
args are of the form <color 1>,...<color n>
APIPARAM: chco
"""
args = color_args(args, *range(len(args)))
self['chco'] = ','.join(args)
return self |
Add a simple label to your chart call each time for each dataset APIPARAM: chl | def label(self, *args):
"""
Add a simple label to your chart
call each time for each dataset
APIPARAM: chl
"""
if self['cht'] == 'qr':
self['chl'] = ''.join(map(str,args))
else:
self['chl'] = '|'.join(map(str,args))
return self |
Define a position for your legend to occupy APIPARAM: chdlp | def legend_pos(self, pos):
"""
Define a position for your legend to occupy
APIPARAM: chdlp
"""
assert pos in LEGEND_POSITIONS, 'Unknown legend position: %s'%pos
self['chdlp'] = str(pos)
return self |
Add a title to your chart args are optional style params of the form <color > <font size > APIPARAMS: chtt chts | def title(self, title, *args):
"""
Add a title to your chart
args are optional style params of the form <color>,<font size>
APIPARAMS: chtt,chts
"""
self['chtt'] = title
if args:
args = color_args(args, 0)
self['chts'] = ','.join(map(str,ar... |
Set the size of the chart args are width height and can be tuple APIPARAM: chs | def size(self,*args):
"""
Set the size of the chart, args are width,height and can be tuple
APIPARAM: chs
"""
if len(args) == 2:
x,y = map(int,args)
else:
x,y = map(int,args[0])
self.check_size(x,y)
self['chs'] = '%dx%d'%(x,y)
... |
Renders the chart context and axes into the dict data | def render(self):
"""
Renders the chart context and axes into the dict data
"""
self.update(self.axes.render())
encoder = Encoder(self._encoding, None, self._series)
if not 'chs' in self:
self['chs'] = '300x150'
else:
size = self['chs'].spl... |
Check to see if the type is either in TYPES or fits type name | def check_type(self, type):
"""Check to see if the type is either in TYPES or fits type name
Returns proper type
"""
if type in TYPES:
return type
tdict = dict(zip(TYPES,TYPES))
tdict.update({
'line': 'lc',
'bar': 'bvs',
'p... |
Returns the rendered URL of the chart | def url(self):
"""
Returns the rendered URL of the chart
"""
self.render()
return self._apiurl + '&'.join(self._parts()).replace(' ','+') |
Shows the chart URL in a webbrowser | def show(self, *args, **kwargs):
"""
Shows the chart URL in a webbrowser
Other arguments passed to webbrowser.open
"""
from webbrowser import open as webopen
return webopen(str(self), *args, **kwargs) |
Download the chart from the URL into a filename as a PNG | def save(self, fname=None):
"""
Download the chart from the URL into a filename as a PNG
The filename defaults to the chart title (chtt) if any
"""
if not fname:
fname = self.getname()
assert fname != None, 'You must specify a filename to save to'
if ... |
Returns an XHTML <img/ > tag of the chart | def img(self, **kwargs):
"""
Returns an XHTML <img/> tag of the chart
kwargs can be other img tag attributes, which are strictly enforced
uses strict escaping on the url, necessary for proper XHTML
"""
safe = 'src="%s" ' % self.url.replace('&','&').replace('<... |
Grabs readable PNG file pointer | def urlopen(self):
"""
Grabs readable PNG file pointer
"""
req = Request(str(self))
try:
return urlopen(req)
except HTTPError:
_print('The server couldn\'t fulfill the request.')
except URLError:
_print('We failed to reach a ser... |
Returns a PngImageFile instance of the chart | def image(self):
"""
Returns a PngImageFile instance of the chart
You must have PIL installed for this to work
"""
try:
try:
import Image
except ImportError:
from PIL import Image
except ImportError:
rai... |
Writes out PNG image data in chunks to file pointer fp | def write(self, fp):
"""
Writes out PNG image data in chunks to file pointer fp
fp must support w or wb
"""
urlfp = self.urlopen().fp
while 1:
try:
fp.write(urlfp.next())
except StopIteration:
return |
Returns the unique SHA1 hexdigest of the chart URL param parts | def checksum(self):
"""
Returns the unique SHA1 hexdigest of the chart URL param parts
good for unittesting...
"""
self.render()
return new_sha(''.join(sorted(self._parts()))).hexdigest() |
>> get_codes () ISO ISO3 ISO - Numeric fips Country Capital Area ( in sq km ) Population Continent tld CurrencyCode CurrencyName Phone Postal Code Format Postal Code Regex Languages geonameid neighbours EquivalentFipsCode | def get_codes():
"""
>> get_codes()
ISO ISO3 ISO-Numeric fips Country Capital Area(in sq km) Population Continent tld CurrencyCode CurrencyName Phone Postal Code Format Postal Code Regex Languages geonameid neighbours EquivalentFipsCode
"""
cache_filename = os.path.join(os.path.dirname(__file__), 'd... |
return a random floating number | def amount(min=1, max=sys.maxsize, decimal_places=2):
"""
return a random floating number
:param min: minimum value
:param max: maximum value
:param decimal_places: decimal places
:return:
"""
q = '.%s1' % '0' * (decimal_places - 1)
return decimal.Decimal(uniform(min, max)).quan... |
Assign an entity name based on the class immediately inhering from Base. | def entity_name_decorator(top_cls):
"""
Assign an entity name based on the class immediately inhering from Base.
This is needed because we don't want
entity names to come from any class that simply inherits our classes,
just the ones in our module.
For example, if you create a class Project2 t... |
Apply the less or equal algorithm on the ordered list of metadata statements: param orig: Start values: return: | def eval(self, orig):
"""
Apply the less or equal algorithm on the ordered list of metadata
statements
:param orig: Start values
:return:
"""
_le = {}
_err = []
for k, v in self.sup_items():
if k in DoNotCompare:
... |
This is both verified and self asserted information. As expected verified information beats self - asserted so if there is both self - asserted and verified values for a claim then only the verified will be returned. | def unprotected_and_protected_claims(self):
"""
This is both verified and self asserted information. As expected
verified information beats self-asserted so if there is both
self-asserted and verified values for a claim then only the verified
will be returned.
"""
... |
Build a JWKS from the signing keys belonging to the self signer | def signing_keys_as_jwks(self):
"""
Build a JWKS from the signing keys belonging to the self signer
:return: Dictionary
"""
_l = [x.serialize() for x in self.self_signer.keyjar.get_signing_key()]
if not _l:
_l = [x.serialize() for x in
self.... |
: param ms_dict: Metadata statement as a dictionary: param keyjar: A keyjar with the necessary FO keys: param cls: What class to map the metadata into: param jwt_ms: Metadata statement as a JWS: param liss: List of FO issuer IDs: return: ParseInfo instance | def _unpack(self, ms_dict, keyjar, cls, jwt_ms=None, liss=None):
"""
:param ms_dict: Metadata statement as a dictionary
:param keyjar: A keyjar with the necessary FO keys
:param cls: What class to map the metadata into
:param jwt_ms: Metadata statement as a JWS
... |
Starting with a signed JWT or a JSON document unpack and verify all the separate metadata statements. | def unpack_metadata_statement(self, ms_dict=None, jwt_ms='', keyjar=None,
cls=ClientMetadataStatement, liss=None):
"""
Starting with a signed JWT or a JSON document unpack and verify all
the separate metadata statements.
:param ms_dict: Metadata stateme... |
Given a MetadataStatement instance create a signed JWT. | def pack_metadata_statement(self, metadata, receiver='', iss='', lifetime=0,
sign_alg=''):
"""
Given a MetadataStatement instance create a signed JWT.
:param metadata: Original metadata statement as a MetadataStatement
instance
:param receiver... |
Computes the resulting metadata statement from a compounded metadata statement. If something goes wrong during the evaluation an exception is raised | def evaluate_metadata_statement(self, metadata, keyjar=None):
"""
Computes the resulting metadata statement from a compounded metadata
statement.
If something goes wrong during the evaluation an exception is raised
:param metadata: The compounded metadata statement as a dictiona... |
Remove MS paths that are marked to be used for another usage | def correct_usage(self, metadata, federation_usage):
"""
Remove MS paths that are marked to be used for another usage
:param metadata: Metadata statement as dictionary
:param federation_usage: In which context this is expected to used.
:return: Filtered Metadata statement.
... |
Add signed metadata statements to a request | def extend_with_ms(self, req, sms_dict):
"""
Add signed metadata statements to a request
:param req: The request
:param sms_dict: A dictionary with FO IDs as keys and signed metadata
statements (sms) or uris pointing to sms as values.
:return: The updated request
... |
Parses command line args using argparse library | def parse_args():
"""
Parses command line args using argparse library
"""
usage = "Usage: create_concordance <infile> [<outfile>]"
description = "Simple Concordance Generator"
argparser = argparse.ArgumentParser(
usage=usage, description=description)
argparser.add_argument(
... |
Add logging option to an ArgumentParser. | def addCommandLineArgs(arg_parser):
"""Add logging option to an ArgumentParser."""
arg_parser.register("action", "log_levels", LogLevelAction)
arg_parser.register("action", "log_files", LogFileAction)
arg_parser.register("action", "log_help", LogHelpAction)
group = arg_parser.add_argument_group("Lo... |
Apply logging options produced by LogLevelAction and LogFileAction. | def applyLoggingOpts(log_levels, log_files):
"""Apply logging options produced by LogLevelAction and LogFileAction.
More often then not this function is not needed, the actions have already
been taken during the parse, but it can be used in the case they need to be
applied again (e.g. when command line... |
Log msg at verbose level debug < verbose < info | def verbose(self, msg, *args, **kwargs):
"""Log msg at 'verbose' level, debug < verbose < info"""
self.log(logging.VERBOSE, msg, *args, **kwargs) |
生成用于post的数据 | def _aodata(echo, columns, xnxq=None, final_exam=False):
"""
生成用于post的数据
:param echo: a int to check is response is write
:type echo: int
:param columns: 所有columns列名组成的list
:type columns: list
:param xnxq: str
:type xnxq: string
:param final_exam:... |
登陆系统 返回一个requests的session对象 | def login(self):
"""
登陆系统,返回一个requests的session对象
:return: session with login cookies
:rtype: requests.sessions.Session
"""
if not hasattr(self, 'session'):
self.last_connect = time.time()
s = requests.session()
s.get('http://bkjws.sdu.... |
获取课表 返回一个列表 包含所有课表对象 | def get_lesson(self):
"""
获取课表,返回一个列表,包含所有课表对象
:return: list of lessons
:rtype: list[dict]
"""
html = self._get('http://bkjws.sdu.edu.cn/f/xk/xs/bxqkb')
soup = BeautifulSoup(html, "html.parser")
s = soup.find('table',
attrs={"class":... |
返回lessons 如果未调用过 get_lesson () 会自动调用 | def lessons(self):
"""
返回lessons,如果未调用过``get_lesson()``会自动调用
:return: list of lessons
:rtype: list
"""
if hasattr(self, '_lessons'):
return self._lessons
else:
self.get_lesson()
return self._lessons |
个人信息 如果未调用过 get_detail () 会自动调用 | def detail(self):
"""
个人信息,如果未调用过``get_detail()``会自动调用
:return: information of student
:rtype: dict
"""
if hasattr(self, '_detail'):
return self._detail
else:
self.get_detail()
return self._detail |
个人信息 同时会把返回值保存在self. detail中: return: information of student: rtype: dict | def get_detail(self):
"""
个人信息,同时会把返回值保存在self.detail中
:return: information of student
:rtype: dict
"""
response = self._post("http://bkjws.sdu.edu.cn/b/grxx/xs/xjxx/detail",
data=None)
if response['result'] == 'success':
s... |
历年成绩查询的原始返回值 请使用get_past_score (): return: dict of the raw response of past score: rtype: dict | def get_raw_past_score(self):
"""
历年成绩查询的原始返回值,请使用get_past_score()
:return: dict of the raw response of past score
:rtype: dict
"""
echo = self._echo
response = self._post("http://bkjws.sdu.edu.cn/b/cj/cjcx/xs/lscx",
data=self._aoda... |
获取教学评估内所有需要课程 | def get_comment_lesson_info(self): # 获取课程序列
"""
获取教学评估内所有需要课程
:return: 返回所以有需要进行教学评估的课程
:rtype: list
"""
echo = self._echo
response = self._post('http://bkjws.sdu.edu.cn/b/pg/xs/list',
data=self._aodata(echo, ['kch', 'kcm', 'jsm', '... |
获取考试时间 | def get_exam_time(self, xnxq):
"""
获取考试时间
:param xnxq: 学年学期 格式为 ``开始学年-结束学年-{1|2|3}`` 3为暑期学校 example:``2016-2017-2``
:type xnxq: str
:return: list of exam time
:rtype: list
"""
echo = self._echo
response = self._post('http://bkjws.sdu.edu.cn/b/ksa... |
Creates a map of letter use in a word. | def _letter_map(word):
"""Creates a map of letter use in a word.
Args:
word: a string to create a letter map from
Returns:
a dictionary of {letter: integer count of letter in word}
"""
lmap = {}
for letter in word:
try:
lmap[letter] += 1
except KeyE... |
Finds anagrams in word. | def anagrams_in_word(word, sowpods=False, start="", end=""):
"""Finds anagrams in word.
Args:
word: the string to base our search off of
sowpods: boolean to declare TWL or SOWPODS words file
start: a string of starting characters to find anagrams based on
end: a string of ending... |
Returns the exception s name in an AMP Command friendly format. | def asAMP(cls):
"""
Returns the exception's name in an AMP Command friendly format.
For example, given a class named ``ExampleExceptionClass``, returns
``"EXAMPLE_EXCEPTION_CLASS"``.
"""
parts = groupByUpperCase(cls.__name__)
return cls, "_".join(part.upper() for... |
Transforms a Go Metrics API metric result into a list of values for a given window period. | def transform_timeseries_data(timeseries, start, end=None):
"""Transforms a Go Metrics API metric result into a list of
values for a given window period.
start and end are expected to be Unix timestamps in microseconds.
"""
data = []
include = False
for metric, points in timeseries.items():... |
Gets the most recent non - zero value for a. last metric or zero for empty data. | def get_last_value_from_timeseries(timeseries):
"""Gets the most recent non-zero value for a .last metric or zero
for empty data."""
if not timeseries:
return 0
for metric, points in timeseries.items():
return next((p['y'] for p in reversed(points) if p['y'] > 0), 0) |
Validate the given 1 - based page number. | def validate_page_number(number):
"""Validate the given 1-based page number."""
try:
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger('That page number is not an integer')
if number < 1:
raise EmptyPage('That page number is less than 1')
return numb... |
Get a page from an interator handling invalid input from the page number by defaulting to the first page. | def get_page_of_iterator(iterator, page_size, page_number):
"""
Get a page from an interator, handling invalid input from the page number
by defaulting to the first page.
"""
try:
page_number = validate_page_number(page_number)
except (PageNotAnInteger, EmptyPage):
page_number = ... |
Executes the given command. returns a 2 - tuple with returncode ( integer ) and OUTPUT ( string ) | def sh(cmd, escape=True):
""" Executes the given command.
returns a 2-tuple with returncode (integer) and OUTPUT (string)
"""
if escape:
cmd = quote(cmd)
process = Popen(cmd, stdout=PIPE, stderr=STDOUT, shell=True)
output, unused_err = process.communicate()
retcode = process.poll()... |
Gzip a file returns a 3 - tuple with returncode ( integer ) terminal output ( string ) and the new filename. | def gzip(filename):
""" Gzip a file
returns a 3-tuple with returncode (integer), terminal output (string)
and the new filename.
"""
## run gzip
retcode, output = sh('gzip %s' % filename)
new_filename = filename+'.gz'
return (retcode, output, new_filename) |
Create a tar - file or a tar. gz at location: filename. params: gzip: if True - gzip the file default = False dirs: dirs to be tared returns a 3 - tuple with returncode ( integer ) terminal output ( string ) and the new filename. | def tar(filename, dirs=[], gzip=False):
""" Create a tar-file or a tar.gz at location: filename.
params:
gzip: if True - gzip the file, default = False
dirs: dirs to be tared
returns a 3-tuple with returncode (integer), terminal output (string)
and the new filename.
"""
if gzip:
... |
alternative to os. chown. wraps around unix chown example: chown (/ tmp/ test/ bob bob ) | def chown(path, uid, guid, recursive=True):
""" alternative to os.chown.
wraps around unix chown
example:
chown('/tmp/test/', bob, bob)
returns 2-tuple: exitcode and terminal output
"""
if recursive:
cmd = 'chown -R %s:%s %s' % (uid, guid, path)
else:
... |
alternative to os. | def chmod(path, mode, recursive=True):
""" alternative to os.
"""
if recursive:
cmd = 'chmod -R %s %s' % (mode, path)
else:
cmd = 'chmod %s %s' % (mode, path)
return sh(cmd) |
Call this method from within a try/ except clause to generate a call to Stack Sentinel. | def handle_exception(self, exc_info=None, state=None, tags=None, return_feedback_urls=False,
dry_run=False):
"""
Call this method from within a try/except clause to generate a call to Stack Sentinel.
:param exc_info: Return value of sys.exc_info(). If you pass None, han... |
Sends error payload to Stack Sentinel API returning a parsed JSON response. ( Parsed as in converted into Python dict/ list objects ) | def send_error(self, error_type, error_message, traceback, environment, state, tags=None,
return_feedback_urls=False):
"""
Sends error payload to Stack Sentinel API, returning a parsed JSON response. (Parsed as in,
converted into Python dict/list objects)
:param error... |
Given configuration initiate an InternalSigningService instance | def make_internal_signing_service(config, entity_id):
"""
Given configuration initiate an InternalSigningService instance
:param config: The signing service configuration
:param entity_id: The entity identifier
:return: A InternalSigningService instance
"""
_args = dict([(k, v) for k, v in... |
Given configuration initiate a SigningService instance | def make_signing_service(config, entity_id):
"""
Given configuration initiate a SigningService instance
:param config: The signing service configuration
:param entity_id: The entity identifier
:return: A SigningService instance
"""
_args = dict([(k, v) for k, v in config.items() if k in KJ... |
Creates a signed JWT | def sign(self, req, receiver='', iss='', lifetime=0, sign_alg='', aud=None):
"""
Creates a signed JWT
:param req: Original metadata statement as a
:py:class:`MetadataStatement` instance
:param receiver: The intended audience for the JWS
:param iss: Issuer or the JWT
... |
Uses POST to send a first metadata statement signing request to a signing service. | def create(self, req, **kwargs):
"""
Uses POST to send a first metadata statement signing request to
a signing service.
:param req: The metadata statement that the entity wants signed
:return: returns a dictionary with 'sms' and 'loc' as keys.
"""
response = req... |
Uses PUT to update an earlier accepted and signed metadata statement. | def update_metadata_statement(self, location, req):
"""
Uses PUT to update an earlier accepted and signed metadata statement.
:param location: A URL to which the update request is sent
:param req: The diff between what is registereed with the signing
service and what it shou... |
Uses GET to get a newly signed metadata statement. | def update_signature(self, location):
"""
Uses GET to get a newly signed metadata statement.
:param location: A URL to which the request is sent
:return: returns a dictionary with 'sms' and 'loc' as keys.
"""
response = requests.get(location, **self.req_args())
r... |
Yield bundle contents from the given dict. | def _yield_bundle_contents(self, data):
"""Yield bundle contents from the given dict.
Each item yielded will be either a string representing a file path
or a bundle."""
if isinstance(data, list):
contents = data
else:
contents = data.get('contents', [])
... |
Return a bundle initialised by the given dict. | def _create_bundle(self, data):
"""Return a bundle initialised by the given dict."""
kwargs = {}
filters = None
if isinstance(data, dict):
kwargs.update(
filters=data.get('filters', None),
output=data.get('output', None),
debug=... |
Returns urls needed to include all assets of asset_type | def urls_for(self, asset_type, *args, **kwargs):
"""Returns urls needed to include all assets of asset_type
"""
return self.urls_for_depends(asset_type, *args, **kwargs) + \
self.urls_for_self(asset_type, *args, **kwargs) |
Return html tags for urls of asset_type | def html_tags_for(self, asset_type, *args, **kwargs):
"""Return html tags for urls of asset_type
"""
html = []
for ref in self.depends:
html.append(self._ref(ref).html_tags_for(asset_type, *args, **kwargs))
if asset_type in self.typed_bundles:
html.append(... |
Return all html tags for all asset_type | def html_tags(self, *args, **kwargs):
"""Return all html tags for all asset_type
"""
html = []
for asset_type in list_asset_types():
html.append(self.html_tags_for(asset_type.name, *args, **kwargs))
return "\n".join(html) |
Uses re to pull out the assigned value to __version__ in filename. | def find_version(filename):
"""Uses re to pull out the assigned value to __version__ in filename."""
with io.open(filename, encoding="utf-8") as version_file:
version_match = re.search(r'^__version__ = [\'"]([^\'"]*)[\'"]',
version_file.read(), re.M)
if version_mat... |
Given a URL check to see if there is an assocaited protocol. | def protocolise(url):
"""
Given a URL, check to see if there is an assocaited protocol.
If not, set the protocol to HTTP and return the protocolised URL
"""
# Use the regex to match http//localhost/something
protore = re.compile(r'https?:{0,1}/{1,2}')
parsed = urlparse.urlparse(url)
if ... |
Find the href destinations of all links at URL | def find_links(url):
"""
Find the href destinations of all links at URL
Arguments:
- `url`:
Return: list[str]
Exceptions: None
"""
url = protocolise(url)
content = requests.get(url).content
flike = StringIO(content)
root = html.parse(flike).getroot()
atags = root.cssse... |
Connected to AMP server start listening locally and give the AMP client a reference to the local listening factory. | def _connected(client):
"""
Connected to AMP server, start listening locally, and give the AMP
client a reference to the local listening factory.
"""
log.msg("Connected to AMP server, starting to listen locally...")
localFactory = multiplexing.ProxyingFactory(client, "hello")
return listenin... |
Return the [ section ] option values as a list. The list items must be delimited with commas and/ or newlines. | def getlist(self, section, option, *, raw=False, vars=None,
fallback=None):
"""Return the [section] option values as a list.
The list items must be delimited with commas and/or newlines.
"""
val = self.get(section, option, raw=raw, vars=vars, fallback=fallback)
va... |
Get modules by project_abspath and packages_scan. | def get_modules(self):
"""Get modules by project_abspath and packages_scan.
Traverse all files under folder packages_scan which set by customer.
And get all modules name.
"""
if not self.project_abspath:
raise TypeError("project_abspath can not be empty.")
pa... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.