Search is not available for this dataset
text
stringlengths 75
104k
|
|---|
def one_to_many(clsname, **kw):
"""Use an event to build a one-to-many relationship on a class.
This makes use of the :meth:`.References._reference_table` method
to generate a full foreign key relationship from the remote table.
"""
@declared_attr
def o2m(cls):
cls._references((clsname, cls.__name__))
return relationship(clsname, **kw)
return o2m |
def djeffify_string(string_to_djeff):
"""
Djeffifies string_to_djeff
"""
string_to_djeff = re.sub(r'^(?=[jg])', 'd', string_to_djeff, flags=re.IGNORECASE) # first
string_to_djeff = re.sub(r'[ ](?=[jg])', ' d', string_to_djeff, flags=re.IGNORECASE) # spaces
string_to_djeff = re.sub(r'[\n](?=[jg])', '\nd', string_to_djeff, flags=re.IGNORECASE) # \n
return string_to_djeff |
def handle_data(self, data):
"""
Djeffify data between tags
"""
if data.strip():
data = djeffify_string(data)
self.djhtml += data |
def _reference_table(cls, ref_table):
"""Create a foreign key reference from the local class to the given remote
table.
Adds column references to the declarative class and adds a
ForeignKeyConstraint.
"""
# create pairs of (Foreign key column, primary key column)
cols = [(sa.Column(), refcol) for refcol in ref_table.primary_key]
# set "tablename_colname = Foreign key Column" on the local class
for col, refcol in cols:
setattr(cls, "%s_%s" % (ref_table.name, refcol.name), col)
# add a ForeignKeyConstraint([local columns], [remote columns])
cls.__table__.append_constraint(sa.ForeignKeyConstraint(*zip(*cols))) |
def __try_to_json(self, request, attr):
"""
Try to run __json__ on the given object.
Raise TypeError is __json__ is missing
:param request: Pyramid Request object
:type request: <Request>
:param obj: Object to JSONify
:type obj: any object that has __json__ method
:exception: TypeError
"""
# check for __json__ method and try to JSONify
if hasattr(attr, '__json__'):
return attr.__json__(request)
# raise error otherwise
raise TypeError('__json__ method missing on %s' % str(attr)) |
def prepare_path(path):
"""
Path join helper method
Join paths if list passed
:type path: str|unicode|list
:rtype: str|unicode
"""
if type(path) == list:
return os.path.join(*path)
return path |
def read_from_file(file_path, encoding="utf-8"):
"""
Read helper method
:type file_path: str|unicode
:type encoding: str|unicode
:rtype: str|unicode
"""
with codecs.open(file_path, "r", encoding) as f:
return f.read() |
def write_to_file(file_path, contents, encoding="utf-8"):
"""
Write helper method
:type file_path: str|unicode
:type contents: str|unicode
:type encoding: str|unicode
"""
with codecs.open(file_path, "w", encoding) as f:
f.write(contents) |
def copy_file(src, dest):
"""
Copy file helper method
:type src: str|unicode
:type dest: str|unicode
"""
dir_path = os.path.dirname(dest)
if not os.path.exists(dir_path):
os.makedirs(dir_path)
shutil.copy2(src, dest) |
def get_path_extension(path):
"""
Split file name and extension
:type path: str|unicode
:rtype: one str|unicode
"""
file_path, file_ext = os.path.splitext(path)
return file_ext.lstrip('.') |
def split_path(path):
"""
Helper method for absolute and relative paths resolution
Split passed path and return each directory parts
example: "/usr/share/dir"
return: ["usr", "share", "dir"]
@type path: one of (unicode, str)
@rtype: list
"""
result_parts = []
#todo: check loops
while path != "/":
parts = os.path.split(path)
if parts[1] == path:
result_parts.insert(0, parts[1])
break
elif parts[0] == path:
result_parts.insert(0, parts[0])
break
else:
path = parts[0]
result_parts.insert(0, parts[1])
return result_parts |
def _create_api_uri(self, *parts):
"""Creates fully qualified endpoint URIs.
:param parts: the string parts that form the request URI
"""
return urljoin(self.API_URI, '/'.join(map(quote, parts))) |
def _format_iso_time(self, time):
"""Makes sure we have proper ISO 8601 time.
:param time: either already ISO 8601 a string or datetime.datetime
:returns: ISO 8601 time
:rtype: str
"""
if isinstance(time, str):
return time
elif isinstance(time, datetime):
return time.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
else:
return None |
def _handle_response(self, response):
"""Returns the given response or raises an APIError for non-2xx responses.
:param requests.Response response: HTTP response
:returns: requested data
:rtype: requests.Response
:raises APIError: for non-2xx responses
"""
if not str(response.status_code).startswith('2'):
raise get_api_error(response)
return response |
def _check_next(self):
"""Checks if a next message is possible.
:returns: True if a next message is possible, otherwise False
:rtype: bool
"""
if self.is_initial:
return True
if self.before:
if self.before_cursor:
return True
else:
return False
else:
if self.after_cursor:
return True
else:
return False |
def _wrap_color(self, code, text, format=None, style=None):
""" Colors text with code and given format """
color = None
if code[:3] == self.bg.PREFIX:
color = self.bg.COLORS.get(code, None)
if not color:
color = self.fg.COLORS.get(code, None)
if not color:
raise Exception('Color code not found')
if format and format not in self.formats:
raise Exception('Color format not found')
fmt = "0;"
if format == 'bold':
fmt = "1;"
elif format == 'underline':
fmt = "4;"
# Manage the format
parts = color.split('[')
color = '{0}[{1}{2}'.format(parts[0], fmt, parts[1])
if self.has_colors and self.colors_enabled:
# Set brightness
st = ''
if style:
st = self.st.COLORS.get(style, '')
return "{0}{1}{2}{3}".format(st, color, text, self.st.COLORS['reset_all'])
else:
return text |
def RegisterMessage(self, message):
"""Registers the given message type in the local database.
Args:
message: a message.Message, to be registered.
Returns:
The provided message.
"""
desc = message.DESCRIPTOR
self._symbols[desc.full_name] = message
if desc.file.name not in self._symbols_by_file:
self._symbols_by_file[desc.file.name] = {}
self._symbols_by_file[desc.file.name][desc.full_name] = message
self.pool.AddDescriptor(desc)
return message |
def GetMessages(self, files):
"""Gets all the messages from a specified file.
This will find and resolve dependencies, failing if they are not registered
in the symbol database.
Args:
files: The file names to extract messages from.
Returns:
A dictionary mapping proto names to the message classes. This will include
any dependent messages as well as any messages defined in the same file as
a specified message.
Raises:
KeyError: if a file could not be found.
"""
result = {}
for f in files:
result.update(self._symbols_by_file[f])
return result |
def insert(self, index, value):
"""
Insert object before index.
:param int index: index to insert in
:param string value: path to insert
"""
self._list.insert(index, value)
self._sync() |
def parse(self, string):
"""
Parse runtime path representation to list.
:param string string: runtime path string
:return: list of runtime paths
:rtype: list of string
"""
var, eq, values = string.strip().partition('=')
assert var == 'runtimepath'
assert eq == '='
return values.split(',') |
def add_bundle(self, *args):
"""
Add some bundle to build group
:type bundle: static_bundle.bundles.AbstractBundle
@rtype: BuildGroup
"""
for bundle in args:
if not self.multitype and self.has_bundles():
first_bundle = self.get_first_bundle()
if first_bundle.get_type() != bundle.get_type():
raise Exception(
'Different bundle types for one Asset: %s[%s -> %s]'
'check types or set multitype parameter to True'
% (self.name, first_bundle.get_type(), bundle.get_type())
)
self.bundles.append(bundle)
return self |
def collect_files(self):
"""
Return collected files links
:rtype: list[static_bundle.files.StaticFileResult]
"""
self.files = []
for bundle in self.bundles:
bundle.init_build(self, self.builder)
bundle_files = bundle.prepare()
self.files.extend(bundle_files)
return self |
def get_minifier(self):
"""
Asset minifier
Uses default minifier in bundle if it's not defined
:rtype: static_bundle.minifiers.DefaultMinifier|None
"""
if self.minifier is None:
if not self.has_bundles():
raise Exception("Unable to get default minifier, no bundles in build group")
minifier = self.get_first_bundle().get_default_minifier()
else:
minifier = self.minifier
if minifier:
minifier.init_asset(self)
return minifier |
def create_asset(self, name, **kwargs):
"""
Create asset
:type name: unicode|str
:rtype: Asset
"""
asset = Asset(self, name, **kwargs)
self.assets[name] = asset
return asset |
def render_asset(self, name):
"""
Render all includes in asset by names
:type name: str|unicode
:rtype: str|unicode
"""
result = ""
if self.has_asset(name):
asset = self.get_asset(name)
if asset.files:
for f in asset.files:
result += f.render_include() + "\r\n"
return result |
def collect_links(self, env=None):
"""
Return links without build files
"""
for asset in self.assets.values():
if asset.has_bundles():
asset.collect_files()
if env is None:
env = self.config.env
if env == static_bundle.ENV_PRODUCTION:
self._minify(emulate=True)
self._add_url_prefix() |
def make_build(self):
"""
Move files / make static build
"""
for asset in self.assets.values():
if asset.has_bundles():
asset.collect_files()
if not os.path.exists(self.config.output_dir):
os.makedirs(self.config.output_dir)
if self.config.copy_only_bundles:
for asset in self.assets.values():
if not asset.minify and asset.files:
for f in asset.files:
copy_file(f.abs_path, self._get_output_path(f.abs_path))
else:
copy_excludes = {}
for asset in self.assets.values():
if asset.minify and asset.files:
for f in asset.files:
copy_excludes[f.abs_path] = f
for root, dirs, files in os.walk(self.config.input_dir):
for fpath in files:
current_file_path = os.path.join(root, fpath)
if current_file_path not in copy_excludes:
copy_file(current_file_path, self._get_output_path(current_file_path))
self._minify() |
def clear(self, exclude=None):
"""
Clear build output dir
:type exclude: list|None
"""
exclude = exclude or []
for root, dirs, files in os.walk(self.config.output_dir):
for f in files:
if f not in exclude:
os.unlink(os.path.join(root, f))
for d in dirs:
if d not in exclude:
shutil.rmtree(os.path.join(root, d)) |
def _default_json_default(obj):
""" Coerce everything to strings.
All objects representing time get output according to default_date_fmt.
"""
if isinstance(obj, (datetime.datetime, datetime.date, datetime.time)):
return obj.strftime(default_date_fmt)
else:
return str(obj) |
def init_logs(path=None,
target=None,
logger_name='root',
level=logging.DEBUG,
maxBytes=1*1024*1024,
backupCount=5,
application_name='default',
server_hostname=None,
fields=None):
"""Initialize the zlogger.
Sets up a rotating file handler to the specified path and file with
the given size and backup count limits, sets the default
application_name, server_hostname, and default/whitelist fields.
:param path: path to write the log file
:param target: name of the log file
:param logger_name: name of the logger (defaults to root)
:param level: log level for this logger (defaults to logging.DEBUG)
:param maxBytes: size of the file before rotation (default 1MB)
:param application_name: app name to add to each log entry
:param server_hostname: hostname to add to each log entry
:param fields: default/whitelist fields.
:type path: string
:type target: string
:type logger_name: string
:type level: int
:type maxBytes: int
:type backupCount: int
:type application_name: string
:type server_hostname: string
:type fields: dict
"""
log_file = os.path.abspath(
os.path.join(path, target))
logger = logging.getLogger(logger_name)
logger.setLevel(level)
handler = logging.handlers.RotatingFileHandler(
log_file, maxBytes=maxBytes, backupCount=backupCount)
handler.setLevel(level)
handler.setFormatter(
JsonFormatter(
application_name=application_name,
server_hostname=server_hostname,
fields=fields))
logger.addHandler(handler) |
def format(self, record):
"""formats a logging.Record into a standard json log entry
:param record: record to be formatted
:type record: logging.Record
:return: the formatted json string
:rtype: string
"""
record_fields = record.__dict__.copy()
self._set_exc_info(record_fields)
event_name = 'default'
if record_fields.get('event_name'):
event_name = record_fields.pop('event_name')
log_level = 'INFO'
if record_fields.get('log_level'):
log_level = record_fields.pop('log_level')
[record_fields.pop(k) for k in record_fields.keys()
if k not in self.fields]
defaults = self.defaults.copy()
fields = self.fields.copy()
fields.update(record_fields)
filtered_fields = {}
for k, v in fields.iteritems():
if v is not None:
filtered_fields[k] = v
defaults.update({
'event_timestamp': self._get_now(),
'event_name': event_name,
'log_level': log_level,
'fields': filtered_fields})
return json.dumps(defaults, default=self.json_default) |
def includeme(config):
"""
Initialize the model for a Pyramid app.
Activate this setup using ``config.include('baka_model')``.
"""
settings = config.get_settings()
should_create = asbool(settings.get('baka_model.should_create_all', False))
should_drop = asbool(settings.get('baka_model.should_drop_all', False))
# Configure the transaction manager to support retrying retryable
# exceptions. We also register the session factory with the thread-local
# transaction manager, so that all sessions it creates are registered.
# "tm.attempts": 3,
config.add_settings({
"retry.attempts": 3,
"tm.activate_hook": tm_activate_hook,
"tm.annotate_user": False,
})
# use pyramid_retry couse pyramid_tm disabled it
config.include('pyramid_retry')
# use pyramid_tm to hook the transaction lifecycle to the request
config.include('pyramid_tm')
engine = get_engine(settings)
session_factory = get_session_factory(engine)
config.registry['db_session_factory'] = session_factory
# make request.db available for use in Pyramid
config.add_request_method(
# r.tm is the transaction manager used by pyramid_tm
lambda r: get_tm_session(session_factory, r.tm),
'db',
reify=True
)
# service model factory
config.include('.service')
# Register a deferred action to bind the engine when the configuration is
# committed. Deferring the action means that this module can be included
# before model modules without ill effect.
config.action(None, bind_engine, (engine,), {
'should_create': should_create,
'should_drop': should_drop
}, order=10) |
def store( self, collection, **kwargs ):
'''
validate the passed values in kwargs based on the collection,
store them in the mongodb collection
'''
key = validate( collection, **kwargs )
if self.fetch( collection, **{ key : kwargs[key] } ):
raise Proauth2Error( 'duplicate_key' )
self.db[collection].insert( kwargs ) |
def get_abs_and_rel_paths(self, root_path, file_name, input_dir):
"""
Return absolute and relative path for file
:type root_path: str|unicode
:type file_name: str|unicode
:type input_dir: str|unicode
:rtype: tuple
"""
# todo: change relative path resolving [bug on duplicate dir names in path]
relative_dir = root_path.replace(input_dir, '')
return os.path.join(root_path, file_name), relative_dir + '/' + file_name |
def get_files(self):
"""
:inheritdoc
"""
assert self.bundle, 'Cannot fetch file name with empty bundle'
abs_path, rel_path = self.get_abs_and_rel_paths(self.bundle.path, self.file_path, self.bundle.input_dir)
file_cls = self.bundle.get_file_cls()
return [file_cls(rel_path, abs_path)] |
def get_files(self):
"""
:inheritdoc
"""
assert self.bundle, 'Cannot fetch directory name with empty bundle'
result_files = []
bundle_ext = self.bundle.get_extension()
ext = "." + bundle_ext if bundle_ext else None
if self.directory_path == "":
root_path = self.bundle.path
else:
root_path = os.path.join(self.bundle.path, self.directory_path)
for root, dirs, files in os.walk(root_path):
for fpath in files:
if (not ext or fpath.endswith(ext)) and (not self.exclusions or all(fpath != n for n in self.exclusions)):
abs_path, rel_path = self.get_abs_and_rel_paths(root, fpath, self.bundle.input_dir)
file_cls = self.bundle.get_file_cls()
result_files.append(file_cls(rel_path, abs_path))
return result_files |
def replicate_existing(source_db, target_db):
"""Replicate an existing database to another existing database."""
# Get the server from which to manage the replication.
server = shortcuts.get_server()
logger = logging.getLogger('relax.couchdb.replicate')
logger.debug('POST ' + urlparse.urljoin(server.resource.uri, '/_replicate'))
source, target = specifier_to_db(source_db), specifier_to_db(target_db)
logger.debug('Source DB: %s' % (source,))
logger.debug('Target DB: %s' % (target,))
try:
resp_headers, resp_body = server.resource.post(path='/_replicate',
content=json.dumps({'source': source, 'target': target}))
except couchdb.client.ServerError, exc:
logger.error('Replication failed.')
raise ReplicationError(exc.args)
result = resp_body['history'][0]
if resp_body['ok']:
logger.info('Replication %s... successful!' % (
resp_body['session_id'][:6],))
logger.info('Replication started: ' + result['start_time'])
logger.info('Replication finished: ' + result['end_time'])
result['start_time'] = datetime.datetime.strptime(result['start_time'],
'%a, %d %b %Y %H:%M:%S GMT')
result['end_time'] = datetime.datetime.strptime(result['end_time'],
'%a, %d %b %Y %H:%M:%S GMT')
timedelta = result['end_time'] - result['start_time']
if timedelta.days:
logger.info('Replication took %d days and %.2f seconds.' % (
timedelta.days,
timedelta.seconds + (timedelta.microseconds * (1e-6))))
else:
logger.info('Replication took %.2f seconds.' % (
timedelta.seconds + (timedelta.microseconds * (1e-6))))
# Prepare the 'result' dictionary.
result['ok'] = resp_body['ok']
result['session_id'] = resp_body['session_id']
result['source_last_seq'] = resp_body['source_last_seq']
# Info-log the number of docs read/written and checked/found.
if result['docs_read'] == 1:
docs_read = '1 document read'
else:
docs_read = '%d documents read' % (result['docs_read'],)
if result['docs_written'] == 1:
docs_written = '1 document written'
else:
docs_written = '%d documents written' % (result['docs_written'],)
if result['missing_checked'] == 1:
missing_checked = 'Checked for 1 missing document, found %d.' % (
result['missing_found'],)
else:
missing_checked = 'Checked for %d missing documents, found %d.' % (
result['missing_checked'], result['missing_found'],)
logging.info('%s, %s' % (docs_read, docs_written))
logging.info(missing_checked)
return result
else:
logger.error('Replication %s... failed.' % (
resp_body['session_id'][:6],))
result['ok'] = resp_body['ok']
result['session_id'] = resp_body['session_id']
result['source_last_seq'] = resp_body['source_last_seq']
raise ReplicationFailure(resp_headers, result) |
def mcmc_advance(start, stdevs, logp, nsteps = 1e300, adapt=True, callback=None):
"""
Generic Metropolis MCMC. Advances the chain by nsteps.
Called by :func:`mcmc`
:param adapt: enables adaptive stepwidth alteration (converges).
"""
import scipy
from numpy import log
import progressbar
prob = logp(start)
chain = [start]
accepts = [True]
probs = [prob]
assert not numpy.isnan(start).any()
assert not numpy.isnan(stdevs).any()
i = 0
widgets=['AR', progressbar.Percentage(), progressbar.Counter('%5d'),
progressbar.Bar(), progressbar.ETA()]
pbar = progressbar.ProgressBar(widgets=widgets,
maxval=nsteps).start()
prev = start
prev_prob = prob
print 'MCMC: start at prob', prob
stepchange = 0.1
while len(chain) < nsteps:
i = i + 1
next = scipy.random.normal(prev, stdevs)
next[next > 1] = 1
next[next < 0] = 0
next_prob = logp(next)
assert not numpy.isnan(next).any()
assert not numpy.isnan(next_prob).any()
delta = next_prob - prev_prob
dice = log(scipy.random.uniform(0, 1))
accept = delta > dice
if accept:
prev = next
prev_prob = next_prob
if adapt: stdevs *= (1 + stepchange)
else:
if adapt: stdevs *= (1 + stepchange)**(-0.4) # aiming for 40% acceptance
if callback: callback(prev_prob, prev, accept)
chain.append(prev)
accepts.append(accept)
probs.append(prev_prob)
if adapt: stepchange = min(0.1, 10. / i)
#print 'STDEV', stdevs[:5], stepchange
# compute stats
widgets[0] = 'AR: %.03f' % numpy.mean(numpy.array(accepts[len(accepts)/3:])+0)
pbar.update(pbar.currval + 1)
pbar.finish()
return chain, probs, accepts, stdevs |
def mcmc(transform, loglikelihood, parameter_names, nsteps=40000, nburn=400,
stdevs=0.1, start = 0.5, **problem):
"""
**Metropolis Hastings MCMC**
with automatic step width adaption.
Burnin period is also used to guess steps.
:param nburn: number of burnin steps
:param stdevs: step widths to start with
"""
if 'seed' in problem:
numpy.random.seed(problem['seed'])
n_params = len(parameter_names)
def like(cube):
cube = numpy.array(cube)
if (cube <= 1e-10).any() or (cube >= 1-1e-10).any():
return -1e100
params = transform(cube)
return loglikelihood(params)
start = start + numpy.zeros(n_params)
stdevs = stdevs + numpy.zeros(n_params)
def compute_stepwidths(chain):
return numpy.std(chain, axis=0) / 3
import matplotlib.pyplot as plt
plt.figure(figsize=(7, 7))
steps = numpy.array([0.1]*(n_params))
print 'burn-in (1/2)...'
chain, prob, _, steps_ = mcmc_advance(start, steps, like, nsteps=nburn / 2, adapt=True)
steps = compute_stepwidths(chain)
print 'burn-in (2/2)...'
chain, prob, _, steps_ = mcmc_advance(chain[-1], steps, like, nsteps=nburn / 2, adapt=True)
steps = compute_stepwidths(chain)
print 'recording chain ...'
chain, prob, _, steps_ = mcmc_advance(chain[-1], steps, like, nsteps=nsteps)
chain = numpy.array(chain)
i = numpy.argmax(prob)
final = chain[-1]
print 'postprocessing...'
chain = numpy.array([transform(params) for params in chain])
return dict(start=chain[-1], maximum=chain[i], seeds=[final, chain[i]], chain=chain, method='Metropolis MCMC') |
def ensemble(transform, loglikelihood, parameter_names, nsteps=40000, nburn=400,
start=0.5, **problem):
"""
**Ensemble MCMC**
via `emcee <http://dan.iel.fm/emcee/>`_
"""
import emcee
import progressbar
if 'seed' in problem:
numpy.random.seed(problem['seed'])
n_params = len(parameter_names)
nwalkers = 50 + n_params * 2
if nwalkers > 200:
nwalkers = 200
p0 = [numpy.random.rand(n_params) for i in xrange(nwalkers)]
start = start + numpy.zeros(n_params)
p0[0] = start
def like(cube):
cube = numpy.array(cube)
if (cube <= 1e-10).any() or (cube >= 1-1e-10).any():
return -1e100
params = transform(cube)
return loglikelihood(params)
sampler = emcee.EnsembleSampler(nwalkers, n_params, like,
live_dangerously=True)
print 'burn-in...'
pos, prob, state = sampler.run_mcmc(p0, nburn / nwalkers)
# Reset the chain to remove the burn-in samples.
sampler.reset()
print 'running ...'
# Starting from the final position in the burn-in chain, sample
pbar = progressbar.ProgressBar(
widgets=[progressbar.Percentage(), progressbar.Counter('%5d'),
progressbar.Bar(), progressbar.ETA()],
maxval=nsteps).start()
for results in sampler.sample(pos, iterations=nsteps / nwalkers, rstate0=state):
pbar.update(pbar.currval + 1)
pbar.finish()
print "Mean acceptance fraction:", numpy.mean(sampler.acceptance_fraction)
chain = sampler.flatchain
final = chain[-1]
print 'postprocessing...'
chain_post = numpy.array([transform(params) for params in chain])
chain_prob = sampler.flatlnprobability
return dict(start=final, chain=chain_post, chain_prior=chain,
chain_prob=chain_prob,
method='Ensemble MCMC') |
def _get_classes(package_name, base_class):
"""
search monits or works classes. Class must have 'name' attribute
:param package_name: 'monits' or 'works'
:param base_class: Monit or Work
:return: tuple of tuples monit/work-name and class
"""
classes = {}
base_dir = os.getcwd()
root_module_name = base_dir.split('/')[-1]
package_dir = base_dir + '/%s' % package_name
if os.path.isdir(package_dir):
for module_path in os.listdir(package_dir):
if not module_path.endswith('.py'):
continue
module_name = os.path.splitext(module_path)[0]
module_full_name = '%s.%s.%s' % (root_module_name, package_name, module_name)
__import__(module_full_name)
work_module = sys.modules[module_full_name]
for module_item in work_module.__dict__.values():
if type(module_item) is type \
and issubclass(module_item, base_class) \
and module_item is not base_class\
and hasattr(module_item, 'name') and module_item.name:
classes.setdefault(module_item.name, []).append(module_item)
# check no duplicated names
for work_name, work_modules in classes.items():
if len(work_modules) > 1:
raise DuplicatedNameException('Modules %s have same name "%s"' % (
' and '.join(map(str, work_modules)),
work_name
))
# create immutable list of modules
return tuple([(work_name, work_modules[0]) for work_name, work_modules in classes.items()]) |
def AddEnumDescriptor(self, enum_desc):
"""Adds an EnumDescriptor to the pool.
This method also registers the FileDescriptor associated with the message.
Args:
enum_desc: An EnumDescriptor.
"""
if not isinstance(enum_desc, descriptor.EnumDescriptor):
raise TypeError('Expected instance of descriptor.EnumDescriptor.')
self._enum_descriptors[enum_desc.full_name] = enum_desc
self.AddFileDescriptor(enum_desc.file) |
def FindFileContainingSymbol(self, symbol):
"""Gets the FileDescriptor for the file containing the specified symbol.
Args:
symbol: The name of the symbol to search for.
Returns:
A FileDescriptor that contains the specified symbol.
Raises:
KeyError: if the file can not be found in the pool.
"""
symbol = _NormalizeFullyQualifiedName(symbol)
try:
return self._descriptors[symbol].file
except KeyError:
pass
try:
return self._enum_descriptors[symbol].file
except KeyError:
pass
try:
file_proto = self._internal_db.FindFileContainingSymbol(symbol)
except KeyError as error:
if self._descriptor_db:
file_proto = self._descriptor_db.FindFileContainingSymbol(symbol)
else:
raise error
if not file_proto:
raise KeyError('Cannot find a file containing %s' % symbol)
return self._ConvertFileProtoToFileDescriptor(file_proto) |
def FindMessageTypeByName(self, full_name):
"""Loads the named descriptor from the pool.
Args:
full_name: The full name of the descriptor to load.
Returns:
The descriptor for the named type.
"""
full_name = _NormalizeFullyQualifiedName(full_name)
if full_name not in self._descriptors:
self.FindFileContainingSymbol(full_name)
return self._descriptors[full_name] |
def FindEnumTypeByName(self, full_name):
"""Loads the named enum descriptor from the pool.
Args:
full_name: The full name of the enum descriptor to load.
Returns:
The enum descriptor for the named type.
"""
full_name = _NormalizeFullyQualifiedName(full_name)
if full_name not in self._enum_descriptors:
self.FindFileContainingSymbol(full_name)
return self._enum_descriptors[full_name] |
def FindExtensionByName(self, full_name):
"""Loads the named extension descriptor from the pool.
Args:
full_name: The full name of the extension descriptor to load.
Returns:
A FieldDescriptor, describing the named extension.
"""
full_name = _NormalizeFullyQualifiedName(full_name)
message_name, _, extension_name = full_name.rpartition('.')
try:
# Most extensions are nested inside a message.
scope = self.FindMessageTypeByName(message_name)
except KeyError:
# Some extensions are defined at file scope.
scope = self.FindFileContainingSymbol(full_name)
return scope.extensions_by_name[extension_name] |
def _ConvertEnumDescriptor(self, enum_proto, package=None, file_desc=None,
containing_type=None, scope=None):
"""Make a protobuf EnumDescriptor given an EnumDescriptorProto protobuf.
Args:
enum_proto: The descriptor_pb2.EnumDescriptorProto protobuf message.
package: Optional package name for the new message EnumDescriptor.
file_desc: The file containing the enum descriptor.
containing_type: The type containing this enum.
scope: Scope containing available types.
Returns:
The added descriptor
"""
if package:
enum_name = '.'.join((package, enum_proto.name))
else:
enum_name = enum_proto.name
if file_desc is None:
file_name = None
else:
file_name = file_desc.name
values = [self._MakeEnumValueDescriptor(value, index)
for index, value in enumerate(enum_proto.value)]
desc = descriptor.EnumDescriptor(name=enum_proto.name,
full_name=enum_name,
filename=file_name,
file=file_desc,
values=values,
containing_type=containing_type,
options=enum_proto.options)
scope['.%s' % enum_name] = desc
self._enum_descriptors[enum_name] = desc
return desc |
def _MakeFieldDescriptor(self, field_proto, message_name, index,
is_extension=False):
"""Creates a field descriptor from a FieldDescriptorProto.
For message and enum type fields, this method will do a look up
in the pool for the appropriate descriptor for that type. If it
is unavailable, it will fall back to the _source function to
create it. If this type is still unavailable, construction will
fail.
Args:
field_proto: The proto describing the field.
message_name: The name of the containing message.
index: Index of the field
is_extension: Indication that this field is for an extension.
Returns:
An initialized FieldDescriptor object
"""
if message_name:
full_name = '.'.join((message_name, field_proto.name))
else:
full_name = field_proto.name
return descriptor.FieldDescriptor(
name=field_proto.name,
full_name=full_name,
index=index,
number=field_proto.number,
type=field_proto.type,
cpp_type=None,
message_type=None,
enum_type=None,
containing_type=None,
label=field_proto.label,
has_default_value=False,
default_value=None,
is_extension=is_extension,
extension_scope=None,
options=field_proto.options) |
def validate( table, **data ):
'''
theoretically, any data store can be implemented to work with this package,
which means basic data validation must be done in-package, so that weird
stuff can't be stored in the data store.
this function raises an exception if an invalid table name is passed, not
all of the required fields are in the data kwargs, or if a field that was
passed is not expected.
it also returns the key field name, for ensuring uniqueness (again, that may
not be built into whatever data store is impelemented.)
'''
if table not in good.keys():
raise Proauth2Error( 'invalid_request', 'invalid name: %s' % table )
for req in good[table]['required']:
if not data.get( req, None ):
raise Proauth2Error( 'invalid_request',
'missing required field: %s' % req )
for key in data.keys():
if key not in good[table]['required'] and \
key not in good[table]['optional']:
raise Proauth2Error( 'invalid_request', 'invalid field: %s' % key )
return good[table]['key'] |
def record_results(self, results):
"""
Record the results of this experiment, by updating the tag.
:param results: A dictionary containing the results of the experiment.
:type results: dict
"""
repository = Repo(self.__repository_directory, search_parent_directories=True)
for tag in repository.tags:
if tag.name == self.__tag_name:
tag_object = tag
break
else:
raise Exception("Experiment tag has been deleted since experiment started")
data = json.loads(tag_object.tag.message)
data["results"] = results
TagReference.create(repository, self.__tag_name, message=json.dumps(data),
ref=tag_object.tag.object, force=True)
self.__results_recorded = True |
def __tag_repo(self, data, repository):
"""
Tag the current repository.
:param data: a dictionary containing the data about the experiment
:type data: dict
"""
assert self.__tag_name not in [t.name for t in repository.tags]
return TagReference.create(repository, self.__tag_name, message=json.dumps(data)) |
def __get_files_to_be_added(self, repository):
"""
:return: the files that have been modified and can be added
"""
for root, dirs, files in os.walk(repository.working_dir):
for f in files:
relative_path = os.path.join(root, f)[len(repository.working_dir) + 1:]
try:
repository.head.commit.tree[relative_path] # will fail if not tracked
yield relative_path
except:
pass |
def __start_experiment(self, parameters):
"""
Start an experiment by capturing the state of the code
:param parameters: a dictionary containing the parameters of the experiment
:type parameters: dict
:return: the tag representing this experiment
:rtype: TagReference
"""
repository = Repo(self.__repository_directory, search_parent_directories=True)
if len(repository.untracked_files) > 0:
logging.warning("Untracked files will not be recorded: %s", repository.untracked_files)
current_commit = repository.head.commit
started_state_is_dirty = repository.is_dirty()
if started_state_is_dirty:
repository.index.add([p for p in self.__get_files_to_be_added(repository)])
commit_obj = repository.index.commit("Temporary commit for experiment " + self.__experiment_name)
sha = commit_obj.hexsha
else:
sha = repository.head.object.hexsha
data = {"parameters": parameters, "started": time.time(), "description": self.__description,
"commit_sha": sha}
tag_object = self.__tag_repo(data, repository)
if started_state_is_dirty:
repository.head.reset(current_commit, working_tree=False, index=True)
return tag_object |
def get_tm_session(session_factory, transaction_manager):
"""
Get a ``sqlalchemy.orm.Session`` instance backed by a transaction.
This function will hook the session to the transaction manager which
will take care of committing any changes.
- When using pyramid_tm it will automatically be committed or aborted
depending on whether an exception is raised.
- When using scripts you should wrap the session in a manager yourself.
For example::
import transaction
engine = get_engine(settings)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
"""
dbsession = session_factory()
zope.sqlalchemy.register(
dbsession, transaction_manager=transaction_manager)
return dbsession |
def run(self):
"""run your main spider here, and get a list/tuple of url as result
then make the instance of branch thread
:return: None
"""
global existed_urls_list
config = config_creator()
debug = config.debug
main_thread_sleep = config.main_thread_sleep
branch_thread_num = config.branch_thread_num
while 1:
url = self.main_queue.get()
if debug:
print('main thread-{} start'.format(url))
main_spider = self.main_spider(url)
sleep(random.randrange(*main_thread_sleep))
links = main_spider.request_urls()
try:
assert type(links) in VALIDATE_URLS
except AssertionError:
error_message('except to return a list or tuple which contains url')
links = list()
branch_queue = queue.Queue(branch_thread_num)
for i in range(branch_thread_num):
branch_thread = BranchThread(branch_queue=branch_queue,
branch_spider=self.branch_spider)
branch_thread.daemon = True
branch_thread.start()
for link in links:
if link not in existed_urls_list:
existed_urls_list.append(link)
branch_queue.put(link)
branch_queue.join()
if debug:
print('main thread-{}\'s child threads is all finish'.format(url))
self.main_queue.task_done() |
def pypi_render(source):
"""
Copied (and slightly adapted) from pypi.description_tools
"""
ALLOWED_SCHEMES = '''file ftp gopher hdl http https imap mailto mms news
nntp prospero rsync rtsp rtspu sftp shttp sip sips snews svn svn+ssh
telnet wais irc'''.split()
settings_overrides = {
"raw_enabled": 0, # no raw HTML code
"file_insertion_enabled": 0, # no file/URL access
"halt_level": 2, # at warnings or errors, raise an exception
"report_level": 5, # never report problems with the reST code
}
# capture publishing errors, they go to stderr
old_stderr = sys.stderr
sys.stderr = s = StringIO.StringIO()
parts = None
try:
# Convert reStructuredText to HTML using Docutils.
document = publish_doctree(source=source,
settings_overrides=settings_overrides)
for node in document.traverse():
if node.tagname == '#text':
continue
if node.hasattr('refuri'):
uri = node['refuri']
elif node.hasattr('uri'):
uri = node['uri']
else:
continue
o = urlparse.urlparse(uri)
if o.scheme not in ALLOWED_SCHEMES:
raise TransformError('link scheme not allowed')
# now turn the transformed document into HTML
reader = readers.doctree.Reader(parser_name='null')
pub = Publisher(reader, source=io.DocTreeInput(document),
destination_class=io.StringOutput)
pub.set_writer('html')
pub.process_programmatic_settings(None, settings_overrides, None)
pub.set_destination(None, None)
pub.publish()
parts = pub.writer.parts
except:
pass
sys.stderr = old_stderr
# original text if publishing errors occur
if parts is None or len(s.getvalue()) > 0:
return None
else:
return parts['body'] |
def generate(length=DEFAULT_LENGTH):
"""
Generate a random string of the specified length.
The returned string is composed of an alphabet that shouldn't include any
characters that are easily mistakeable for one another (I, 1, O, 0), and
hopefully won't accidentally contain any English-language curse words.
"""
return ''.join(random.SystemRandom().choice(ALPHABET)
for _ in range(length)) |
def require(name, field, data_type):
"""Require that the named `field` has the right `data_type`"""
if not isinstance(field, data_type):
msg = '{0} must have {1}, got: {2}'.format(name, data_type, field)
raise AssertionError(msg) |
def _enqueue(self, msg):
"""Push a new `msg` onto the queue, return `(success, msg)`"""
self.log.debug('queueing: %s', msg)
if self.queue.full():
self.log.warn('librato_bg queue is full')
return False, msg
self.queue.put(msg)
self.log.debug('enqueued %s.', msg)
return True, msg |
def flush(self):
"""Forces a flush from the internal queue to the server"""
queue = self.queue
size = queue.qsize()
queue.join()
self.log.debug('successfully flushed %s items.', size) |
def open(name=None, fileobj=None, closefd=True):
"""
Use all decompressor possible to make the stream
"""
return Guesser().open(name=name, fileobj=fileobj, closefd=closefd) |
def marv(ctx, config, loglevel, logfilter, verbosity):
"""Manage a Marv site"""
if config is None:
cwd = os.path.abspath(os.path.curdir)
while cwd != os.path.sep:
config = os.path.join(cwd, 'marv.conf')
if os.path.exists(config):
break
cwd = os.path.dirname(cwd)
else:
config = '/etc/marv/marv.conf'
if not os.path.exists(config):
config = None
ctx.obj = config
setup_logging(loglevel, verbosity, logfilter) |
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.include('cms')
config.configure_celery(global_config['__file__'])
return config.make_wsgi_app() |
def _SignedVarintDecoder(mask, result_type):
"""Like _VarintDecoder() but decodes signed values."""
def DecodeVarint(buffer, pos):
result = 0
shift = 0
while 1:
b = six.indexbytes(buffer, pos)
result |= ((b & 0x7f) << shift)
pos += 1
if not (b & 0x80):
if result > 0x7fffffffffffffff:
result -= (1 << 64)
result |= ~mask
else:
result &= mask
result = result_type(result)
return (result, pos)
shift += 7
if shift >= 64:
raise _DecodeError('Too many bytes when decoding varint.')
return DecodeVarint |
def MessageSetItemDecoder(extensions_by_number):
"""Returns a decoder for a MessageSet item.
The parameter is the _extensions_by_number map for the message class.
The message set message looks like this:
message MessageSet {
repeated group Item = 1 {
required int32 type_id = 2;
required string message = 3;
}
}
"""
type_id_tag_bytes = encoder.TagBytes(2, wire_format.WIRETYPE_VARINT)
message_tag_bytes = encoder.TagBytes(3, wire_format.WIRETYPE_LENGTH_DELIMITED)
item_end_tag_bytes = encoder.TagBytes(1, wire_format.WIRETYPE_END_GROUP)
local_ReadTag = ReadTag
local_DecodeVarint = _DecodeVarint
local_SkipField = SkipField
def DecodeItem(buffer, pos, end, message, field_dict):
message_set_item_start = pos
type_id = -1
message_start = -1
message_end = -1
# Technically, type_id and message can appear in any order, so we need
# a little loop here.
while 1:
(tag_bytes, pos) = local_ReadTag(buffer, pos)
if tag_bytes == type_id_tag_bytes:
(type_id, pos) = local_DecodeVarint(buffer, pos)
elif tag_bytes == message_tag_bytes:
(size, message_start) = local_DecodeVarint(buffer, pos)
pos = message_end = message_start + size
elif tag_bytes == item_end_tag_bytes:
break
else:
pos = SkipField(buffer, pos, end, tag_bytes)
if pos == -1:
raise _DecodeError('Missing group end tag.')
if pos > end:
raise _DecodeError('Truncated message.')
if type_id == -1:
raise _DecodeError('MessageSet item missing type_id.')
if message_start == -1:
raise _DecodeError('MessageSet item missing message.')
extension = extensions_by_number.get(type_id)
if extension is not None:
value = field_dict.get(extension)
if value is None:
value = field_dict.setdefault(
extension, extension.message_type._concrete_class())
if value._InternalParse(buffer, message_start,message_end) != message_end:
# The only reason _InternalParse would return early is if it encountered
# an end-group tag.
raise _DecodeError('Unexpected end-group tag.')
else:
if not message._unknown_fields:
message._unknown_fields = []
message._unknown_fields.append((MESSAGE_SET_ITEM_TAG,
buffer[message_set_item_start:pos]))
return pos
return DecodeItem |
def get_app_name():
"""Flask like implementation of getting the applicaiton name via
the filename of the including file
"""
fn = getattr(sys.modules['__main__'], '__file__', None)
if fn is None:
return '__main__'
return os.path.splitext(os.path.basename(fn))[0] |
def get_function(function_name):
"""
Given a Python function name, return the function it refers to.
"""
module, basename = str(function_name).rsplit('.', 1)
try:
return getattr(__import__(module, fromlist=[basename]), basename)
except (ImportError, AttributeError):
raise FunctionNotFound(function_name) |
def handle_add_fun(self, function_name):
"""Add a function to the function list, in order."""
function_name = function_name.strip()
try:
function = get_function(function_name)
except Exception, exc:
self.wfile.write(js_error(exc) + NEWLINE)
return
# This tests to see if the function has been decorated with the view
# server synchronisation decorator (``decorate_view``).
if not getattr(function, 'view_decorated', None):
self.functions[function_name] = (self.function_counter, function)
# The decorator gets called with the logger function.
else:
self.functions[function_name] = (self.function_counter,
function(self.log))
self.function_counter += 1
return True |
def handle_map_doc(self, document):
"""Return the mapping of a document according to the function list."""
# This uses the stored set of functions, sorted by order of addition.
for function in sorted(self.functions.values(), key=lambda x: x[0]):
try:
# It has to be run through ``list``, because it may be a
# generator function.
yield [list(function(document))]
except Exception, exc:
# Otherwise, return an empty list and log the event.
yield []
self.log(repr(exc)) |
def handle_reduce(self, reduce_function_names, mapped_docs):
"""Reduce several mapped documents by several reduction functions."""
reduce_functions = []
# This gets a large list of reduction functions, given their names.
for reduce_function_name in reduce_function_names:
try:
reduce_function = get_function(reduce_function_name)
if getattr(reduce_function, 'view_decorated', None):
reduce_function = reduce_function(self.log)
reduce_functions.append(reduce_function)
except Exception, exc:
self.log(repr(exc))
reduce_functions.append(lambda *args, **kwargs: None)
# Transform lots of (key, value) pairs into one (keys, values) pair.
keys, values = zip(
(key, value) for ((key, doc_id), value) in mapped_docs)
# This gets the list of results from the reduction functions.
results = []
for reduce_function in reduce_functions:
try:
results.append(reduce_function(keys, values, rereduce=False))
except Exception, exc:
self.log(repr(exc))
results.append(None)
return [True, results] |
def handle_rereduce(self, reduce_function_names, values):
"""Re-reduce a set of values, with a list of rereduction functions."""
# This gets a large list of reduction functions, given their names.
reduce_functions = []
for reduce_function_name in reduce_function_names:
try:
reduce_function = get_function(reduce_function_name)
if getattr(reduce_function, 'view_decorated', None):
reduce_function = reduce_function(self.log)
reduce_functions.append(reduce_function)
except Exception, exc:
self.log(repr(exc))
reduce_functions.append(lambda *args, **kwargs: None)
# This gets the list of results from those functions.
results = []
for reduce_function in reduce_functions:
try:
results.append(reduce_function(None, values, rereduce=True))
except Exception, exc:
self.log(repr(exc))
results.append(None)
return [True, results] |
def handle_validate(self, function_name, new_doc, old_doc, user_ctx):
"""Validate...this function is undocumented, but still in CouchDB."""
try:
function = get_function(function_name)
except Exception, exc:
self.log(repr(exc))
return False
try:
return function(new_doc, old_doc, user_ctx)
except Exception, exc:
self.log(repr(exc))
return repr(exc) |
def handle(self):
"""The main function called to handle a request."""
while True:
try:
line = self.rfile.readline()
try:
# All input data are lines of JSON like the following:
# ["<cmd_name>" "<cmd_arg1>" "<cmd_arg2>" ...]
# So I handle this by dispatching to various methods.
cmd = json.loads(line)
except Exception, exc:
# Sometimes errors come up. Once again, I can't predict
# anything, but can at least tell CouchDB about the error.
self.wfile.write(repr(exc) + NEWLINE)
continue
else:
# Automagically get the command handler.
handler = getattr(self, 'handle_' + cmd[0], None)
if not handler:
# We are ready to not find commands. It probably won't
# happen, but fortune favours the prepared.
self.wfile.write(
repr(CommandNotFound(cmd[0])) + NEWLINE)
continue
return_value = handler(*cmd[1:])
if not return_value:
continue
# We write the output back to CouchDB.
self.wfile.write(
one_lineify(json.dumps(return_value)) + NEWLINE)
except Exception, exc:
self.wfile.write(repr(exc) + NEWLINE)
continue |
def log(self, string):
"""Log an event on the CouchDB server."""
self.wfile.write(json.dumps({'log': string}) + NEWLINE) |
def guid(*args):
"""
Generates a universally unique ID.
Any arguments only create more randomness.
"""
t = float(time.time() * 1000)
r = float(random.random()*10000000000000)
a = random.random() * 10000000000000
data = str(t) + ' ' + str(r) + ' ' + str(a) + ' ' + str(args)
data = hashlib.md5(data.encode()).hexdigest()[:10]
return data |
def get_pages(self, limit=5, order_by=('position', '-modified_at')):
"""
Return pages the GitModel knows about.
:param int limit:
The number of pages to return, defaults to 5.
:param tuple order_by:
The attributes to order on,
defaults to ('position', '-modified_at')
"""
return to_eg_objects(self.workspace.S(Page).filter(
language=self.locale).order_by(*order_by)[:limit]) |
def get_featured_pages(
self, limit=5, order_by=('position', '-modified_at')):
"""
Return featured pages the GitModel knows about.
:param str locale:
The locale string, like `eng_UK`.
:param int limit:
The number of pages to return, defaults to 5.
:param tuple order_by:
The attributes to order on,
defaults to ('position', '-modified_at').
"""
return self._get_featured_pages(self.locale, limit, order_by) |
def register_app(self, name, redirect_uri, callback):
'''
register_app takes an application name and redirect_uri
It generates client_id (client_key) and client_secret,
then stores all of the above in the data_store,
and returns a dictionary containing the client_id and client_secret.
'''
client_id = self._generate_token()
client_secret = self._generate_token(64)
yield Task(self.data_store.store, 'applications', client_id=client_id,
client_secret=client_secret, name=name,
redirect_uri=redirect_uri)
callback({'client_id':client_id, 'client_secret':client_secret}) |
def request_authorization(self, client_id, user_id, response_type,
redirect_uri=None, scope=None, state=None,
expires=600, callback=None):
'''
request_authorization generates a nonce, and stores it in the data_store along with the
client_id, user_id, and expiration timestamp.
It then returns a dictionary containing the nonce as "code," and the passed
state.
---
response_type MUST be "code." this is directly from the OAuth2 spec.
this probably doesn't need to be checked here, but if it's in the spec I
guess it should be verified somewhere.
scope has not been implemented here. it will be stored, but there is no
scope-checking built in here at this time.
if a redirect_uri is passed, it must match the registered redirect_uri.
again, this is per spec.
'''
if response_type != 'code':
raise Proauth2Error('invalid_request',
'response_type must be "code"', state=state)
client = yield Task(self.data_store.fetch, 'applications',
client_id=client_id)
if not client: raise Proauth2Error('access_denied')
if redirect_uri and client['redirect_uri'] != redirect_uri:
raise Proauth2Error('invalid_request', "redirect_uris don't match")
nonce_code = self._generate_token()
expires = time() + expires
try:
yield Task(self.data_store.store, 'nonce_codes', code=nonce_code,
client_id=client_id, expires=expires, user_id=user_id,
scope=scope)
except Proauth2Error as e:
e.state = state
raise e
callback({'code':nonce_code, 'state':state}) |
def request_access_token(self, client_id, key, code, grant_type,
redirect_uri=None, method='direct_auth',
callback=None):
'''
request_access_token validates the client_id and client_secret, using the
provided method, then generates an access_token, stores it with the user_id
from the nonce, and returns a dictionary containing an access_token and
bearer token.
---
from the spec, it looks like there are different types of
tokens, but i don't understand the disctintions, so someone else can fix
this if need be.
regarding the method: it appears that it is intended for there to be
multiple ways to verify the client_id. my assumption is that you use the
secret as the salt and pass the hashed of the client_id or something, and
then compare hashes on the server end. currently the only implemented method
is direct comparison of the client_ids and client_secrets.
additional methods can be added to proauth2.auth_methods
'''
if grant_type != 'authorization_code':
raise Proauth2Error('invalid_request',
'grant_type must be "authorization_code"')
yield Task(self._auth, client_id, key, method)
user_id = yield Task(self._validate_request_code, code, client_id)
access_token = self._generate_token(64)
yield Task(self.data_store.store, 'tokens', token=access_token,
user_id=user_id, client_id=client_id)
callback({'access_token':access_token, 'token_type':'bearer'}) |
def authenticate_token(self, token, callback):
'''
authenticate_token checks the passed token and returns the user_id it is
associated with. it is assumed that this method won't be directly exposed to
the oauth client, but some kind of framework or wrapper. this allows the
framework to have the user_id without doing additional DB calls.
'''
token_data = yield Task(self.data_store.fetch, 'tokens', token=token)
if not token_data:
raise Proauth2Error('access_denied',
'token does not exist or has been revoked')
callback(token_data['user_id']) |
def revoke_token(self, token, callback):
'''
revoke_token removes the access token from the data_store
'''
yield Task(self.data_store.remove, 'tokens', token=token)
callback() |
def _auth(self, client_id, key, method, callback):
'''
_auth - internal method to ensure the client_id and client_secret passed with
the nonce match
'''
available = auth_methods.keys()
if method not in available:
raise Proauth2Error('invalid_request',
'unsupported authentication method: %s'
'available methods: %s' % \
(method, '\n'.join(available)))
client = yield Task(self.data_store.fetch, 'applications',
client_id=client_id)
if not client: raise Proauth2Error('access_denied')
if not auth_methods[method](key, client['client_secret']):
raise Proauth2Error('access_denied')
callback() |
def _validate_request_code(self, code, client_id, callback):
'''
_validate_request_code - internal method for verifying the the given nonce.
also removes the nonce from the data_store, as they are intended for
one-time use.
'''
nonce = yield Task(self.data_store.fetch, 'nonce_codes', code=code)
if not nonce:
raise Proauth2Error('access_denied', 'invalid request code: %s' % code)
if client_id != nonce['client_id']:
raise Proauth2Error('access_denied', 'invalid request code: %s' % code)
user_id = nonce['user_id']
expires = nonce['expires']
yield Task(self.data_store.remove, 'nonce_codes', code=code,
client_id=client_id, user_id=user_id)
if time() > expires:
raise Proauth2Error('access_denied', 'request code %s expired' % code)
callback(user_id) |
def _generate_token(self, length=32):
'''
_generate_token - internal function for generating randomized alphanumberic
strings of a given length
'''
return ''.join(choice(ascii_letters + digits) for x in range(length)) |
def merge_ordered(ordereds: typing.Iterable[typing.Any]) -> typing.Iterable[typing.Any]:
"""Merge multiple ordered so that within-ordered order is preserved
"""
seen_set = set()
add_seen = seen_set.add
return reversed(tuple(map(
lambda obj: add_seen(obj) or obj,
filterfalse(
seen_set.__contains__,
chain.from_iterable(map(reversed, reversed(ordereds))),
),
))) |
def validate_params(required, optional, params):
"""
Helps us validate the parameters for the request
:param valid_options: a list of strings of valid options for the
api request
:param params: a dict, the key-value store which we really only care about
the key which has tells us what the user is using for the
API request
:returns: None or throws an exception if the validation fails
"""
missing_fields = [x for x in required if x not in params]
if missing_fields:
field_strings = ", ".join(missing_fields)
raise Exception("Missing fields: %s" % field_strings)
disallowed_fields = [x for x in params if x not in optional and x not in required]
if disallowed_fields:
field_strings = ", ".join(disallowed_fields)
raise Exception("Disallowed fields: %s" % field_strings) |
def authenticate_token( self, token ):
'''
authenticate_token checks the passed token and returns the user_id it is
associated with. it is assumed that this method won't be directly exposed to
the oauth client, but some kind of framework or wrapper. this allows the
framework to have the user_id without doing additional DB calls.
'''
token_data = self.data_store.fetch( 'tokens', token=token )
if not token_data:
raise Proauth2Error( 'access_denied',
'token does not exist or has been revoked' )
return token_data['user_id'] |
def main():
"""Register your own mode and handle method here."""
plugin = Register()
if plugin.args.option == 'filenumber':
plugin.filenumber_handle()
elif plugin.args.option == 'fileage':
plugin.fileage_handle()
elif plugin.args.option == 'sqlserverlocks':
plugin.sqlserverlocks_handle()
else:
plugin.unknown("Unknown actions.") |
def filenumber_handle(self):
"""Get the number of file in the folder."""
self.file_list = []
self.count = 0
status = self.ok
if self.args.recursion:
self.__result, self.__file_list = self.__get_folder(self.args.path)
else:
self.__result, self.__file_list = self.__get_file(self.args.path)
# Compare the vlaue.
if self.__result > self.args.critical:
status = self.critical
elif self.__result > self.args.warning:
status = self.warning
else:
status = self.ok
# Output
self.shortoutput = "Found {0} files in {1}.".format(self.__result,
self.args.path)
self.logger.debug("file_list: {}".format(self.__file_list))
[self.longoutput.append(file_data.get('Name'))
for file_data in self.__file_list]
self.perfdata.append("{path}={result};{warn};{crit};0;".format(
crit=self.args.critical,
warn=self.args.warning,
result=self.__result,
path=self.args.path))
# Return status with message to Nagios.
status(self.output(long_output_limit=None))
self.logger.debug("Return status and exit to Nagios.") |
def __get_current_datetime(self):
"""Get current datetime for every file."""
self.wql_time = "SELECT LocalDateTime FROM Win32_OperatingSystem"
self.current_time = self.query(self.wql_time)
# [{'LocalDateTime': '20160824161431.977000+480'}]'
self.current_time_string = str(
self.current_time[0].get('LocalDateTime').split('.')[0])
# '20160824161431'
self.current_time_format = datetime.datetime.strptime(
self.current_time_string, '%Y%m%d%H%M%S')
# param: datetime.datetime(2016, 8, 24, 16, 14, 31) -> type:
# datetime.datetime
return self.current_time_format |
def fileage_handle(self):
"""Get the number of file in the folder."""
self.file_list = []
self.ok_file = []
self.warn_file = []
self.crit_file = []
status = self.ok
if self.args.recursion:
self.__file_list = self.__get_folder(self.args.path)
else:
self.__file_list = self.__get_file(self.args.path)
self.logger.debug("file_list: {}".format(self.__file_list))
# [{'LastModified': '20160824142017.737101+480', 'Name': 'd:\\test\\1.txt'},
# {'LastModified': '20160824142021.392101+480', 'Name': 'd:\\test\\2.txt'},
# {'LastModified': '20160824142106.460101+480', 'Name': 'd:\\test\\test1\\21.txt'}]
for file_dict in self.__file_list:
self.filename = file_dict.get('Name')
if self.filename and self.filename != 'Name':
self.logger.debug(
"===== start to compare {} =====".format(
self.filename))
self.file_datetime_string = file_dict.get(
'LastModified').split('.')[0]
self.file_datetime = datetime.datetime.strptime(
self.file_datetime_string, '%Y%m%d%H%M%S')
self.logger.debug(
"file_datetime: {}".format(
self.file_datetime))
self.current_datetime = self.__get_current_datetime()
self.logger.debug(
"current_datetime: {}".format(
self.current_datetime))
self.__delta_datetime = self.current_datetime - self.file_datetime
self.logger.debug(
"delta_datetime: {}".format(
self.__delta_datetime))
self.logger.debug(
"warn_datetime: {}".format(
datetime.timedelta(
minutes=self.args.warning)))
self.logger.debug(
"crit_datetime: {}".format(
datetime.timedelta(
minutes=self.args.critical)))
if self.__delta_datetime > datetime.timedelta(
minutes=self.args.critical):
self.crit_file.append(self.filename)
elif self.__delta_datetime > datetime.timedelta(minutes=self.args.warning):
self.warn_file.append(self.filename)
else:
self.ok_file.append(self.filename)
# Compare the vlaue.
if self.crit_file:
status = self.critical
elif self.warn_file:
status = self.warning
else:
status = self.ok
# Output
self.shortoutput = "Found {0} files out of date.".format(
len(self.crit_file))
if self.crit_file:
self.longoutput.append("===== Critical File out of date ====")
[self.longoutput.append(filename)
for filename in self.crit_file if self.crit_file]
if self.warn_file:
self.longoutput.append("===== Warning File out of date ====")
[self.longoutput.append(filename)
for filename in self.warn_file if self.warn_file]
if self.ok_file:
self.longoutput.append("===== OK File out of date ====")
[self.longoutput.append(filename)
for filename in self.ok_file if self.ok_file]
self.perfdata.append("{path}={result};{warn};{crit};0;".format(
crit=self.args.critical,
warn=self.args.warning,
result=len(self.crit_file),
path=self.args.drive + self.args.path))
# Return status with message to Nagios.
status(self.output(long_output_limit=None))
self.logger.debug("Return status and exit to Nagios.") |
def run(self):
"""run your main spider here
as for branch spider result data, you can return everything or do whatever with it
in your own code
:return: None
"""
config = config_creator()
debug = config.debug
branch_thread_sleep = config.branch_thread_sleep
while 1:
url = self.branch_queue.get()
if debug:
print('branch thread-{} start'.format(url))
branch_spider = self.branch_spider(url)
sleep(random.randrange(*branch_thread_sleep))
branch_spider.request_page()
if debug:
print('branch thread-{} end'.format(url))
self.branch_queue.task_done() |
def get_version(relpath):
"""Read version info from a file without importing it"""
from os.path import dirname, join
if '__file__' not in globals():
# Allow to use function interactively
root = '.'
else:
root = dirname(__file__)
# The code below reads text file with unknown encoding in
# in Python2/3 compatible way. Reading this text file
# without specifying encoding will fail in Python 3 on some
# systems (see http://goo.gl/5XmOH). Specifying encoding as
# open() parameter is incompatible with Python 2
# cp437 is the encoding without missing points, safe against:
# UnicodeDecodeError: 'charmap' codec can't decode byte...
for line in open(join(root, relpath), 'rb'):
line = line.decode('cp437')
if '__version__' in line:
if '"' in line:
# __version__ = "0.9"
return line.split('"')[1]
elif "'" in line:
return line.split("'")[1] |
def MakeDescriptor(desc_proto, package='', build_file_if_cpp=True,
syntax=None):
"""Make a protobuf Descriptor given a DescriptorProto protobuf.
Handles nested descriptors. Note that this is limited to the scope of defining
a message inside of another message. Composite fields can currently only be
resolved if the message is defined in the same scope as the field.
Args:
desc_proto: The descriptor_pb2.DescriptorProto protobuf message.
package: Optional package name for the new message Descriptor (string).
build_file_if_cpp: Update the C++ descriptor pool if api matches.
Set to False on recursion, so no duplicates are created.
syntax: The syntax/semantics that should be used. Set to "proto3" to get
proto3 field presence semantics.
Returns:
A Descriptor for protobuf messages.
"""
if api_implementation.Type() == 'cpp' and build_file_if_cpp:
# The C++ implementation requires all descriptors to be backed by the same
# definition in the C++ descriptor pool. To do this, we build a
# FileDescriptorProto with the same definition as this descriptor and build
# it into the pool.
from typy.google.protobuf import descriptor_pb2
file_descriptor_proto = descriptor_pb2.FileDescriptorProto()
file_descriptor_proto.message_type.add().MergeFrom(desc_proto)
# Generate a random name for this proto file to prevent conflicts with any
# imported ones. We need to specify a file name so the descriptor pool
# accepts our FileDescriptorProto, but it is not important what that file
# name is actually set to.
proto_name = str(uuid.uuid4())
if package:
file_descriptor_proto.name = os.path.join(package.replace('.', '/'),
proto_name + '.proto')
file_descriptor_proto.package = package
else:
file_descriptor_proto.name = proto_name + '.proto'
_message.default_pool.Add(file_descriptor_proto)
result = _message.default_pool.FindFileByName(file_descriptor_proto.name)
if _USE_C_DESCRIPTORS:
return result.message_types_by_name[desc_proto.name]
full_message_name = [desc_proto.name]
if package: full_message_name.insert(0, package)
# Create Descriptors for enum types
enum_types = {}
for enum_proto in desc_proto.enum_type:
full_name = '.'.join(full_message_name + [enum_proto.name])
enum_desc = EnumDescriptor(
enum_proto.name, full_name, None, [
EnumValueDescriptor(enum_val.name, ii, enum_val.number)
for ii, enum_val in enumerate(enum_proto.value)])
enum_types[full_name] = enum_desc
# Create Descriptors for nested types
nested_types = {}
for nested_proto in desc_proto.nested_type:
full_name = '.'.join(full_message_name + [nested_proto.name])
# Nested types are just those defined inside of the message, not all types
# used by fields in the message, so no loops are possible here.
nested_desc = MakeDescriptor(nested_proto,
package='.'.join(full_message_name),
build_file_if_cpp=False,
syntax=syntax)
nested_types[full_name] = nested_desc
fields = []
for field_proto in desc_proto.field:
full_name = '.'.join(full_message_name + [field_proto.name])
enum_desc = None
nested_desc = None
if field_proto.HasField('type_name'):
type_name = field_proto.type_name
full_type_name = '.'.join(full_message_name +
[type_name[type_name.rfind('.')+1:]])
if full_type_name in nested_types:
nested_desc = nested_types[full_type_name]
elif full_type_name in enum_types:
enum_desc = enum_types[full_type_name]
# Else type_name references a non-local type, which isn't implemented
field = FieldDescriptor(
field_proto.name, full_name, field_proto.number - 1,
field_proto.number, field_proto.type,
FieldDescriptor.ProtoTypeToCppProtoType(field_proto.type),
field_proto.label, None, nested_desc, enum_desc, None, False, None,
options=field_proto.options, has_default_value=False)
fields.append(field)
desc_name = '.'.join(full_message_name)
return Descriptor(desc_proto.name, desc_name, None, None, fields,
list(nested_types.values()), list(enum_types.values()), [],
options=desc_proto.options) |
def GetTopLevelContainingType(self):
"""Returns the root if this is a nested type, or itself if its the root."""
desc = self
while desc.containing_type is not None:
desc = desc.containing_type
return desc |
def FindMethodByName(self, name):
"""Searches for the specified method, and returns its descriptor."""
for method in self.methods:
if name == method.name:
return method
return None |
def main():
"""Register your own mode and handle method here."""
plugin = Register()
if plugin.args.option == 'sqlserverlocks':
plugin.sqlserverlocks_handle()
else:
plugin.unknown("Unknown actions.") |
def MessageToJson(message, including_default_value_fields=False):
"""Converts protobuf message to JSON format.
Args:
message: The protocol buffers message instance to serialize.
including_default_value_fields: If True, singular primitive fields,
repeated fields, and map fields will always be serialized. If
False, only serialize non-empty fields. Singular message fields
and oneof fields are not affected by this option.
Returns:
A string containing the JSON formatted protocol buffer message.
"""
js = _MessageToJsonObject(message, including_default_value_fields)
return json.dumps(js, indent=2) |
def _MessageToJsonObject(message, including_default_value_fields):
"""Converts message to an object according to Proto3 JSON Specification."""
message_descriptor = message.DESCRIPTOR
full_name = message_descriptor.full_name
if _IsWrapperMessage(message_descriptor):
return _WrapperMessageToJsonObject(message)
if full_name in _WKTJSONMETHODS:
return _WKTJSONMETHODS[full_name][0](
message, including_default_value_fields)
js = {}
return _RegularMessageToJsonObject(
message, js, including_default_value_fields) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.