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_03_16.json\')
"""
response = self._get_request(self._activity_endpoint(athlete, filename)).json()
activity = pd.DataFrame(response['RIDE']['SAMPLES'])
activity = activity.rename(columns=ACTIVITY_COLUMN_TRANSLATION)
activity.index = pd.to_timedelta(activity.time, unit='s')
activity.drop('time', axis=1, inplace=True)
return activity[[i for i in ACTIVITY_COLUMN_ORDER if i in activity.columns]] |
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}/activity/{filename}'.format(
host=self.host,
athlete=quote_plus(athlete),
filename=filename
) |
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:
raise GoldenCheetahNotAvailable(endpoint)
if response.text.startswith('unknown athlete'):
match = re.match(
pattern='unknown athlete (?P<athlete>.+)',
string=response.text)
raise AthleteDoesNotExist(
athlete=match.groupdict()['athlete'])
elif response.text == 'file not found':
match = re.match(
pattern='.+/activity/(?P<filename>.+)',
string=endpoint)
raise ActivityDoesNotExist(
filename=match.groupdict()['filename'])
return response |
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 create.
:returns: A tuple with ``(build_id, app_name)``.
"""
data = self._api.create_build(
tarball_url=tarball_url,
env=env,
app_name=app_name,
)
return (data['id'], data['app']['name']) |
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 + "." + view if prefix else view)))
elif isinstance(view, (list, tuple)): # include
return url(regex, view, name, prefix, **kwargs)
else: # view is an object
return url(regex, api_auth(view)) |
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 RegexURLPattern
resolverFunc: function to process RegexURLResolver
"""
for u in urlpattern:
if isinstance(u, RegexURLResolver): # inspect sub urls
if resolverFunc:
resolverFunc(u, prefixre, prefixname)
traverse_urls(u.url_patterns,
prefixre + [u.regex, ],
prefixname + [u._regex, ],
patternFunc,
resolverFunc)
else:
if patternFunc:
patternFunc(u, prefixre, prefixname) |
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
:param genders: list of allowed genders. (GENDER_FEMALE, GENDER_MALE) if None
"""
languages = languages or ['en']
genders = genders or (GENDER_FEMALE, GENDER_MALE)
choices = _get_titles(languages)
gender = {'m':0, 'f':1}[random.choice(genders)]
return random.choice(choices)[gender] |
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'])
(u'Jacinto', u'Delgado', u'El Sr.', 'm')
:param language:
:param genders:
"""
languages = languages or ['en']
genders = genders or (GENDER_FEMALE, GENDER_MALE)
lang = random.choice(languages)
g = random.choice(genders)
t = title([lang], [g])
return first_name([lang], [g]), last_name([lang]), t, g |
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 = genders or [GENDER_MALE, GENDER_FEMALE]
for lang in languages:
for gender in genders:
samples = _get_firstnames(lang, gender)
choices.extend(samples)
return random.choice(choices).title() |
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_name(['it'])
'It_Lastname'
"""
choices = []
languages = languages or ['en']
for lang in languages:
samples = _get_lastnames(lang)
choices.extend(samples)
return random.choice(choices).title() |
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:
yield arg |
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)
self['chxt'] = atype
return self.parent |
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))))
return self.parent |
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(args, 0)
self.data['styles'].append(
','.join([str(index)]+list(map(str,args)))
)
return self.parent |
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, dict):
return cls(**qs)
return cls(**dict(parse_qsl(qs[qs.index('?')+1:]))) |
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/ statecodes. html APIPARAMS: chtm & chld | 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 state codes can be found at http://code.google.com/apis/chart/statecodes.html
APIPARAMS: chtm & chld
"""
assert geo in GEO, 'Geograpic area %s not recognized'%geo
self._geo = geo
self._ld = country_codes
return self |
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!
APIPARAM: chds
"""
self._scale = [','.join(map(smart_str, args))]
return self |
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 complete spec
APIPARAM: chm
"""
if len(args[0]) == 1:
assert args[0] in MARKERS, 'Invalid marker type: %s'%args[0]
assert len(args) <= 6, 'Incorrect arguments %s'%str(args)
args = color_args(args, 1)
self.markers.append(','.join(map(str,args)) )
return self |
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>
APIPARAM: chma
"""
self['chma'] = '%d,%d,%d,%d' % (left, right, top, bottom)
if lwidth or lheight:
self['chma'] += '|%d,%d' % (lwidth, lheight)
return self |
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 map(float,args)]))
return self |
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 = args[:2]
assert a in ('c','bg','a'), 'Fill type must be bg/c/a not %s'%a
assert b in ('s','lg','ls'), 'Fill style must be s/lg/ls not %s'%b
if len(args) == 3:
args = color_args(args, 2)
else:
args = color_args(args, 3,5)
self.fills.append(','.join(map(str,args)))
return self |
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
"""
grids = map(str,map(float,args))
self['chg'] = ','.join(grids).replace('None','')
return self |
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,args))
return self |
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)
return self |
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'].split('x')
assert len(size) == 2, 'Invalid size, must be in the format WxH'
self.check_size(*map(int,size))
assert 'cht' in self, 'No chart type defined, use type method'
self['cht'] = self.check_type(self['cht'])
if ('any' in dir(self._dataset) and self._dataset.any()) or self._dataset:
self['chd'] = encoder.encode(self._dataset)
elif not 'choe' in self:
assert 'chd' in self, 'You must have a dataset, or use chd'
if self._scale:
assert self['chd'].startswith('t'),\
'You must use text encoding with chds'
self['chds'] = ','.join(self._scale)
if self._geo and self._ld:
self['chtm'] = self._geo
self['chld'] = self._ld
if self.lines:
self['chls'] = '|'.join(self.lines)
if self.markers:
self['chm'] = '|'.join(self.markers)
if self.fills:
self['chf'] = '|'.join(self.fills) |
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',
'pie': 'p',
'venn': 'v',
'scater': 's',
'radar': 'r',
'meter': 'gom',
})
assert type in tdict, 'Invalid chart type: %s'%type
return tdict[type] |
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 not fname.endswith('.png'):
fname += '.png'
try:
urlretrieve(self.url, fname)
except Exception:
raise IOError('Problem saving %s to file'%fname)
return fname |
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('<', '<')\
.replace('>', '>').replace('"', '"').replace( "'", ''')
for item in kwargs.items():
if not item[0] in IMGATTRS:
raise AttributeError('Invalid img tag attribute: %s'%item[0])
safe += '%s="%s" '%item
return '<img %s/>'%safe |
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 server.') |
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:
raise ImportError('You must install PIL to fetch image objects')
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
return Image.open(StringIO(self.urlopen().read())) |
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__), 'data', 'countryInfo.txt')
data = []
for line in open(cache_filename, 'r'):
if not line.startswith('#'):
data.append(line.split('\t'))
return data |
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)).quantize(decimal.Decimal(q)) |
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 that exists outside of
kalibro_client and inherits from Project, it's entity name should still
be Project.
"""
class_name = inflection.underscore(top_cls.__name__).lower()
def entity_name(cls):
return class_name
top_cls.entity_name = classmethod(entity_name)
return top_cls |
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:
continue
if k in orig:
if is_lesser(orig[k], v):
_le[k] = orig[k]
else:
_err.append({'claim': k, 'policy': orig[k], 'err': v,
'signer': self.iss})
else:
_le[k] = v
for k, v in orig.items():
if k in DoNotCompare:
continue
if k not in _le:
_le[k] = v
self.le = _le
self.err = _err |
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.
"""
if self.sup:
res = {}
for k, v in self.le.items():
if k not in self.sup.le:
res[k] = v
else:
res[k] = self.sup.le[k]
return res
else:
return self.le |
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.self_signer.keyjar.get_signing_key(owner=self.iss)]
return {'keys': _l} |
: 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
:param liss: List of FO issuer IDs
:return: ParseInfo instance
"""
if liss is None:
liss = []
_pr = ParseInfo()
_pr.input = ms_dict
ms_flag = False
if 'metadata_statements' in ms_dict:
ms_flag = True
for iss, _ms in ms_dict['metadata_statements'].items():
if liss and iss not in liss:
continue
_pr = self._ums(_pr, _ms, keyjar)
if 'metadata_statement_uris' in ms_dict:
ms_flag = True
if self.httpcli:
for iss, url in ms_dict['metadata_statement_uris'].items():
if liss and iss not in liss:
continue
rsp = self.httpcli(method='GET', url=url,
verify=self.verify_ssl)
if rsp.status_code == 200:
_pr = self._ums(_pr, rsp.text, keyjar)
else:
raise ParseError(
'Could not fetch jws from {}'.format(url))
for _ms in _pr.parsed_statement:
if _ms: # can be None
loaded = False
try:
keyjar.import_jwks_as_json(_ms['signing_keys'],
ms_dict['iss'])
except KeyError:
pass
except TypeError:
try:
keyjar.import_jwks(_ms['signing_keys'], ms_dict['iss'])
except Exception as err:
logger.error(err)
raise
else:
loaded = True
else:
loaded = True
if loaded:
logger.debug(
'Loaded signing keys belonging to {} into the '
'keyjar'.format(ms_dict['iss']))
if ms_flag is True and not _pr.parsed_statement:
return _pr
if jwt_ms:
logger.debug("verifying signed JWT: {}".format(jwt_ms))
try:
_pr.result = cls().from_jwt(jwt_ms, keyjar=keyjar)
except MissingSigningKey:
if 'signing_keys' in ms_dict:
try:
_pr.result = self.self_signed(ms_dict, jwt_ms, cls)
except MissingSigningKey as err:
logger.error('Encountered: {}'.format(err))
_pr.error[jwt_ms] = err
except (JWSException, BadSignature, KeyError) as err:
logger.error('Encountered: {}'.format(err))
_pr.error[jwt_ms] = err
else:
_pr.result = ms_dict
if _pr.result and _pr.parsed_statement:
_prr = _pr.result
_res = {}
for x in _pr.parsed_statement:
if x:
_res[get_fo(x)] = x
_msg = Message(**_res)
logger.debug('Resulting metadata statement: {}'.format(_msg))
_pr.result['metadata_statements'] = _msg
return _pr |
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 statement as a dictionary
:param jwt_ms: Metadata statement as JWT
:param keyjar: Keys that should be used to verify the signature of the
document
:param cls: What type (Class) of metadata statement this is
:param liss: list of FO identifiers that matters. The rest will be
ignored
:return: A ParseInfo instance
"""
if not keyjar:
if self.jwks_bundle:
keyjar = self.jwks_bundle.as_keyjar()
else:
keyjar = KeyJar()
if jwt_ms:
try:
ms_dict = unfurl(jwt_ms)
except JWSException as err:
logger.error('Could not unfurl jwt_ms due to {}'.format(err))
raise
if ms_dict:
return self._unpack(ms_dict, keyjar, cls, jwt_ms, liss)
else:
raise AttributeError('Need one of ms_dict or jwt_ms') |
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: Receiver (audience) of the JWT
:param iss: Issuer ID if different from default
:param lifetime: jWT signature life time
:param sign_alg: JWT signature algorithm
:return: A JWT
"""
return self.self_signer.sign(metadata, receiver=receiver, iss=iss,
lifetime=lifetime, sign_alg=sign_alg) |
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 dictionary
:return: A list of :py:class:`fedoidc.operator.LessOrEqual`
instances, one per FO.
"""
# start from the innermost metadata statement and work outwards
res = dict([(k, v) for k, v in metadata.items() if k not in IgnoreKeys])
les = []
if 'metadata_statements' in metadata:
for fo, ms in metadata['metadata_statements'].items():
if isinstance(ms, str):
ms = json.loads(ms)
for _le in self.evaluate_metadata_statement(ms):
if isinstance(ms, Message):
le = LessOrEqual(sup=_le, **ms.to_dict())
else: # Must be a dict
le = LessOrEqual(sup=_le, **ms)
if le.is_expired():
logger.error(
'This metadata statement has expired: {}'.format(ms)
)
logger.info('My time: {}'.format(utc_time_sans_frac()))
continue
le.eval(res)
les.append(le)
return les
else: # this is the innermost
try:
_iss = metadata['iss']
except:
le = LessOrEqual()
le.eval(res)
else:
le = LessOrEqual(iss=_iss, exp=metadata['exp'])
le.eval(res)
les.append(le)
return les |
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.
"""
if 'metadata_statements' in metadata:
_msl = {}
for fo, ms in metadata['metadata_statements'].items():
if not isinstance(ms, Message):
ms = json.loads(ms)
if self.correct_usage(ms, federation_usage=federation_usage):
_msl[fo] = ms
if _msl:
metadata['metadata_statements'] = Message(**_msl)
return metadata
else:
return None
else: # this is the innermost
try:
assert federation_usage == metadata['federation_usage']
except KeyError:
pass
except AssertionError:
return None
return metadata |
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
"""
_ms_uri = {}
_ms = {}
for fo, sms in sms_dict.items():
if sms.startswith('http://') or sms.startswith('https://'):
_ms_uri[fo] = sms
else:
_ms[fo] = sms
if _ms:
req['metadata_statements'] = Message(**_ms)
if _ms_uri:
req['metadata_statement_uris'] = Message(**_ms_uri)
return req |
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(
'infile', type=argparse.FileType('r'),
help="File read in to create concordance")
argparser.add_argument(
'outfile', nargs='?', type=argparse.FileType('w'),
default=sys.stdout, help="File to write concordance to. "
"Default is stdout")
argparser.add_argument(
'--word', nargs="?", const=str, help="Display a word in concordance")
args = argparser.parse_args()
return args |
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("Logging options")
group.add_argument(
"-l", "--log-level", dest="log_levels",
action="log_levels", metavar="LOGGER:LEVEL", default=[],
help="Set log levels for individual loggers. See --help-logging for "
"complete details.")
group.add_argument(
"-L", "--log-file", dest="log_files",
action="log_files", metavar="LOGGER:FILE", default=[],
help="Set log the output file for individual loggers. "
" See --help-logging for complete details.")
group.add_argument("--help-logging", action="log_help",
help=argparse.SUPPRESS) |
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 opts take precedence but were
overridded by a fileConfig, etc.).
"""
for l, lvl in log_levels:
l.setLevel(lvl)
for l, hdl in log_files:
for h in l.handlers:
l.removeHandler(h)
l.addHandler(hdl) |
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: 是否期末考试
:rtype: bool
:return: a valid data for post to get data
"""
ao_data = [{"name": "sEcho", "value": echo},
{"name": "iColumns", "value": len(columns)},
{"name": "sColumns", "value": ""},
{"name": "iDisplayStart", "value": 0},
{"name": "iDisplayLength", "value": -1},
]
if xnxq:
if final_exam:
ao_data.append(
{"name": "ksrwid", "value": "000000005bf6cb6f015bfac609410d4b"})
ao_data.append({"name": "xnxq", "value": xnxq})
for index, value in enumerate(columns):
ao_data.append(
{"name": "mDataProp_{}".format(index), "value": value})
ao_data.append(
{"name": "bSortable_{}".format(index), "value": False})
return urlencode({"aoData": ao_data}) |
登陆系统 返回一个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.edu.cn')
data = {
'j_username': self.student_id,
'j_password': self.password_md5
}
r6 = s.post('http://bkjws.sdu.edu.cn/b/ajaxLogin', headers={
'user-agent': self._ua},
data=data)
if r6.text == '"success"':
return s
else:
s.close()
raise AuthFailure(r6.text) |
获取课表 返回一个列表 包含所有课表对象 | 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": "table table-striped table-bordered table-hover",
"id": "ysjddDataTableId"})
tr_box = s.find_all('tr')
c = list()
for les in tr_box[1:]:
td_box = les.find_all('td')
c.append({"lesson_num_long": td_box[1].text,
"lesson_name": td_box[2].text,
"lesson_num_short": td_box[3].text,
"credit": td_box[4].text,
"school": td_box[6].text,
"teacher": td_box[7].text,
"weeks": td_box[8].text,
"days": td_box[9].text,
"times": td_box[10].text,
"place": td_box[11].text})
self._lessons = c
return c |
返回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':
self._detail = response['object']
return self._detail
else:
self._unexpected(response) |
历年成绩查询的原始返回值 请使用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._aodata(echo,
columns=["xnxq", "kcm", "kxh", "xf", "kssj",
"kscjView", "wfzjd",
"wfzdj",
"kcsx"]))
if self._check_response(response, echo):
self._raw_past_score = response
return self._raw_past_score
else:
self._unexpected(response) |
获取教学评估内所有需要课程 | 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', 'function', 'function']), )
if self._check_response(response, echo=echo):
return response['object']['aaData']
else:
self._unexpected(response) |
获取考试时间 | 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/ksap/xs/vksapxs/pageList',
data=self._aodata(echo, xnxq=xnxq,
columns=["function", 'ksmc', 'kcm', 'kch', 'xqmc',
'jxljs', 'sjsj', "ksfsmc",
"ksffmc", "ksbz"]))
if self._check_response(response, echo):
return response['object']['aaData']
else:
self._unexpected(response) |
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 KeyError:
lmap[letter] = 1
return lmap |
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 characters to find anagrams based on
Yields:
a tuple of (word, score) that can be made with the input_word
"""
input_letters, blanks, questions = blank_tiles(word)
for tile in start + end:
input_letters.append(tile)
for word in word_list(sowpods, start, end):
lmap = _letter_map(input_letters)
used_blanks = 0
for letter in word:
if letter in lmap:
lmap[letter] -= 1
if lmap[letter] < 0:
used_blanks += 1
if used_blanks > (blanks + questions):
break
else:
used_blanks += 1
if used_blanks > (blanks + questions):
break
else:
yield (word, word_score(word, input_letters, questions)) |
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 part in parts) |
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():
for point in points:
if point['x'] == start:
include = True
if include:
data.append(point['y'])
if end is not None and point['x'] == end:
return data
return data |
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 number |
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 = 1
start = (page_number - 1) * page_size
# End 1 more than we need, so that we can see if there's another page
end = (page_number * page_size) + 1
skipped_items = list(islice(iterator, start))
items = list(islice(iterator, end))
if len(items) == 0 and page_number != 1:
items = skipped_items
page_number = 1
has_next = len(items) > page_size
items = items[:page_size]
return NoCountPage(items, page_number, page_size, has_next) |
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()
return (retcode, output) |
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:
cmd = 'tar czvf %s ' % filename
else:
cmd = 'tar cvf %s ' % filename
if type(dirs) != 'list':
dirs = [dirs]
cmd += ' '.join(str(x) for x in dirs)
retcode, output = sh(cmd)
return (retcode, output, filename) |
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:
cmd = 'chown %s:%s %s' % (uid, guid, path)
return sh(cmd) |
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, handle_exception will call sys.exc_info() itself
:param state: Dictionary of state information associated with the error. This could be form data, cookie data, whatnot. NOTE: sys and machine are added to this dictionary if they are not already included.
:param tags: Any string tags you want associated with the exception report.
:param return_feedback_urls: If True, Stack Sentinel will return feedback URLs you can present to the user for extra debugging information.
:param dry_run: If True, method will not actively send in error information to API. Instead, it will return a request object and payload. Used in unittests.
"""
if not exc_info:
exc_info = sys.exc_info()
if exc_info is None:
raise StackSentinelError("handle_exception called outside of exception handler")
(etype, value, tb) = exc_info
try:
msg = value.args[0]
except:
msg = repr(value)
if not isinstance(tags, list):
tags = [tags]
limit = None
new_tb = []
n = 0
while tb is not None and (limit is None or n < limit):
f = tb.tb_frame
lineno = tb.tb_lineno
co = f.f_code
filename = co.co_filename
name = co.co_name
tb = tb.tb_next
n = n + 1
new_tb.append({'line': lineno, 'module': filename, 'method': name})
if state is None:
state = {}
if 'sys' not in state:
try:
state['sys'] = self._get_sys_info()
except Exception as e:
state['sys'] = '<Unable to get sys: %r>' % e
if 'machine' not in state:
try:
state['machine'] = self._get_machine_info()
except Exception as e:
state['machine'] = '<Unable to get machine: %e>' % e
if tags is None:
tags = []
# The joy of Unicode
if sys.version_info.major > 2:
error_type = str(etype.__name__)
error_message = str(value)
else:
error_type = unicode(etype.__name__)
error_message = unicode(value)
send_error_args = dict(error_type=error_type,
error_message=error_message,
traceback=new_tb,
environment=self.environment,
state=state,
tags=self.tags + tags,
return_feedback_urls=return_feedback_urls)
if dry_run:
return send_error_args
else:
return self.send_error(**send_error_args) |
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_type: Type of error generated. (Eg, "TypeError")
:param error_message: Message of error generated (Eg, "cannot concatenate 'str' and 'int' objects")
:param traceback: List of dictionaries. Each dictionary should contain, "line", "method", and "module" keys.
:param environment: Environment the error occurred in (eg, "devel")_
:param state: State of the application when the error happened. Could contain form data, cookies, etc.
:param tags: Arbitrary tags you want associated with the error. list.
:param return_feedback_urls: If True, return payload will offer URLs to send users to collect additional feedback for debugging.
:return: Parsed return value from Stack Sentinel API
"""
(request, payload) = self._generate_request(environment, error_message, error_type, return_feedback_urls,
state, tags, traceback)
try:
response = urlopen(request)
except HTTPError as e:
if e.code == 400:
raise StackSentinelError(e.read())
else:
raise
if sys.version_info.major > 2:
text_response = response.read().decode(response.headers.get_content_charset() or 'utf8')
else:
encoding = response.headers.get('content-type', '').split('charset=')[-1].strip()
if encoding:
text_response = response.read().decode('utf8', 'replace')
else:
text_response = response.read().decode(encoding)
return json.loads(text_response) |
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 config.items() if k in KJ_SPECS])
_kj = init_key_jar(**_args)
return InternalSigningService(entity_id, _kj) |
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_SPECS])
_kj = init_key_jar(**_args)
if config['type'] == 'internal':
signer = InternalSigningService(entity_id, _kj)
elif config['type'] == 'web':
_kj.issuer_keys[config['iss']] = _kj.issuer_keys['']
del _kj.issuer_keys['']
signer = WebSigningServiceClient(config['iss'], config['url'],
entity_id, _kj)
else:
raise ValueError('Unknown signer type: {}'.format(config['type']))
return signer |
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
:param lifetime: Lifetime of the signature
:param sign_alg: Which signature algorithm to use
:param aud: The audience, a list of receivers.
:return: A signed JWT
"""
if not sign_alg:
for key_type, s_alg in [('RSA', 'RS256'), ('EC', 'ES256')]:
if self.keyjar.get_signing_key(key_type=key_type):
sign_alg = s_alg
break
if not sign_alg:
raise NoSigningKeys('Could not find any signing keys')
return self.pack(req=req, receiver=receiver, iss=iss, lifetime=lifetime,
sign=True, encrypt=False, sign_alg=sign_alg) |
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 = requests.post(self.url, json=req, **self.req_args())
return self.parse_response(response) |
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 should be.
:return: returns a dictionary with 'sms' and 'loc' as keys.
"""
response = requests.put(location, json=req, **self.req_args())
return self.parse_response(response) |
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())
return self.parse_response(response) |
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', [])
if isinstance(contents, six.string_types):
contents = contents,
for content in contents:
if isinstance(content, dict):
content = self._create_bundle(content)
yield content |
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=data.get('debug', None),
extra=data.get('extra', {}),
config=data.get('config', {}),
depends=data.get('depends', None))
bundle = Bundle(*list(self._yield_bundle_contents(data)), **kwargs)
return self._auto_filter_bundle(bundle) |
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(render_asset_html_tags(asset_type, self.urls_for_self(asset_type, *args, **kwargs)))
return "\n".join(html) |
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_match:
return version_match.group(1)
return "0.0-version-unknown" |
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 not parsed.scheme and not protore.search(url):
url = 'http://{0}'.format(url)
return url |
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.cssselect('a')
hrefs = [a.attrib['href'] for a in atags]
# !!! This does the wrong thing for bbc.co.uk/index.html
hrefs = [h if h.startswith('http') else '/'.join([url, h]) for h in hrefs ]
return hrefs |
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 listeningEndpoint.listen(localFactory) |
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)
values = []
if val:
for line in val.split("\n"):
values += [s.strip() for s in line.split(",")]
return values |
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.")
packages_abspath = self.get_package_abspath()
for package_abspath in packages_abspath:
self.get_module_name(package_abspath)
return self._modules |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.