Unnamed: 0
int64 0
10k
| function
stringlengths 79
138k
| label
stringclasses 20
values | info
stringlengths 42
261
|
|---|---|---|---|
0 | def run(self):
"""
Called when the process intializes.
"""
logger.info('started worker')
FULL_NAMESPACE = settings.FULL_NAMESPACE
MINI_NAMESPACE = settings.MINI_NAMESPACE
MAX_RESOLUTION = settings.MAX_RESOLUTION
full_uniques = FULL_NAMESPACE + 'unique_metrics'
mini_uniques = MINI_NAMESPACE + 'unique_metrics'
pipe = self.redis_conn.pipeline()
while 1:
# Make sure Redis is up
try:
self.redis_conn.ping()
except:
logger.error('worker can\'t connect to redis at socket path %s' % settings.REDIS_SOCKET_PATH)
sleep(10)
self.redis_conn = StrictRedis(unix_socket_path = settings.REDIS_SOCKET_PATH)
pipe = self.redis_conn.pipeline()
continue
try:
# Get a chunk from the queue with a 15 second timeout
chunk = self.q.get(True, 15)
now = time()
for metric in chunk:
# Check if we should skip it
if self.in_skip_list(metric[0]):
continue
# Bad data coming in
if metric[1][0] < now - MAX_RESOLUTION:
continue
# Append to messagepack main namespace
key = ''.join((FULL_NAMESPACE, metric[0]))
pipe.append(key, packb(metric[1]))
pipe.sadd(full_uniques, key)
if not self.skip_mini:
# Append to mini namespace
mini_key = ''.join((MINI_NAMESPACE, metric[0]))
pipe.append(mini_key, packb(metric[1]))
pipe.sadd(mini_uniques, mini_key)
pipe.execute()
# Log progress
if self.canary:
logger.info('queue size at %d' % self.q.qsize())
self.send_graphite_metric('skyline.horizon.queue_size', self.q.qsize())
except Empty:
logger.info('worker queue is empty and timed out')
except WatchError:
logger.error(key)
except __HOLE__:
pass
except Exception as e:
logger.error("worker error: " + str(e)) | NotImplementedError | dataset/ETHPy150Open etsy/skyline/src/horizon/worker.py/Worker.run |
1 | def create_entropies(vmx, m):
try:
default_signature = vmx.get_method_signature(m, predef_sign = DEFAULT_SIGNATURE).get_string()
l = [ default_signature,
entropy( vmx.get_method_signature(m, "L4", { "L4" : { "arguments" : ["Landroid"] } } ).get_string() ),
entropy( vmx.get_method_signature(m, "L4", { "L4" : { "arguments" : ["Ljava"] } } ).get_string() ),
entropy( vmx.get_method_signature(m, "hex" ).get_string() ),
entropy( vmx.get_method_signature(m, "L2" ).get_string() ),
]
return l
except __HOLE__:
return [ "", 0.0, 0.0, 0.0, 0.0 ] | KeyError | dataset/ETHPy150Open androguard/androguard/androguard/core/data/data.py/create_entropies |
2 | def new_id(self, i, l):
try:
return l[i]
except __HOLE__:
l[i] = len(l)
return l[i] | KeyError | dataset/ETHPy150Open androguard/androguard/androguard/core/data/data.py/DexViewer.new_id |
3 | @property
def storage_path(self):
try:
conan_user_home = os.getenv("CONAN_USER_HOME")
if conan_user_home:
storage = self.storage["path"]
if storage[:2] == "~/":
storage = storage[2:]
result = os.path.join(conan_user_home, storage)
else:
result = os.path.expanduser(self.storage["path"])
except __HOLE__:
result = None
result = get_env('CONAN_STORAGE_PATH', result)
return result | KeyError | dataset/ETHPy150Open conan-io/conan/conans/client/conf/__init__.py/ConanClientConfigParser.storage_path |
4 | def run_tests(tests, test_input, timeout = 60, waittime = 0.1):
"""
Runs all the tests given by directly executing them. If they return
with a non-zero exit code, it adds them to the dictionary returned.
Keyword arguments:
tests -- a list of paths to executable test files
test_input -- dictionary of key value pairs to provide to the test
timeout -- how many seconds to let the tests run
waittime -- how many seconds to wait in between test polls
"""
failed_tests = {}
for t in tests:
log.debug("Executing test %s", t)
p = subprocess.Popen(t, stdin=subprocess.PIPE)
to_send = json.dumps(test_input)
log.debug("Sending test_input to test: %s", to_send)
# Using write here instead of communicate because communicate
# blocks on reading output
try:
p.stdin.write(to_send + os.linesep)
p.stdin.close()
countdown = int(timeout / waittime)
while countdown:
retcode = p.poll()
if retcode is not None:
break
time.sleep(waittime)
countdown = countdown - 1
else:
p.terminate()
log.warn("Test %s timed out", t)
p.wait()
retcode = 'TIMEOUT'
except __HOLE__ as e:
log.warn("Caught IOError from process: %s", e)
retcode = e
if retcode:
failed_tests[t] = retcode
log.error("Test %s failed with code %s", t, retcode)
return failed_tests | IOError | dataset/ETHPy150Open gosquadron/squadron/squadron/tests.py/run_tests |
5 | def git_version():
def _minimal_ext_cmd(cmd):
# construct minimal environment
env = {}
for k in ['SYSTEMROOT', 'PATH']:
v = os.environ.get(k)
if v is not None:
env[k] = v
# LANGUAGE is used on win32
env['LANGUAGE'] = 'C'
env['LANG'] = 'C'
env['LC_ALL'] = 'C'
out = subprocess.Popen(
cmd, stdout=subprocess.PIPE, env=env).communicate()[0]
return out
try:
out = _minimal_ext_cmd(['git', 'rev-parse', 'HEAD'])
GIT_REVISION = out.strip().decode('ascii')
except __HOLE__:
GIT_REVISION = "Unknown"
return GIT_REVISION
# This is a bit hackish: we are setting a global variable so that the main
# pyfunt __init__ can detect if it is being loaded by the setup routine, to
# avoid attempting to load components that aren't built yet. While ugly, it's
# a lot more robust than what was previously being used. | OSError | dataset/ETHPy150Open dnlcrl/PyFunt/setup.py/git_version |
6 | def setup_package():
# Rewrite the version file every time
write_version_py()
cmdclass = {}
# Figure out whether to add ``*_requires = ['numpy']``.
# We don't want to do that unconditionally, because we risk updating
# an installed numpy which fails too often. Just if it's not installed, we
# may give it a try. See gh-3379.
build_requires = []
try:
import numpy
if (len(sys.argv) >= 2 and sys.argv[1] == 'bdist_wheel' and
sys.platform == 'darwin'):
# We're ony building wheels for platforms where we know there's
# also a Numpy wheel, so do this unconditionally. See gh-5184.
build_requires = ['numpy>=1.7.1']
except:
build_requires = ['numpy>=1.7.1']
metadata = dict(
name="pyfunt",
author="Daniele Ettore Ciriello",
author_email="ciriello.daniele@gmail.com",
version="0.1",
license="MIT",
url="https://github.com/dnlcrl/PyFunt",
download_url="https://github.com/dnlcrl/PyFunt",
description="Pythonic Deep Learning Framework",
packages=['pyfunt', 'pyfunt/layers', 'pyfunt/utils'],
cmdclass=cmdclass, # {'build_ext': build_ext},
platforms=["Windows", "Linux", "Solaris", "Mac OS-X", "Unix"],
setup_requires=build_requires,
install_requires=required,
# ext_modules=extensions,
keywords='pyfunt deep learning artificial neural network convolution',
)
if len(sys.argv) >= 2 and ('--help' in sys.argv[1:] or
sys.argv[1] in ('--help-commands', 'egg_info', '--version',
'clean')):
# For these actions, NumPy is not required.
#
# They are required to succeed without Numpy for example when
# pip is used to install Scipy when Numpy is not yet present in
# the system.
try:
from setuptools import setup
except __HOLE__:
from distutils.core import setup
else:
if (len(sys.argv) >= 2 and sys.argv[1] in ('bdist_wheel', 'bdist_egg')) or (
'develop' in sys.argv):
# bdist_wheel/bdist_egg needs setuptools
import setuptools
from numpy.distutils.core import setup
cwd = os.path.abspath(os.path.dirname(__file__))
if not os.path.exists(os.path.join(cwd, 'PKG-INFO')):
# Generate Cython sources, unless building from source release
generate_cython()
metadata['configuration'] = configuration
print 'setup complete'
setup(**metadata) | ImportError | dataset/ETHPy150Open dnlcrl/PyFunt/setup.py/setup_package |
7 | def exclude(self, excludes):
"""Takes a list of node names and removes all nodes and their
successors from the graph.
:param excludes: list of node names
:type excludes: list of string
"""
if not excludes:
return
if not isinstance(excludes, (list, tuple)):
excludes = [excludes]
excludes = set(excludes)
# index the nodes by name
names2nodes = {}
for node in self.nodes():
if node._job.name is not None:
names2nodes[node._job.name] = node
def _recursive_remove(node, force=True):
parents = list(node.parents())
if force or len(parents) <= 1:
children = list(node.children())
map(lambda n: _recursive_remove(n, False),
children)
try:
log.info("Excluding node %s", node)
self.remove(node)
# check the children again, they might have becom invalid
for child in [c for c in children
if c._tool in self._nodes]:
try:
child._tool.validate()
except:
log.info("Forcing exclude of %s, "
"node became invalid",
child)
_recursive_remove(child)
except __HOLE__:
## ignore errors where the node was already removed
pass
for name in excludes:
if not name in names2nodes:
log.warn("Node marked for exclusing not found: %s", name)
else:
if isinstance(name, basestring) and not name in names2nodes:
node = names2nodes[name]
else:
node = name
_recursive_remove(names2nodes[name])
self._update_cleanup_nodes() | KeyError | dataset/ETHPy150Open thasso/pyjip/jip/pipelines.py/Pipeline.exclude |
8 | def download(uri, filename=None, headers=None, redirect_limit=5, **kwargs):
""" Get a remote resource and save the content to a local file. If a local
file already exists at the download destination, the modification time of
that file is sent in the request headers as the `If-Modified-Since` value
to perform a conditional GET. If the remote file has not been modified, a
304 response should then be returned.
:param uri:
:param filename:
:param headers:
:param redirect_limit:
:param kwargs:
:return:
"""
from datetime import datetime
from os import utime
from os.path import getmtime
from time import time
from .tardis import datetime_to_timestamp
try:
last_modified = datetime.fromtimestamp(getmtime(filename))
except __HOLE__:
last_modified = None
with get(uri, if_modified_since=last_modified, headers=headers, redirect_limit=redirect_limit, **kwargs) as source:
if source.status_code == 200:
if not filename:
filename = source.filename
with open(filename, "wb") as destination:
finished = False
while not finished:
data = source.read(8192)
if data:
destination.write(data)
else:
finished = True
utime(filename, (time(), datetime_to_timestamp(source.last_modified)))
return True
elif source.status_code == 304:
return False
else:
raise ValueError("Unexpected status code %s from download response" % source.status_code) | OSError | dataset/ETHPy150Open nigelsmall/py2neo/py2neo/packages/httpstream/__init__.py/download |
9 | def ReadFile(filename, logger=None):
"""Read the contents of the file.
An optional logger can be specified to emit messages to your favorite logging
stream. If specified, then no exception is raised. This is external so that it
can be used by third-party applications.
Arguments:
filename: (unicode) The name of the file.
logger: (function) A function or lambda that takes a string and emits it.
Returns:
The contents of filename.
Raises:
IOError: raised if there was an error reading the file.
"""
try:
with open(filename, 'rb') as fd:
encoding = tokenize.detect_encoding(fd.readline)[0]
except __HOLE__ as err:
if logger:
logger(err)
raise
try:
with py3compat.open_with_encoding(filename,
mode='r',
encoding=encoding) as fd:
source = fd.read()
return source, encoding
except IOError as err:
if logger:
logger(err)
raise | IOError | dataset/ETHPy150Open google/yapf/yapf/yapflib/yapf_api.py/ReadFile |
10 | @view(path=r'^themes/?$')
def index(request):
order = request.GET.get('order', '')
if not order in ['downloads', 'date']:
order = 'downloads'
nameFilter = request.GET.get('filter', '')
try:
page = int(request.GET.get('page', '1'))
except __HOLE__:
page = 1
themes, page, pagesCount = get_page(order, nameFilter, page - 1)
return render(request, 'themes/index.html', {
'themes': themes,
'order': order,
'filter': nameFilter,
'page': page + 1,
'pages': range(1, pagesCount + 1),
'nextPage': page + 2 if page < pagesCount - 1 else 0,
'adPlace': themes[random.randint(0, len(themes) - 1)]['id'] if len(themes) > 0 else -1,
'emptyList': len(themes) == 0
}) | ValueError | dataset/ETHPy150Open y-a-r-g/idea-color-themes/backend/views/themes.py/index |
11 | def payment_successful_handler(sender, **kwargs):
if sender.payment_status == "Completed":
try:
token = ShoppingToken.objects.get(value=sender.invoice)
token.payed = True
token.save()
except __HOLE__:
pass | ObjectDoesNotExist | dataset/ETHPy150Open y-a-r-g/idea-color-themes/backend/views/themes.py/payment_successful_handler |
12 | def test_numparser_strict():
parsenumber = numparser(strict=True)
assert parsenumber('1') == 1
assert parsenumber('1.0') == 1.0
assert parsenumber(str(maxint + 1)) == maxint + 1
assert parsenumber('3+4j') == 3 + 4j
try:
parsenumber('aaa')
except __HOLE__:
pass # expected
else:
assert False, 'expected exception'
try:
parsenumber(None)
except TypeError:
pass # expected
else:
assert False, 'expected exception' | ValueError | dataset/ETHPy150Open alimanfoo/petl/petl/test/util/test_parsers.py/test_numparser_strict |
13 | def test_laxparsers():
p1 = datetimeparser('%Y-%m-%dT%H:%M:%S')
try:
p1('2002-12-25 00:00:00')
except ValueError:
pass
else:
assert False, 'expected exception'
p2 = datetimeparser('%Y-%m-%dT%H:%M:%S', strict=False)
try:
v = p2('2002-12-25 00:00:00')
except __HOLE__:
assert False, 'did not expect exception'
else:
eq_('2002-12-25 00:00:00', v) | ValueError | dataset/ETHPy150Open alimanfoo/petl/petl/test/util/test_parsers.py/test_laxparsers |
14 | def logout(self, request):
try:
request.user.auth_token.delete()
except (__HOLE__, ObjectDoesNotExist):
pass
logout(request)
return Response({"success": _("Successfully logged out.")},
status=status.HTTP_200_OK) | AttributeError | dataset/ETHPy150Open Tivix/django-rest-auth/rest_auth/views.py/LogoutView.logout |
15 | def search_external_subtitles(path, directory=None):
"""Search for external subtitles from a video `path` and their associated language.
Unless `directory` is provided, search will be made in the same directory as the video file.
:param str path: path to the video.
:param str directory: directory to search for subtitles.
:return: found subtitles with their languages.
:rtype: dict
"""
dirpath, filename = os.path.split(path)
dirpath = dirpath or '.'
fileroot, fileext = os.path.splitext(filename)
subtitles = {}
for p in os.listdir(directory or dirpath):
# keep only valid subtitle filenames
if not p.startswith(fileroot) or not p.endswith(SUBTITLE_EXTENSIONS):
continue
# extract the potential language code
language_code = p[len(fileroot):-len(os.path.splitext(p)[1])].replace(fileext, '').replace('_', '-')[1:]
# default language is undefined
language = Language('und')
# attempt to parse
if language_code:
try:
language = Language.fromietf(language_code)
except __HOLE__:
logger.error('Cannot parse language code %r', language_code)
subtitles[p] = language
logger.debug('Found subtitles %r', subtitles)
return subtitles | ValueError | dataset/ETHPy150Open Diaoul/subliminal/subliminal/video.py/search_external_subtitles |
16 | def scan_videos(path, subtitles=True, embedded_subtitles=True, subtitles_dir=None):
"""Scan `path` for videos and their subtitles.
:param str path: existing directory path to scan.
:param bool subtitles: scan for subtitles with the same name.
:param bool embedded_subtitles: scan for embedded subtitles.
:param str subtitles_dir: directory to search for subtitles.
:return: the scanned videos.
:rtype: list of :class:`Video`
"""
# check for non-existing path
if not os.path.exists(path):
raise ValueError('Path does not exist')
# check for non-directory path
if not os.path.isdir(path):
raise ValueError('Path is not a directory')
# walk the path
videos = []
for dirpath, dirnames, filenames in os.walk(path):
logger.debug('Walking directory %s', dirpath)
# remove badly encoded and hidden dirnames
for dirname in list(dirnames):
if dirname.startswith('.'):
logger.debug('Skipping hidden dirname %r in %r', dirname, dirpath)
dirnames.remove(dirname)
# scan for videos
for filename in filenames:
# filter on videos
if not filename.endswith(VIDEO_EXTENSIONS):
continue
# skip hidden files
if filename.startswith('.'):
logger.debug('Skipping hidden filename %r in %r', filename, dirpath)
continue
# reconstruct the file path
filepath = os.path.join(dirpath, filename)
# skip links
if os.path.islink(filepath):
logger.debug('Skipping link %r in %r', filename, dirpath)
continue
# scan video
try:
video = scan_video(filepath, subtitles=subtitles, embedded_subtitles=embedded_subtitles,
subtitles_dir=subtitles_dir)
except __HOLE__: # pragma: no cover
logger.exception('Error scanning video')
continue
videos.append(video)
return videos | ValueError | dataset/ETHPy150Open Diaoul/subliminal/subliminal/video.py/scan_videos |
17 | def _ParseQueueYaml(self):
"""Loads the queue.yaml file and parses it.
Returns:
None if queue.yaml doesn't exist, otherwise a queueinfo.QueueEntry object
populated from the queue.yaml.
"""
if hasattr(self, 'queue_yaml_parser'):
return self.queue_yaml_parser(self._root_path)
if self._root_path is None:
return None
for queueyaml in ('queue.yaml', 'queue.yml'):
try:
path = os.path.join(self._root_path, queueyaml)
modified = os.stat(path).st_mtime
if self._yaml_last_modified and self._yaml_last_modified == modified:
return self._last_queue_info
fh = open(path, 'r')
except (IOError, __HOLE__):
continue
try:
queue_info = queueinfo.LoadSingleQueue(fh)
self._last_queue_info = queue_info
self._yaml_last_modified = modified
return queue_info
finally:
fh.close()
return None | OSError | dataset/ETHPy150Open AppScale/appscale/AppServer/google/appengine/api/taskqueue/taskqueue_stub.py/TaskQueueServiceStub._ParseQueueYaml |
18 | def add_image_info_cb(self, viewer, channel, image_info):
"""Almost the same as add_image_info(), except that the image
may not be loaded in memory.
"""
chname = channel.name
name = image_info.name
self.logger.debug("name=%s" % (name))
# Updates of any extant information
try:
image = channel.get_loaded_image(name)
except __HOLE__:
# images that are not yet loaded will show "N/A" for keywords
image = None
self.add_image_cb(viewer, chname, image, image_info) | KeyError | dataset/ETHPy150Open ejeschke/ginga/ginga/misc/plugins/Contents.py/Contents.add_image_info_cb |
19 | def asm(chrom, start, end, bamfilename, reffile, kmersize, tmpdir, mutid='null', debug=False):
bamfile = pysam.Samfile(bamfilename,'rb')
matefile = pysam.Samfile(bamfilename,'rb')
readpairs = {}
nreads = 0
ndisc = 0 # track discordant reads
rquals = []
mquals = []
for read in bamfile.fetch(chrom,start,end):
if not read.mate_is_unmapped and read.is_paired:
try:
mate = matefile.mate(read)
readpairs[read.qname] = ReadPair(read,mate)
nreads += 1
if not read.is_proper_pair:
ndisc += 1
if nreads % 1000 == 0:
print "INFO\t" + now() + "\t" + mutid + "\tfound mates for", nreads, "reads,", float(ndisc)/float(nreads), "discordant."
if read.is_read1:
if read.is_reverse:
rquals.append(read.qual[::-1])
mquals.append(mate.qual)
else:
rquals.append(read.qual)
mquals.append(mate.qual[::-1])
else:
if read.is_reverse:
rquals.append(mate.qual)
mquals.append(read.qual[::-1])
else:
rquals.append(mate.qual[::-1])
mquals.append(read.qual)
except __HOLE__:
sys.stderr.write("WARN\t" + now() + "\t" + mutid + "\tcannot find mate for read marked paired: " + read.qname + "\n")
sys.stdout.write("INFO\t" + now() + "\t" + mutid + "\tfound " + str(nreads) + " reads in region.\n")
if nreads == 0:
return []
refseq = None
if reffile:
refseq = reffile.fetch(chrom,start,end)
region = "%s:%d-%d" % (chrom, start, end)
contigs = runVelvet(readpairs, region, refseq, kmersize, tmpdir, cov_cutoff=True, mutid=mutid, debug=debug)
newcontigs = None
for contig in contigs:
contig.rquals = rquals
contig.mquals = mquals
return contigs | ValueError | dataset/ETHPy150Open adamewing/bamsurgeon/bamsurgeon/asmregion.py/asm |
20 | def circuit_built(self, circuit):
"""ICircuitListener API"""
# older tor versions will have empty build_flags
if 'ONEHOP_TUNNEL' in circuit.build_flags:
return
if circuit.purpose == 'GENERAL':
if len(circuit.path) > 0:
if circuit.path[0] not in self.state.entry_guards.values():
print "WEIRD: first circuit hop not in entry guards:",
print circuit, circuit.path, circuit.purpose
return
self.built_circuits += 1
self.update_percent()
if len(circuit.path) != 3 and len(circuit.path) != 4:
print "WEIRD: circuit has odd pathlength:",
print circuit, circuit.path
try:
self.per_guard_built[circuit.path[0].unique_name] += 1.0
except __HOLE__:
self.per_guard_built[circuit.path[0].unique_name] = 1.0
self.per_guard_failed[circuit.path[0].unique_name] = 0.0 | KeyError | dataset/ETHPy150Open meejah/txtorcon/examples/circuit_failure_rates.py/CircuitFailureWatcher.circuit_built |
21 | def circuit_failed(self, circuit, kw):
"""ICircuitListener API"""
if kw['REASON'] != 'MEASUREMENT_EXPIRED':
return
# older tor versions will have empty build_flags
if 'ONEHOP_TUNNEL' in circuit.build_flags:
return
if circuit.purpose == 'GENERAL':
if len(circuit.path) > 1:
if circuit.path[0] not in self.state.entry_guards.values():
# note that single-hop circuits are built for various
# internal reasons (and it seems they somtimes use
# GENERAL anyway)
print "WEIRD: first circuit hop not in entry guards:",
print circuit, circuit.path
return
self.failed_circuits += 1
print "failed", circuit.id
if circuit.id not in self.failed_circuit_ids:
self.failed_circuit_ids.append(circuit.id)
else:
print "WARNING: duplicate message for", circuit
if len(circuit.path) > 0:
try:
self.per_guard_failed[circuit.path[0].unique_name] += 1.0
except __HOLE__:
self.per_guard_failed[circuit.path[0].unique_name] = 1.0
self.per_guard_built[circuit.path[0].unique_name] = 0.0
self.update_percent() | KeyError | dataset/ETHPy150Open meejah/txtorcon/examples/circuit_failure_rates.py/CircuitFailureWatcher.circuit_failed |
22 | @nif_blueprint.route('/', methods=['POST', 'GET'])
def home():
try:
params = get_params(request)
algo = params.get("algorithm", None)
specific_params = current_app.senpy.parameters(algo)
logger.debug(
"Specific params: %s", json.dumps(specific_params, indent=4))
params.update(get_params(request, specific_params))
response = current_app.senpy.analyse(**params)
in_headers = params["inHeaders"] != "0"
return response.flask(in_headers=in_headers)
except __HOLE__ as ex:
return ex.message.flask() | ValueError | dataset/ETHPy150Open gsi-upm/senpy/senpy/blueprints.py/home |
23 | def automoderate(instance, user):
'''
Auto moderates given model instance on user. Returns moderation status:
0 - Rejected
1 - Approved
'''
try:
status = instance.moderated_object.automoderate(user)
except __HOLE__:
msg = "%s has been registered with Moderation." % instance.__class__
raise RegistrationError(msg)
return status | AttributeError | dataset/ETHPy150Open dominno/django-moderation/moderation/helpers.py/automoderate |
24 | def import_moderator(app):
'''
Import moderator module and register all models it contains with moderation
'''
from django.utils.importlib import import_module
import imp
try:
app_path = import_module(app).__path__
except __HOLE__:
return None
try:
imp.find_module('moderator', app_path)
except ImportError:
return None
module = import_module("%s.moderator" % app)
return module | AttributeError | dataset/ETHPy150Open dominno/django-moderation/moderation/helpers.py/import_moderator |
25 | def parse_request(self):
"""Parse a request (internal).
The request should be stored in self.raw_requestline; the results
are in self.command, self.path, self.request_version and
self.headers.
Return True for success, False for failure; on failure, an
error is sent back.
"""
self.command = None # set in case of error on the first line
self.request_version = version = self.default_request_version
self.close_connection = 1
requestline = str(self.raw_requestline, 'iso-8859-1')
requestline = requestline.rstrip('\r\n')
self.requestline = requestline
words = requestline.split()
if len(words) == 3:
command, path, version = words
if version[:5] != 'HTTP/':
self.send_error(400, "Bad request version (%r)" % version)
return False
try:
base_version_number = version.split('/', 1)[1]
version_number = base_version_number.split(".")
# RFC 2145 section 3.1 says there can be only one "." and
# - major and minor numbers MUST be treated as
# separate integers;
# - HTTP/2.4 is a lower version than HTTP/2.13, which in
# turn is lower than HTTP/12.3;
# - Leading zeros MUST be ignored by recipients.
if len(version_number) != 2:
raise ValueError
version_number = int(version_number[0]), int(version_number[1])
except (ValueError, __HOLE__):
self.send_error(400, "Bad request version (%r)" % version)
return False
if version_number >= (1, 1) and self.protocol_version >= "HTTP/1.1":
self.close_connection = 0
if version_number >= (2, 0):
self.send_error(505,
"Invalid HTTP Version (%s)" % base_version_number)
return False
elif len(words) == 2:
command, path = words
self.close_connection = 1
if command != 'GET':
self.send_error(400,
"Bad HTTP/0.9 request type (%r)" % command)
return False
elif not words:
return False
else:
self.send_error(400, "Bad request syntax (%r)" % requestline)
return False
self.command, self.path, self.request_version = command, path, version
# Examine the headers and look for a Connection directive.
try:
self.headers = http_client.parse_headers(self.rfile,
_class=self.MessageClass)
except http_client.LineTooLong:
self.send_error(400, "Line too long")
return False
conntype = self.headers.get('Connection', "")
if conntype.lower() == 'close':
self.close_connection = 1
elif (conntype.lower() == 'keep-alive' and
self.protocol_version >= "HTTP/1.1"):
self.close_connection = 0
# Examine the headers and look for an Expect directive
expect = self.headers.get('Expect', "")
if (expect.lower() == "100-continue" and
self.protocol_version >= "HTTP/1.1" and
self.request_version >= "HTTP/1.1"):
if not self.handle_expect_100():
return False
return True | IndexError | dataset/ETHPy150Open OpenCobolIDE/OpenCobolIDE/open_cobol_ide/extlibs/future/backports/http/server.py/BaseHTTPRequestHandler.parse_request |
26 | def send_error(self, code, message=None):
"""Send and log an error reply.
Arguments are the error code, and a detailed message.
The detailed message defaults to the short entry matching the
response code.
This sends an error response (so it must be called before any
output has been generated), logs the error, and finally sends
a piece of HTML explaining the error to the user.
"""
try:
shortmsg, longmsg = self.responses[code]
except __HOLE__:
shortmsg, longmsg = '???', '???'
if message is None:
message = shortmsg
explain = longmsg
self.log_error("code %d, message %s", code, message)
# using _quote_html to prevent Cross Site Scripting attacks (see bug #1100201)
content = (self.error_message_format %
{'code': code, 'message': _quote_html(message), 'explain': explain})
self.send_response(code, message)
self.send_header("Content-Type", self.error_content_type)
self.send_header('Connection', 'close')
self.end_headers()
if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
self.wfile.write(content.encode('UTF-8', 'replace')) | KeyError | dataset/ETHPy150Open OpenCobolIDE/OpenCobolIDE/open_cobol_ide/extlibs/future/backports/http/server.py/BaseHTTPRequestHandler.send_error |
27 | def send_head(self):
"""Common code for GET and HEAD commands.
This sends the response code and MIME headers.
Return value is either a file object (which has to be copied
to the outputfile by the caller unless the command was HEAD,
and must be closed by the caller under all circumstances), or
None, in which case the caller has nothing further to do.
"""
path = self.translate_path(self.path)
f = None
if os.path.isdir(path):
if not self.path.endswith('/'):
# redirect browser - doing basically what apache does
self.send_response(301)
self.send_header("Location", self.path + "/")
self.end_headers()
return None
for index in "index.html", "index.htm":
index = os.path.join(path, index)
if os.path.exists(index):
path = index
break
else:
return self.list_directory(path)
ctype = self.guess_type(path)
try:
f = open(path, 'rb')
except __HOLE__:
self.send_error(404, "File not found")
return None
self.send_response(200)
self.send_header("Content-type", ctype)
fs = os.fstat(f.fileno())
self.send_header("Content-Length", str(fs[6]))
self.send_header("Last-Modified", self.date_time_string(fs.st_mtime))
self.end_headers()
return f | IOError | dataset/ETHPy150Open OpenCobolIDE/OpenCobolIDE/open_cobol_ide/extlibs/future/backports/http/server.py/SimpleHTTPRequestHandler.send_head |
28 | def nobody_uid():
"""Internal routine to get nobody's uid"""
global nobody
if nobody:
return nobody
try:
import pwd
except __HOLE__:
return -1
try:
nobody = pwd.getpwnam('nobody')[2]
except KeyError:
nobody = 1 + max(x[2] for x in pwd.getpwall())
return nobody | ImportError | dataset/ETHPy150Open OpenCobolIDE/OpenCobolIDE/open_cobol_ide/extlibs/future/backports/http/server.py/nobody_uid |
29 | def run_cgi(self):
"""Execute a CGI script."""
path = self.path
dir, rest = self.cgi_info
i = path.find('/', len(dir) + 1)
while i >= 0:
nextdir = path[:i]
nextrest = path[i+1:]
scriptdir = self.translate_path(nextdir)
if os.path.isdir(scriptdir):
dir, rest = nextdir, nextrest
i = path.find('/', len(dir) + 1)
else:
break
# find an explicit query string, if present.
i = rest.rfind('?')
if i >= 0:
rest, query = rest[:i], rest[i+1:]
else:
query = ''
# dissect the part after the directory name into a script name &
# a possible additional path, to be stored in PATH_INFO.
i = rest.find('/')
if i >= 0:
script, rest = rest[:i], rest[i:]
else:
script, rest = rest, ''
scriptname = dir + '/' + script
scriptfile = self.translate_path(scriptname)
if not os.path.exists(scriptfile):
self.send_error(404, "No such CGI script (%r)" % scriptname)
return
if not os.path.isfile(scriptfile):
self.send_error(403, "CGI script is not a plain file (%r)" %
scriptname)
return
ispy = self.is_python(scriptname)
if self.have_fork or not ispy:
if not self.is_executable(scriptfile):
self.send_error(403, "CGI script is not executable (%r)" %
scriptname)
return
# Reference: http://hoohoo.ncsa.uiuc.edu/cgi/env.html
# XXX Much of the following could be prepared ahead of time!
env = copy.deepcopy(os.environ)
env['SERVER_SOFTWARE'] = self.version_string()
env['SERVER_NAME'] = self.server.server_name
env['GATEWAY_INTERFACE'] = 'CGI/1.1'
env['SERVER_PROTOCOL'] = self.protocol_version
env['SERVER_PORT'] = str(self.server.server_port)
env['REQUEST_METHOD'] = self.command
uqrest = urllib_parse.unquote(rest)
env['PATH_INFO'] = uqrest
env['PATH_TRANSLATED'] = self.translate_path(uqrest)
env['SCRIPT_NAME'] = scriptname
if query:
env['QUERY_STRING'] = query
env['REMOTE_ADDR'] = self.client_address[0]
authorization = self.headers.get("authorization")
if authorization:
authorization = authorization.split()
if len(authorization) == 2:
import base64, binascii
env['AUTH_TYPE'] = authorization[0]
if authorization[0].lower() == "basic":
try:
authorization = authorization[1].encode('ascii')
if utils.PY3:
# In Py3.3, was:
authorization = base64.decodebytes(authorization).\
decode('ascii')
else:
# Backport to Py2.7:
authorization = base64.decodestring(authorization).\
decode('ascii')
except (binascii.Error, UnicodeError):
pass
else:
authorization = authorization.split(':')
if len(authorization) == 2:
env['REMOTE_USER'] = authorization[0]
# XXX REMOTE_IDENT
if self.headers.get('content-type') is None:
env['CONTENT_TYPE'] = self.headers.get_content_type()
else:
env['CONTENT_TYPE'] = self.headers['content-type']
length = self.headers.get('content-length')
if length:
env['CONTENT_LENGTH'] = length
referer = self.headers.get('referer')
if referer:
env['HTTP_REFERER'] = referer
accept = []
for line in self.headers.getallmatchingheaders('accept'):
if line[:1] in "\t\n\r ":
accept.append(line.strip())
else:
accept = accept + line[7:].split(',')
env['HTTP_ACCEPT'] = ','.join(accept)
ua = self.headers.get('user-agent')
if ua:
env['HTTP_USER_AGENT'] = ua
co = filter(None, self.headers.get_all('cookie', []))
cookie_str = ', '.join(co)
if cookie_str:
env['HTTP_COOKIE'] = cookie_str
# XXX Other HTTP_* headers
# Since we're setting the env in the parent, provide empty
# values to override previously set values
for k in ('QUERY_STRING', 'REMOTE_HOST', 'CONTENT_LENGTH',
'HTTP_USER_AGENT', 'HTTP_COOKIE', 'HTTP_REFERER'):
env.setdefault(k, "")
self.send_response(200, "Script output follows")
self.flush_headers()
decoded_query = query.replace('+', ' ')
if self.have_fork:
# Unix -- fork as we should
args = [script]
if '=' not in decoded_query:
args.append(decoded_query)
nobody = nobody_uid()
self.wfile.flush() # Always flush before forking
pid = os.fork()
if pid != 0:
# Parent
pid, sts = os.waitpid(pid, 0)
# throw away additional data [see bug #427345]
while select.select([self.rfile], [], [], 0)[0]:
if not self.rfile.read(1):
break
if sts:
self.log_error("CGI script exit status %#x", sts)
return
# Child
try:
try:
os.setuid(nobody)
except os.error:
pass
os.dup2(self.rfile.fileno(), 0)
os.dup2(self.wfile.fileno(), 1)
os.execve(scriptfile, args, env)
except:
self.server.handle_error(self.request, self.client_address)
os._exit(127)
else:
# Non-Unix -- use subprocess
import subprocess
cmdline = [scriptfile]
if self.is_python(scriptfile):
interp = sys.executable
if interp.lower().endswith("w.exe"):
# On Windows, use python.exe, not pythonw.exe
interp = interp[:-5] + interp[-4:]
cmdline = [interp, '-u'] + cmdline
if '=' not in query:
cmdline.append(query)
self.log_message("command: %s", subprocess.list2cmdline(cmdline))
try:
nbytes = int(length)
except (TypeError, __HOLE__):
nbytes = 0
p = subprocess.Popen(cmdline,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env = env
)
if self.command.lower() == "post" and nbytes > 0:
data = self.rfile.read(nbytes)
else:
data = None
# throw away additional data [see bug #427345]
while select.select([self.rfile._sock], [], [], 0)[0]:
if not self.rfile._sock.recv(1):
break
stdout, stderr = p.communicate(data)
self.wfile.write(stdout)
if stderr:
self.log_error('%s', stderr)
p.stderr.close()
p.stdout.close()
status = p.returncode
if status:
self.log_error("CGI script exit status %#x", status)
else:
self.log_message("CGI script exited OK") | ValueError | dataset/ETHPy150Open OpenCobolIDE/OpenCobolIDE/open_cobol_ide/extlibs/future/backports/http/server.py/CGIHTTPRequestHandler.run_cgi |
30 | def test(HandlerClass = BaseHTTPRequestHandler,
ServerClass = HTTPServer, protocol="HTTP/1.0", port=8000):
"""Test the HTTP request handler class.
This runs an HTTP server on port 8000 (or the first command line
argument).
"""
server_address = ('', port)
HandlerClass.protocol_version = protocol
httpd = ServerClass(server_address, HandlerClass)
sa = httpd.socket.getsockname()
print("Serving HTTP on", sa[0], "port", sa[1], "...")
try:
httpd.serve_forever()
except __HOLE__:
print("\nKeyboard interrupt received, exiting.")
httpd.server_close()
sys.exit(0) | KeyboardInterrupt | dataset/ETHPy150Open OpenCobolIDE/OpenCobolIDE/open_cobol_ide/extlibs/future/backports/http/server.py/test |
31 | def get_object_from_identifier(identifier, valid=None):
""" Helper function to resolve an item identifier
into a model instance.
Raises StoreException if the identifier is invalid
or the requested Model could not be found
Raises <Model>.DoesNotExist if the object lookup fails
Arguments (optional):
valid
One or more Django model classes to compare the
returned model instance to.
"""
try:
model_str, pk = identifier.split('__')
except __HOLE__:
raise StoreException('Invalid identifier string')
Model = get_model(*model_str.split('.'))
if Model is None:
raise StoreException('Model from identifier string "%s" not found' % model_str)
if valid is not None:
if not isinstance(valid, (list, tuple) ):
valid = (valid,)
if Model not in valid:
raise StoreException('Model type mismatch')
# This will raise Model.DoesNotExist if lookup fails
return Model._default_manager.get(pk=pk) | ValueError | dataset/ETHPy150Open klipstein/dojango/dojango/data/modelstore/utils.py/get_object_from_identifier |
32 | def get_fields_and_servicemethods(bases, attrs, include_bases=True):
""" This function was pilfered (and slightly modified) from django/forms/forms.py
See the original function for doc and comments.
"""
fields = [ (field_name, attrs.pop(field_name)) for \
field_name, obj in attrs.items() if isinstance(obj, StoreField)]
# Get the method name directly from the __servicemethod__ dict
# as set by the decorator
methods = [ (method.__servicemethod__['name'], method) for \
method in attrs.values() if hasattr(method, '__servicemethod__') ]
if include_bases:
for base in bases[::-1]:
# Grab the fields and servicemethods from the base classes
try:
fields = base.fields.items() + fields
except AttributeError:
pass
try:
methods = base.servicemethods.items() + methods
except __HOLE__:
pass
return SortedDict(fields), SortedDict(methods) | AttributeError | dataset/ETHPy150Open klipstein/dojango/dojango/data/modelstore/utils.py/get_fields_and_servicemethods |
33 | def GetCaParameters(settings, ca_id=0, omit_server_private_key=False):
"""Get ca/cert parameters for CA named ca_id.
Note, subtle: If no ca_id value is supplied, the default value from
settings.CA_ID is used for the ca_id. This value might make the chosen
parameters be NOT from the defaults (no prefix on the settings names).
However, if None value is supplied for ca_id then the CA_ID of default
(no specific CA_ID specified) is used. See the table below for examples.
ca_id argument settings settings
------------------ ------------ -------------------------------
ca_id (unspecified) CA_ID="FOO" uses: FOO_CA_PUBLIC_CERT_PEM
ca_id (unspecified) CA_ID=None uses: CA_PUBLIC_CERT_PEM
ca_id=None CA_ID=None uses: CA_PUBLIC_CERT_PEM
ca_id=None CA_ID="FOO" uses: CA_PUBLIC_CERT_PEM
ca_id="BAR" CA_ID=None uses: BAR_CA_PUBLIC_CERT_PEM
ca_id="BAR" CA_ID="FOO" uses: BAR_CA_PUBLIC_CERT_PEM
Args:
settings: object with attribute level access to settings parameters.
ca_id: str or None (default), identifies the CA/server cert/keys.
omit_server_private_key: bool, True to omit the server's private key, for
use when calling from clients. Default False, which includes the key.
Returns:
CaParameters instance.
Raises:
CaIdError: if any errors occur loading keys/certs for ca_id
"""
if ca_id is 0:
ca_id = GetCaId(settings)
if ca_id is not None and not CA_ID_RE.match(ca_id):
raise CaParametersError('invalid ca_id')
settings_params = [
L_CA_PUBLIC_CERT_PEM,
L_SERVER_PUBLIC_CERT_PEM,
L_REQUIRED_ISSUER,
]
optional_params = []
if not omit_server_private_key:
settings_params.append(L_SERVER_PRIVATE_KEY_PEM)
optional_params.append(L_SERVER_PRIVATE_KEY_PEM)
ca_params = CaParameters()
try:
for settings_name in settings_params:
if ca_id:
settings_k = '%s_%s' % (ca_id, settings_name)
else:
settings_k = settings_name
param_k = settings_name.lower()
try:
v = getattr(settings, settings_k)
except __HOLE__:
if settings_name in optional_params:
v = None
else:
raise
setattr(ca_params, param_k, v)
except (AttributeError, ValueError), e:
logging.critical(str(e))
logging.exception(str(e))
raise CaParametersError(str(e))
ca_params.ca_id = ca_id
return ca_params | AttributeError | dataset/ETHPy150Open google/simian/src/simian/auth/util.py/GetCaParameters |
34 | def setup_config(config_dir):
""" Setup configuration directory. """
config_dir = os.path.abspath(config_dir)
if not os.path.isdir(config_dir):
try:
os.mkdir(config_dir)
except OSError as err:
print('Polyglot could not create configuration directory.')
print(repr(err))
sys.exit(1)
if not os.path.isdir(os.path.join(config_dir, 'node_servers')):
try:
os.mkdir(os.path.join(config_dir, 'node_servers'))
except __HOLE__ as err:
print('Polyglot could not create user node server directory.')
print(repr(err))
sys.exit(1)
return config_dir | OSError | dataset/ETHPy150Open UniversalDevicesInc/Polyglot/polyglot/__main__.py/setup_config |
35 | def run_ginkgo():
parser = argparse.ArgumentParser(prog="ginkgo", add_help=False)
parser.add_argument("-v", "--version",
action="version", version="%(prog)s {}".format(ginkgo.__version__))
parser.add_argument("-h", "--help", action="store_true", help="""
show program's help text and exit
""".strip())
parser.add_argument("-d", "--daemonize", action="store_true", help="""
daemonize the service process
""".strip())
parser.add_argument("target", nargs='?', help="""
service class path to run (modulename.ServiceClass) or
configuration file path to use (/path/to/config.py)
""".strip())
args = parser.parse_args()
if args.help:
parser.print_help()
if args.target:
print# blank line
try:
app = setup_process(args.target)
app.config.print_help()
except __HOLE__, e:
parser.error(e)
else:
if args.target:
try:
ControlInterface().start(args.target, args.daemonize)
except RuntimeError, e:
parser.error(e)
else:
parser.print_usage() | RuntimeError | dataset/ETHPy150Open progrium/ginkgo/ginkgo/runner.py/run_ginkgo |
36 | def run_ginkgoctl():
parser = argparse.ArgumentParser(prog="ginkgoctl")
parser.add_argument("-v", "--version",
action="version", version="%(prog)s {}".format(ginkgo.__version__))
parser.add_argument("-p", "--pid", help="""
pid or pidfile to use instead of target
""".strip())
parser.add_argument("target", nargs='?', help="""
service class path to use (modulename.ServiceClass) or
configuration file path to use (/path/to/config.py)
""".strip())
parser.add_argument("action",
choices="start stop restart reload status log logtail".split())
args = parser.parse_args()
if args.pid and args.target:
parser.error("You cannot specify both a target and a pid")
try:
if args.action in "start restart log logtail".split():
if not args.target:
parser.error("You need to specify a target for {}".format(args.action))
getattr(ControlInterface(), args.action)(args.target)
else:
getattr(ControlInterface(), args.action)(resolve_pid(args.pid, args.target))
except __HOLE__, e:
parser.error(e) | RuntimeError | dataset/ETHPy150Open progrium/ginkgo/ginkgo/runner.py/run_ginkgoctl |
37 | def load_class(class_path):
if '.' not in class_path:
raise RuntimeError("Invalid class path")
module_name, class_name = class_path.rsplit('.', 1)
try:
try:
module = runpy.run_module(module_name)
except ImportError:
module = runpy.run_module(module_name + ".__init__")
except ImportError, e:
import traceback, pkgutil
tb_tups = traceback.extract_tb(sys.exc_info()[2])
if pkgutil.__file__.startswith(tb_tups[-1][0]):
# If the bottommost frame in our stack was in pkgutil,
# then we can safely say that this ImportError occurred
# because the top level class path was not found.
raise RuntimeError("Unable to load class path: {}:\n{}".format(
class_path, e))
else:
# If the ImportError occurred further down,
# raise original exception.
raise
try:
return module[class_name]
except __HOLE__, e:
raise RuntimeError("Unable to find class in module: {}".format(
class_path)) | KeyError | dataset/ETHPy150Open progrium/ginkgo/ginkgo/runner.py/load_class |
38 | def resolve_target(target):
if target.endswith('.py'):
if os.path.exists(target):
config = ginkgo.settings.load_file(target)
try:
return config['service']
except __HOLE__:
raise RuntimeError(
"Configuration does not specify a service factory")
else:
raise RuntimeError(
'Configuration file %s does not exist' % target)
else:
return target | KeyError | dataset/ETHPy150Open progrium/ginkgo/ginkgo/runner.py/resolve_target |
39 | def start(self, target, daemonize=True):
print "Starting process with {}...".format(target)
app = setup_process(target, daemonize)
try:
app.serve_forever()
except __HOLE__:
pass
finally:
app.stop() | KeyboardInterrupt | dataset/ETHPy150Open progrium/ginkgo/ginkgo/runner.py/ControlInterface.start |
40 | def _validate(self, pid):
try:
os.kill(pid, 0)
return pid
except (__HOLE__, TypeError):
print "Process is NOT running." | OSError | dataset/ETHPy150Open progrium/ginkgo/ginkgo/runner.py/ControlInterface._validate |
41 | def logtail(self, target):
try:
app = setup_process(target)
app.logger.tail_log()
except __HOLE__:
pass | KeyboardInterrupt | dataset/ETHPy150Open progrium/ginkgo/ginkgo/runner.py/ControlInterface.logtail |
42 | def do_reload(self):
try:
self.config.reload_file()
self.logger.load_config()
except __HOLE__, e:
logger.warn(e) | RuntimeError | dataset/ETHPy150Open progrium/ginkgo/ginkgo/runner.py/Process.do_reload |
43 | def make_all(self, profiler=None, input_storage=None,
output_storage=None, storage_map=None):
# can't import at toplevel because of circular import TODO:
# don't do this ugly hacky way of setting the
# filter_checks_isfinite
from theano.tensor import TensorType # to set filter_check_isfinite
fgraph = self.fgraph
input_storage_ = input_storage
output_storage_ = output_storage
# Compute a topological ordering that IGNORES the destroy_map
# of destructive Ops. This will be OK, because every thunk is
# evaluated on a copy of its input.
fgraph_equiv = fgraph.equivalence_tracker
order_outputs = copy.copy(fgraph_equiv.all_variables_ever)
del fgraph_equiv
order_outputs.reverse()
order = graph.io_toposort(fgraph.inputs, order_outputs)
# an ordering of just the active nodes
active_order = self.schedule(fgraph)
active_order_set = set(active_order)
# Disable no_recycling, in order to be able to use
# check_preallocated_output even on the output of the function.
# no_recycling in individual thunks does not really matter, since
# the function's outputs will always be freshly allocated.
no_recycling = []
input_storage, output_storage, storage_map = link.map_storage(
fgraph, order, input_storage_, output_storage_, storage_map)
thunks_py = [] # python thunks
thunks_c = [] # c thunks
for node in order:
compute_map = {}
for k in node.inputs:
compute_map[k] = [True]
for k in node.outputs:
compute_map[k] = [False]
# Some Ops define a make_thunk with the expectation that
# it will be called before the C code is compiled, because
# the compilation of some dependency is triggered there.
thunk_other = None
if (get_unbound_function(node.op.make_thunk) not in
default_make_thunk):
thunk = node.op.make_thunk(node,
storage_map,
compute_map,
no_recycling)
thunk.inputs = [storage_map[v] for v in node.inputs]
thunk.outputs = [storage_map[v] for v in node.outputs]
thunk_other = thunk
else:
new_node = node.op.prepare_node(node, storage_map, compute_map)
if new_node is not None:
node = new_node
debug = hasattr(node.op, 'debug_perform')
try:
if not self.maker.mode.check_c_code or debug:
raise utils.MethodNotDefined()
# Ops that do not inherit from gof.op.Op don't have certain
# methods defined that the CLinker expects (Scan is an
# example, ifelse is another of such classes that inherit
# directly from PureOp)
if not isinstance(node.op, gof.op.Op):
raise utils.MethodNotDefined()
thunk = node.op.make_c_thunk(node, storage_map, compute_map,
no_recycling)
thunks_c.append(thunk)
except (NotImplementedError, utils.MethodNotDefined):
thunks_c.append(None)
# Pure ops don't really have a perform ( or their perform just
# raises an not implemented exception), so in those cases we
# consider that we don't have a python implementation
if (((self.maker.mode.check_py_code or thunks_c[-1] is None) and
node.op.perform.__code__ != gof.op.PureOp.perform.__code__) or
debug):
thunk = node.op.make_py_thunk(node, storage_map, compute_map,
no_recycling, debug=debug)
thunks_py.append(thunk)
else:
thunks_py.append(None)
if not self.maker.mode.check_c_code and thunks_py[-1] is None:
_logger.warn("Op %s doesn't have a perform, "
"forcing check of the C code" % node.op)
thunk = node.op.make_c_thunk(node, storage_map, compute_map,
no_recycling)
thunks_c[-1] = thunk
# If the op defined its own make_thunk, use the generated thunk
if thunk_other is not None:
if thunks_py[-1] is None:
thunks_py[-1] = thunk_other
elif thunks_c[-1] is None:
thunks_c[-1] = thunk_other
else:
_logger.warn("We won't check the perform function "
"of node '%s' but we will check its "
"make_thunk function" % node)
thunks_py[-1] = thunk_other
# Use self.no_recycling (that was passed in accept()) to always
# use new memory storage when it is needed, in particular for the
# function's outputs. no_recycling_map will be used in f() below.
if self.no_recycling is True:
no_recycling_map = list(storage_map.values())
no_recycling_map = utils.difference(no_recycling_map,
input_storage)
else:
no_recycling_map = [storage_map[r] for r in self.no_recycling
if r not in fgraph.inputs]
# Precompute some things for storage pre-allocation
def_val = int(config.unittests.rseed)
#####
# This is the function that runs when you evaluate the graph
#####
def f():
####
# Note: `f` ignores the compute_map and evaluates the nodes in
# topological order. In some sense, this is ok, and can be used
# for now.
#####
_logger.debug("starting a DebugMode call")
_logger.debug("self.maker.mode.check_preallocated_output: %s",
self.maker.mode.check_preallocated_output)
for x in no_recycling_map:
x[0] = None
# nest all this in try-finally to put storage *back* into
# storage_map when an exception is raised
original_storage_map_keys = [r for r in storage_map
if r.owner is None]
try:
# r_vals are the true values associated with each
# variable in the graph they should not change during
# the evaluation of this function, even when the graph
# has destructive ops in it
#
# This dictionary is used to populate the storage_map
# as necessary
r_vals = {}
# dr_vals are the values taken by variables after
# being destroyed
dr_vals = {}
assert len(thunks_py) == len(order)
# transfer the initial values from the storage_map to
# the r_vals
_logger.debug("DEBUGMODE: transfer initial values")
# r_vals_initialized keeps track of the values that have
# actually been transferred from storage_map to r_vals
r_vals_initialized = []
for r in storage_map:
if (r.owner is None):
if not r.type.is_valid_value(storage_map[r][0]):
# None may be a valid input value (for instance,
# for a Generic object). We only want to raise
# an error if it is not valid.
if (storage_map[r][0] is None):
raise InvalidValueError(
r, storage_map[r][0],
hint=("Graph Input '%s' is missing" %
str(r)))
raise InvalidValueError(
r, storage_map[r][0],
hint=("Graph Input '%s' has invalid value "
"%s" % (r, storage_map[r][0])))
r_vals[r] = storage_map[r][0]
storage_map[r][0] = None
r_vals_initialized.append(r)
# store preallocated outputs in another map, and test
# the thunks on them as output storages.
init_outputs = {}
for r in storage_map:
if r in fgraph.outputs:
if storage_map[r][0] is not None:
init_outputs[r] = storage_map[r][0]
storage_map[r][0] = None
#####
# Precondition: the storage map is empty, transferred
# completely to r_vals
#####
for r, s in iteritems(storage_map):
if s[0] is not None:
print(r, s)
assert s[0] is None
# try:
# compute the value of all variables
for i, (thunk_py, thunk_c, node) in enumerate(zip(thunks_py,
thunks_c,
order)):
_logger.debug("%i - starting node %i %s", i, i, node)
# put a copy of each input into the storage_map
# also, check that inputs have valid values
for r in node.inputs:
assert isinstance(r, gof.Variable)
assert r in r_vals
storage_map[r][0] = _lessbroken_deepcopy(r_vals[r])
if not r.type.is_valid_value(storage_map[r][0]):
raise InvalidValueError(r, storage_map[r][0],
client_node=node)
# On the first call to thunk_py(), its output
# storage will be None
if thunk_py:
_logger.debug("%i - running thunk_py with None as "
"output storage", i)
try:
thunk_py()
except (utils.MethodNotDefined, __HOLE__):
# shouldn't have put it into the list in
# the first place
thunk_py = None
thunks_py[i] = None
except Exception as e:
# I think that only 1 optimization can
# insert a given apply node. If that is not True,
# we would need to loop over all node outputs,
# But this make the output uglier.
reason = fgraph.equivalence_tracker.reasons[
node.outputs[0]]
if not reason:
raise
opt = str(reason[0][0])
msg = (
"An optimization (probably %s) inserted an "
"apply node that raise an error." % opt +
"\nThe information we have about this "
"optimizations is:" + str(reason[0][1]) +
"\n" + reason[0][2] +
"\n\nThe original exception: \n" + str(e))
new_e = e.__class__(msg)
exc_type, exc_value, exc_trace = sys.exc_info()
exc_value = new_e
raise_with_op(node, thunk_c,
(exc_type, exc_value, exc_trace))
if thunk_py:
# check output values for type-correctness
for r in node.outputs:
if not r.type.is_valid_value(storage_map[r][0]):
hint2 = r.type.value_validity_msg(
storage_map[r][0])
raise InvalidValueError(r, storage_map[r][0],
hint='perform output',
specific_hint=hint2)
warn_inp = config.DebugMode.warn_input_not_reused
py_inplace_outs = _check_inputs(
node, storage_map, r_vals, dr_vals,
active_order_set,
clobber_dr_vals=True, perform='py',
warn_input_not_reused=warn_inp)
_check_viewmap(node, storage_map)
# Retrieve each output from the storage_map.
# The return values of this first run will be
# the reference ones
for r in node.outputs:
assert r not in r_vals
r_vals[r] = storage_map[r][0]
# clear the storage_map of outputs for the thunk_c
storage_map[r][0] = None
if self.maker.mode.check_preallocated_output:
prealloc_modes = \
self.maker.mode.check_preallocated_output
_logger.debug(
'%i - calling _check_preallocated_output '
'with thunk_py', i)
_check_preallocated_output(
node=node,
thunk=thunk_py,
prealloc_modes=prealloc_modes,
def_val=def_val,
storage_map=storage_map,
r_vals=r_vals,
dr_vals=dr_vals,
perform='py',
active_order_set=active_order_set,
inplace_outs=py_inplace_outs,
init_outputs=init_outputs)
sys.stdout.flush()
if thunk_c:
clobber = True
if thunk_py:
dmap = getattr(node.op, 'destroy_map', {})
vmap = getattr(node.op, 'view_map', {})
for i, r in enumerate(node.inputs):
# if thunk_py ran, and we still got
# this far, it means that the
# destroy_map of the Op (and view_map)
# are accurate so we can assume that
# inputs not marked as destroyed have
# in fact not been destroyed.
# Therefore... we only need to
# overwrite inputs that *have* been
# marked as destroyed. Inputs marked
# as viewd are unsafe too, because the
# corresponding output can be
# destroyed.
if any(i in v for v in chain(dmap.values(),
vmap.values())):
storage_map[r][0] = _lessbroken_deepcopy(
r_vals[r])
clobber = False
_logger.debug("%i - running thunk_c", i)
# First time, with None in output_storage
try:
thunk_c()
except Exception as e:
# I think that only 1 optimization can
# insert a given apply node. If that is not True,
# we would need to loop over all node outputs,
# But this make the output uglier.
reason = fgraph.equivalence_tracker.reasons[
node.outputs[0]]
if not reason:
raise
opt = str(reason[0][0])
msg = (
"An optimization (probably %s) inserted "
"an apply node that raise an error." % opt +
"\nThe information we have about this "
"optimizations is:" + str(reason[0][1]) +
"\n" + reason[0][2] +
"\n\nThe original exception: \n" + str(e))
new_e = e.__class__(msg)
exc_type, exc_value, exc_trace = sys.exc_info()
exc_value = new_e
raise_with_op(node, thunk_c,
(exc_type, exc_value, exc_trace))
for r in node.outputs:
# check output values for type-correctness
if not r.type.is_valid_value(storage_map[r][0]):
raise InvalidValueError(r, storage_map[r][0],
hint='c output')
if thunk_py:
# because we put it in during the
# thunk_py branch
assert r in r_vals
# check for stride correctness (may
# raise exception)
_check_strides_match(
r_vals[r], storage_map[r][0],
self.maker.mode.require_matching_strides,
node.op)
warn_inp = config.DebugMode.warn_input_not_reused
c_inplace_outs = _check_inputs(
node, storage_map, r_vals,
dr_vals, active_order_set,
clobber_dr_vals=clobber, perform='c',
warn_input_not_reused=warn_inp)
_check_viewmap(node, storage_map)
# Check with Python result
for r in node.outputs:
if r in r_vals:
# compares the version from thunk_py
# (in r_vals) to the version produced
# by thunk_c (in storage_map)
if not check_eq(r, r_vals[r],
storage_map[r][0]):
inputs_val = [storage_map[inp][0]
for inp in r.owner.inputs]
raise BadThunkOutput(
r, thunk1='perform', val1=r_vals[r],
thunk2='c_code',
val2=storage_map[r][0],
inputs_val=inputs_val)
else:
# retrieve each output from the storage_map
r_vals[r] = storage_map[r][0]
# clear the storage_map for the thunk_c
storage_map[r][0] = None
if self.maker.mode.check_preallocated_output:
prealloc_modes = \
self.maker.mode.check_preallocated_output
def thunk():
try:
thunk_c()
except Exception:
raise_with_op(node, thunk_c)
_logger.debug(
'%i - calling _check_preallocated_output '
'with thunk_c', i)
_check_preallocated_output(
node=node,
thunk=thunk,
prealloc_modes=prealloc_modes,
def_val=def_val,
storage_map=storage_map,
r_vals=r_vals,
dr_vals=dr_vals,
perform='c code',
active_order_set=active_order_set,
inplace_outs=c_inplace_outs,
init_outputs=init_outputs)
sys.stdout.flush()
# we're done with this thunk
# clear everything out of the storage_map
for r in node.inputs:
storage_map[r][0] = None
_logger.debug("%i - done with node", i)
for r in node.outputs:
if r not in r_vals:
idx = order.index(node)
assert thunks_py[idx] is None, node
assert thunks_c[idx] is None, node
raise Exception("No code run for %s" % node)
if False:
# This could be useful to help finding refcount problem.
# But it is very slow and it is not sure it will help.
gc.collect()
_find_bad_optimizations(order,
fgraph.equivalence_tracker.reasons,
r_vals)
#####
# Postcondition: the input and output variables are
# in the storage map, nothing more
#####
# Nothing should be in storage map after evaluating
# each the thunk (specifically the last one)
for r, s in iteritems(storage_map):
assert type(s) is list
assert s[0] is None
# store our output variables to their respective storage lists
for output, storage in zip(fgraph.outputs, output_storage):
storage[0] = r_vals[output]
# transfer all inputs back to their respective storage lists
for r in r_vals:
if r.owner is None:
if r in fgraph.inputs:
assert (storage_map[r] is
input_storage[fgraph.inputs.index(r)])
storage_map[r][0] = r_vals[r]
# if an input was destroyed, the destroyed value
# should be returned
for r in dr_vals:
assert dr_vals[r][0] is not None
if r.owner is None:
assert r in fgraph.inputs
# HACK TO LOOK LIKE A REAL DESTRUCTIVE ACTION
# TOOK PLACE
if ((type(dr_vals[r][0]) in
(numpy.ndarray, numpy.memmap)) and
(dr_vals[r][0].dtype ==
storage_map[r][0].dtype) and
(dr_vals[r][0].shape ==
storage_map[r][0].shape)):
if len(dr_vals[r][0].shape):
storage_map[r][0][:] = dr_vals[r][0]
else:
storage_map[r][0].itemset(dr_vals[r][0])
else:
storage_map[r][0] = dr_vals[r][0]
except Exception:
# Restore the initial state of storage_map
for r in storage_map:
if r in original_storage_map_keys:
# If r was transferred to r_vals, put it back
if r in r_vals_initialized:
storage_map[r][0] = r_vals[r]
else:
# clear out any partially-computed stuff
storage_map[r][0] = None
raise
for r in storage_map:
if (r.owner is None):
if not r.type.is_valid_value(None):
assert storage_map[r][0] is not None
###############
# Done debugmode function call 'f'
##############
def run_with_tensortype_filter_check(f):
def deco():
# WARNING: this is a global mechanism...
# so it will screw up if we are trying to use
# multiple modes at once.
old_filter_checks_isfinite = TensorType.filter_checks_isfinite
TensorType.filter_checks_isfinite = \
self.maker.mode.check_isfinite
try:
return f()
finally:
# put back the filter_checks_isfinite
TensorType.filter_checks_isfinite = \
old_filter_checks_isfinite
return deco
f = run_with_tensortype_filter_check(f)
f.storage_map = storage_map
f.allow_gc = True
assert len(fgraph.inputs) == len(input_storage)
assert len(fgraph.outputs) == len(output_storage)
return (f,
[link.Container(input, storage, readonly=False)
for input, storage in zip(fgraph.inputs, input_storage)],
[link.Container(output, storage, readonly=True)
for output, storage in zip(fgraph.outputs, output_storage)],
thunks_py, order) | NotImplementedError | dataset/ETHPy150Open rizar/attention-lvcsr/libs/Theano/theano/compile/debugmode.py/_Linker.make_all |
44 | def GenerateOutput(target_list, target_dicts, data, params):
user_config = params.get('generator_flags', {}).get('config', None)
if user_config:
GenerateOutputForConfig(target_list, target_dicts, data,
params, user_config)
else:
config_names = target_dicts[target_list[0]]['configurations'].keys()
if params['parallel']:
try:
pool = multiprocessing.Pool(len(config_names))
arglists = []
for config_name in config_names:
arglists.append((target_list, target_dicts, data,
params, config_name))
pool.map(CallGenerateOutputForConfig, arglists)
except __HOLE__, e:
pool.terminate()
raise e
else:
for config_name in config_names:
GenerateOutputForConfig(target_list, target_dicts, data,
params, config_name) | KeyboardInterrupt | dataset/ETHPy150Open francelabs/datafari/debian7/elk/kibana/node/lib/node_modules/npm/node_modules/node-gyp/gyp/pylib/gyp/generator/cmake.py/GenerateOutput |
45 | @staticmethod
def load(path, name, cluster):
"""
Load a node from from the path on disk to the config files, the node name and the
cluster the node is part of.
"""
node_path = os.path.join(path, name)
filename = os.path.join(node_path, 'node.conf')
with open(filename, 'r') as f:
data = yaml.load(f)
try:
itf = data['interfaces']
initial_token = None
if 'initial_token' in data:
initial_token = data['initial_token']
remote_debug_port = 2000
if 'remote_debug_port' in data:
remote_debug_port = data['remote_debug_port']
binary_interface = None
if 'binary' in itf and itf['binary'] is not None:
binary_interface = tuple(itf['binary'])
node = cluster.create_node(data['name'], data['auto_bootstrap'], tuple(itf['thrift']), tuple(itf['storage']), data['jmx_port'], remote_debug_port, initial_token, save=False, binary_interface=binary_interface, byteman_port=data['byteman_port'])
node.status = data['status']
if 'pid' in data:
node.pid = int(data['pid'])
if 'install_dir' in data:
node.__install_dir = data['install_dir']
if 'config_options' in data:
node.__config_options = data['config_options']
if 'dse_config_options' in data:
node._dse_config_options = data['dse_config_options']
if 'data_center' in data:
node.data_center = data['data_center']
if 'workloads' in data:
node.workloads = data['workloads']
return node
except __HOLE__ as k:
raise common.LoadError("Error Loading " + filename + ", missing property: " + str(k)) | KeyError | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/Node.load |
46 | def print_process_output(self, name, proc, verbose=False):
try:
stderr = proc.communicate()[1]
except __HOLE__:
stderr = ''
if len(stderr) > 1:
print_("[%s ERROR] %s" % (name, stderr.strip()))
# This will return when exprs are found or it timeouts | ValueError | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/Node.print_process_output |
47 | def stress(self, stress_options=None, capture_output=False, whitelist=False,**kwargs):
if stress_options is None:
stress_options = []
else:
stress_options = stress_options[:]
stress = common.get_stress_bin(self.get_install_dir())
if self.cluster.cassandra_version() <= '2.1':
stress_options.append('-d')
stress_options.append(self.address())
else:
stress_options.append('-node')
if whitelist:
stress_options.append("whitelist")
stress_options.append(self.address())
# specify used jmx port if not already set
if not [opt for opt in stress_options if opt.startswith('jmx=')]:
stress_options.extend(['-port', 'jmx=' + self.jmx_port])
args = [stress] + stress_options
try:
if capture_output:
p = subprocess.Popen(args, cwd=common.parse_path(stress),
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
**kwargs)
stdout, stderr = p.communicate()
else:
p = subprocess.Popen(args, cwd=common.parse_path(stress),
**kwargs)
stdout, stderr = None, None
p.wait()
return stdout, stderr
except __HOLE__:
pass | KeyboardInterrupt | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/Node.stress |
48 | def shuffle(self, cmd):
cdir = self.get_install_dir()
shuffle = common.join_bin(cdir, 'bin', 'cassandra-shuffle')
host = self.address()
args = [shuffle, '-h', host, '-p', str(self.jmx_port)] + [cmd]
try:
subprocess.call(args)
except __HOLE__:
pass | KeyboardInterrupt | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/Node.shuffle |
49 | def __update_status(self):
if self.pid is None:
if self.status == Status.UP or self.status == Status.DECOMMISSIONED:
self.status = Status.DOWN
return
old_status = self.status
# os.kill on windows doesn't allow us to ping a process
if common.is_win():
self.__update_status_win()
else:
try:
os.kill(self.pid, 0)
except __HOLE__ as err:
if err.errno == errno.ESRCH:
# not running
if self.status == Status.UP or self.status == Status.DECOMMISSIONED:
self.status = Status.DOWN
elif err.errno == errno.EPERM:
# no permission to signal this process
if self.status == Status.UP or self.status == Status.DECOMMISSIONED:
self.status = Status.DOWN
else:
# some other error
raise err
else:
if self.status == Status.DOWN or self.status == Status.UNINITIALIZED:
self.status = Status.UP
if not old_status == self.status:
if old_status == Status.UP and self.status == Status.DOWN:
self.pid = None
self._update_config() | OSError | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/Node.__update_status |
50 | def _find_pid_on_windows(self):
found = False
try:
import psutil
found = psutil.pid_exists(self.pid)
except __HOLE__:
print_("WARN: psutil not installed. Pid tracking functionality will suffer. See README for details.")
cmd = 'tasklist /fi "PID eq ' + str(self.pid) + '"'
proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
for line in proc.stdout:
if re.match("Image", str(line)):
found = True
return found | ImportError | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/Node._find_pid_on_windows |
51 | def _update_pid(self, process):
pidfile = os.path.join(self.get_path(), 'cassandra.pid')
start = time.time()
while not (os.path.isfile(pidfile) and os.stat(pidfile).st_size > 0):
if (time.time() - start > 30.0):
print_("Timed out waiting for pidfile to be filled (current time is %s)" % (datetime.now()))
break
else:
time.sleep(0.1)
try:
with open(pidfile, 'rb') as f:
if common.is_win() and self.get_base_cassandra_version() >= 2.1:
self.pid = int(f.readline().strip().decode('utf-16').strip())
else:
self.pid = int(f.readline().strip())
except __HOLE__ as e:
raise NodeError('Problem starting node %s due to %s' % (self.name, e), process)
self.__update_status() | IOError | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/Node._update_pid |
52 | def pause(self):
try:
import psutil
p = psutil.Process(self.pid)
p.suspend()
except __HOLE__:
if common.is_win():
print_("WARN: psutil not installed. Pause functionality will not work properly on Windows.")
else:
os.kill(self.pid, signal.SIGSTOP) | ImportError | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/Node.pause |
53 | def resume(self):
try:
import psutil
p = psutil.Process(self.pid)
p.resume()
except __HOLE__:
if common.is_win():
print_("WARN: psutil not installed. Resume functionality will not work properly on Windows.")
else:
os.kill(self.pid, signal.SIGCONT) | ImportError | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/Node.resume |
54 | def _get_load_from_info_output(info):
load_lines = [s for s in info.split('\n')
if s.startswith('Load')]
if not len(load_lines) == 1:
msg = ('Expected output from `nodetool info` to contain exactly 1 '
'line starting with "Load". Found:\n') + info
raise RuntimeError(msg)
load_line = load_lines[0].split()
# Don't have access to C* version here, so we need to support both prefix styles
# See CASSANDRA-9692 on Apache JIRA
unit_multipliers = {'KiB': 1,
'KB': 1,
'MiB': 1024,
'MB': 1024,
'GiB': 1024 * 1024,
'GB': 1024 * 1024,
'TiB': 1024 * 1024 * 1024,
'TB': 1024 * 1024 * 1024}
load_num, load_units = load_line[2], load_line[3]
try:
load_mult = unit_multipliers[load_units]
except __HOLE__:
expected = ', '.join(list(unit_multipliers))
msg = ('Expected `nodetool info` to report load in one of the '
'following units:\n'
' {expected}\n'
'Found:\n'
' {found}').format(expected=expected, found=load_units)
raise RuntimeError(msg)
return float(load_num) * load_mult | KeyError | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/_get_load_from_info_output |
55 | def _grep_log_for_errors(log):
matchings = []
it = iter(log.splitlines())
for line in it:
is_error_line = ('ERROR' in line
and 'DEBUG' not in line.split('ERROR')[0])
if is_error_line:
matchings.append([line])
try:
it, peeker = itertools.tee(it)
while 'INFO' not in next(peeker):
matchings[-1].append(next(it))
except __HOLE__:
break
return matchings | StopIteration | dataset/ETHPy150Open pcmanus/ccm/ccmlib/node.py/_grep_log_for_errors |
56 | def _get__data_sources_names(self):
names = []
for name in self.data_sources:
try:
self.data_sources[name] + 1
names.append(name)
except __HOLE__:
pass
names.sort()
return names
# Dictionnary mapping the views | TypeError | dataset/ETHPy150Open enthought/mayavi/mayavi/tools/data_wizards/data_source_wizard.py/DataSourceWizard._get__data_sources_names |
57 | def _findNode(self, nodeId):
try:
return self.getDispatchTree().nodes[int(nodeId)]
except __HOLE__:
raise NodeNotFoundError(nodeId) | KeyError | dataset/ETHPy150Open mikrosimage/OpenRenderManagement/src/octopus/dispatcher/webservice/nodes.py/NodesResource._findNode |
58 | def iterOnCommands(self):
"""
Cancel each command in a node hierarchy (command is given by a generator on the node)
Each command might be blocked by network pb (or machine swapping) but asynchronous mecanism will
allow other request to be treated between each command cancelation.
"""
try:
# Get next command in generator
cmd = self.gen.next()
cmd.cancel()
tornado.ioloop.IOLoop.instance().add_callback(self.iterOnCommands)
except __HOLE__:
self.finish() | StopIteration | dataset/ETHPy150Open mikrosimage/OpenRenderManagement/src/octopus/dispatcher/webservice/nodes.py/NodeStatusResource.iterOnCommands |
59 | def put(self, nodeId):
data = self.getBodyAsJSON()
try:
paused = data['paused']
except __HOLE__:
raise Http400('Missing entry: "paused".')
except TypeError:
raise Http400('Missing entry: "paused".')
else:
nodeId = int(nodeId)
node = self._findNode(nodeId)
node.setPaused(paused)
self.writeCallback("Paused flag changed.") | KeyError | dataset/ETHPy150Open mikrosimage/OpenRenderManagement/src/octopus/dispatcher/webservice/nodes.py/NodePausedResource.put |
60 | def put(self, nodeId):
'''
| Put a new value for the maxAttempt attribute of a task node
| The new maxAttempt value is taken from request body, for instance : "{ maxAttempt : 10 }"
:param nodeId: id of the task node to update
'''
# Get task object
try:
nodeId = int(nodeId)
node = self._findNode(nodeId)
except NodeNotFoundError:
raise HTTPError(404, "Node not found: %d" % nodeId)
# Get maxAttemtp from request body
data = self.getBodyAsJSON()
try:
maxAttempt = int(data['maxAttempt'])
except __HOLE__, e:
raise HTTPError(400, 'Missing entry: "maxAttempt".')
except (TypeError, ValueError), e:
raise HTTPError(400, 'Invalid type for "maxAttempt", integer expected but %r received (error: %s)' % (data['maxAttempt'], e))
# Update selected node and associated task
if isinstance(node, TaskNode) or isinstance(node, FolderNode):
result = node.setMaxAttempt(maxAttempt)
if result is False:
raise HTTPError(404, "Impossible to set 'maxAttempt' on node %d" % nodeId)
else:
raise HTTPError(404, "Invalid element selected: %r" % type(node))
message = "Attribute maxAttempt of node %d has successfully been updated." % nodeId
self.writeCallback(message) | KeyError | dataset/ETHPy150Open mikrosimage/OpenRenderManagement/src/octopus/dispatcher/webservice/nodes.py/NodeMaxAttemptResource.put |
61 | def __getattr__(self, key):
try:
return self[key]
except __HOLE__:
raise AttributeError(r"'Dict' object has no attribute '%s'" % key) | KeyError | dataset/ETHPy150Open michaelliao/transwarp/transwarp/utils.py/Dict.__getattr__ |
62 | def test_options_without_type(self):
query = self.session.query(self.Character.name).filter(
match({self.Character.name: 0.5, self.Character.info['race']: 0.9},
'Trillian',
options={'boost': 10.0})
)
err = None
try:
str(query)
except __HOLE__ as e:
err = e
msg = "missing match_type. " + \
"It's not allowed to specify options without match_type"
self.assertEquals(str(err), msg) | ValueError | dataset/ETHPy150Open crate/crate-python/src/crate/client/sqlalchemy/tests/match_test.py/SqlAlchemyMatchTest.test_options_without_type |
63 | def conv_TimeField(self, model, field, kwargs):
def time_only(obj):
try:
return obj.time()
except __HOLE__:
return obj
kwargs['filters'].append(time_only)
return f.DateTimeField(widget=form.DateTimePickerWidget(),
format='%H:%M:%S', **kwargs) | AttributeError | dataset/ETHPy150Open syrusakbary/Flask-SuperAdmin/flask_superadmin/model/backends/django/orm.py/AdminModelConverter.conv_TimeField |
64 | def conv_DateTimeField(self, model, field, kwargs):
def time_only(obj):
try:
return obj.time()
except __HOLE__:
return obj
kwargs['filters'].append(time_only)
return f.DateTimeField(widget=form.DateTimePickerWidget(),
format='%H:%M:%S', **kwargs) | AttributeError | dataset/ETHPy150Open syrusakbary/Flask-SuperAdmin/flask_superadmin/model/backends/django/orm.py/AdminModelConverter.conv_DateTimeField |
65 | def conv_DateField(self, model, field, kwargs):
def time_only(obj):
try:
return obj.date()
except __HOLE__:
return obj
kwargs['filters'].append(time_only)
return f.DateField(widget=form.DatePickerWidget(), **kwargs) | AttributeError | dataset/ETHPy150Open syrusakbary/Flask-SuperAdmin/flask_superadmin/model/backends/django/orm.py/AdminModelConverter.conv_DateField |
66 | def conv_USStateField(self, model, field, kwargs):
try:
from django.contrib.localflavor.us.us_states import STATE_CHOICES
except __HOLE__:
STATE_CHOICES = []
return f.SelectField(choices=STATE_CHOICES, **kwargs) | ImportError | dataset/ETHPy150Open syrusakbary/Flask-SuperAdmin/flask_superadmin/model/backends/django/orm.py/AdminModelConverter.conv_USStateField |
67 | def refresh(self):
"""
Refresh the screen.
"""
super(_CursesScreen, self).refresh()
try:
sys.stdout.flush()
except __HOLE__:
pass | IOError | dataset/ETHPy150Open peterbrittain/asciimatics/asciimatics/screen.py/_CursesScreen.refresh |
68 | def _print_at(self, text, x, y):
"""
Print string at the required location.
:param text: The text string to print.
:param x: The x coordinate
:param y: The Y coordinate
"""
# Move the cursor if necessary
msg = ""
if x != self._x or y != self._y:
msg += curses.tparm(self._move_y_x, y, x).decode("utf-8")
msg += text
# Print the text at the required location and update the current
# position. Screen resize can throw IOErrors. These can be safely
# ignored as the screen will be shortly reset anyway.
try:
sys.stdout.write(msg)
except __HOLE__:
pass | IOError | dataset/ETHPy150Open peterbrittain/asciimatics/asciimatics/screen.py/_CursesScreen._print_at |
69 | def refresh(self):
"""
Refresh the screen.
"""
# Flush screen buffer to get all updates after doing the common
# processing. Exact timing of the signal can interrupt the
# flush, raising an EINTR IOError, which we can safely ignore.
super(_BlessedScreen, self).refresh()
try:
sys.stdout.flush()
except __HOLE__:
pass | IOError | dataset/ETHPy150Open peterbrittain/asciimatics/asciimatics/screen.py/_BlessedScreen.refresh |
70 | def get_order_for_user_or_404(user, number):
try:
return queryset_orders_for_user(user).get(number=number)
except __HOLE__:
raise Http404() | ObjectDoesNotExist | dataset/ETHPy150Open django-oscar/django-oscar/src/oscar/apps/dashboard/orders/views.py/get_order_for_user_or_404 |
71 | def handle_line_action(self, request, order, action):
if action not in self.line_actions:
return self.reload_page(error=_("Invalid action"))
# Load requested lines
line_ids = request.POST.getlist('selected_line')
if len(line_ids) == 0:
return self.reload_page(error=_(
"You must select some lines to act on"))
lines = order.lines.filter(id__in=line_ids)
if len(line_ids) != len(lines):
return self.reload_page(error=_("Invalid lines requested"))
# Build list of line quantities
line_quantities = []
for line in lines:
qty = request.POST.get('selected_line_qty_%s' % line.id)
try:
qty = int(qty)
except __HOLE__:
qty = None
if qty is None or qty <= 0:
error_msg = _("The entered quantity for line #%s is not valid")
return self.reload_page(error=error_msg % line.id)
elif qty > line.quantity:
error_msg = _(
"The entered quantity for line #%(line_id)s "
"should not be higher than %(quantity)s")
kwargs = {'line_id': line.id, 'quantity': line.quantity}
return self.reload_page(error=error_msg % kwargs)
line_quantities.append(qty)
return getattr(self, action)(
request, order, lines, line_quantities) | ValueError | dataset/ETHPy150Open django-oscar/django-oscar/src/oscar/apps/dashboard/orders/views.py/OrderDetailView.handle_line_action |
72 | def delete_note(self, request, order):
try:
note = order.notes.get(id=request.POST.get('note_id', None))
except __HOLE__:
messages.error(request, _("Note cannot be deleted"))
else:
messages.info(request, _("Note deleted"))
note.delete()
return self.reload_page() | ObjectDoesNotExist | dataset/ETHPy150Open django-oscar/django-oscar/src/oscar/apps/dashboard/orders/views.py/OrderDetailView.delete_note |
73 | def _populate_port_ha_information(self, context, port, router_id, hags,
user_router_id, modified_interfaces):
subnet_id = port['fixed_ips'][0]['subnet_id']
try:
hag = hags[subnet_id]
except __HOLE__:
# Oops, the subnet_id was not found. Probably because the DB
# insertion of that HA group is still in progress by another
# process and has not been committed to the DB yet.
# Let's retry a few times to see if the DB entry turns up.
LOG.debug('No HA group info for router: %(r_id)s and subnet: '
'%(s_id)s was found when populating HA info for port: '
'%(p_id)s. Will now make additional lookup attempts.',
{'r_id': router_id, 's_id': subnet_id,
'p_id': port['id']})
try:
hag = self._get_ha_group_for_subnet_id(context, router_id,
subnet_id)
except exc.NoResultFound:
hag = None
if hag is None:
LOG.debug('Failed to fetch the HA group info for for router: '
'%(r_id)s and subnet: %(s_id)s. Giving up. No HA '
'info will be added to the router\'s port: %s.',
{'r_id': router_id, 's_id': subnet_id,
'p_id': port['id']})
# we leave it to the L3 config agent to handle this
return
else:
LOG.debug('Successfully fetched the HA group info for '
'router: %(r_id)s and subnet: %(s_id)s from DB',
{'r_id': router_id, 's_id': subnet_id})
hags[subnet_id] = hag
if router_id == user_router_id:
# If the router interface need no dedicated IP address we just
# set the HA (VIP) port to the port itself. The config agent
# driver will know how to handle this "signal".
p_id = hag.extra_port_id or port['id']
try:
interface_port = self._core_plugin.get_port(context, p_id)
except n_exc.PortNotFound:
LOG.debug('**** NO Port Info for '
'router: %(r_id)s : Port: %(p_id)s from DB',
{'r_id': router_id, 'p_id': port['id']})
return
LOG.debug('**** Fetched Port Info for '
'router: %(r_id)s : Port: %(p_id)s from DB',
{'r_id': router_id, 'p_id': port['id']})
self._populate_mtu_and_subnets_for_ports(context, [interface_port])
modified_interfaces.append(interface_port)
ha_port = port
else:
try:
ha_port = self._core_plugin.get_port(context, hag.ha_port_id)
except n_exc.PortNotFound:
LOG.debug('**** NO Port Info for '
'router(BAK): %(r_id)s : Port: %(p_id)s from DB',
{'r_id': router_id, 'p_id': hag.ha_port_id})
return
LOG.debug('**** Fetched Port Info for '
'router(BAK): %(r_id)s : Port: %(p_id)s from DB',
{'r_id': router_id, 'p_id': hag.ha_port_id})
self._populate_mtu_and_subnets_for_ports(context, [ha_port])
interface_port = port
interface_port[ha.HA_INFO] = {
ha.TYPE: hag.ha_type,
HA_GROUP: hag.group_identity,
'timers_config': hag.timers_config,
'tracking_config': hag.tracking_config,
'other_config': hag.other_config,
HA_PORT: ha_port}
return interface_port | KeyError | dataset/ETHPy150Open openstack/networking-cisco/networking_cisco/plugins/cisco/db/l3/ha_db.py/HA_db_mixin._populate_port_ha_information |
74 | @gen_test
def test_websocket_handler_bad_token(self):
"""
A bad token should returns a 401 during a websocket connect
"""
token = 'A'*32
url = 'ws://127.0.0.1:{0}/hook/{1}'.format(self.get_http_port(), token)
request = HTTPRequest(url, headers={'Origin': 'http://example.com',
'Host': 'example.com'})
try:
ws = yield websocket_connect(request)
except __HOLE__ as error:
self.assertEqual(error.code, 401) | HTTPError | dataset/ETHPy150Open saltstack/salt/tests/unit/netapi/rest_tornado/test_handlers.py/TestWebsocketSaltAPIHandler.test_websocket_handler_bad_token |
75 | @gen_test
def test_cors_origin_single(self):
self._app.mod_opts['cors_origin'] = 'http://example.com'
response = yield self.http_client.fetch(self.get_url('/login'),
method='POST',
body=urlencode(self.auth_creds),
headers={'Content-Type': self.content_type_map['form']})
token = json.loads(response.body)['return'][0]['token']
url = 'ws://127.0.0.1:{0}/hook/{1}'.format(self.get_http_port(), token)
# Example.com should works
request = HTTPRequest(url, headers={'Origin': 'http://example.com',
'Host': 'example.com'})
ws = yield websocket_connect(request)
ws.write_message('websocket client ready')
ws.close()
# But foo.bar not
request = HTTPRequest(url, headers={'Origin': 'http://foo.bar',
'Host': 'example.com'})
try:
ws = yield websocket_connect(request)
except __HOLE__ as error:
self.assertEqual(error.code, 403) | HTTPError | dataset/ETHPy150Open saltstack/salt/tests/unit/netapi/rest_tornado/test_handlers.py/TestWebsocketSaltAPIHandler.test_cors_origin_single |
76 | @workflow
def operation_mapping3(ctx, value, **_):
def expect_error(func):
try:
func('test.operation', kwargs={
'value': value
}).get()
except __HOLE__, e:
assert 'Duplicate' in e.message
node1 = list(ctx.get_node('node1').instances)[0]
node2_rel = list(list(ctx.get_node('node2').instances)[0].relationships)[0]
node3_rel = list(list(ctx.get_node('node3').instances)[0].relationships)[0]
expect_error(node1.execute_operation)
expect_error(node2_rel.execute_source_operation)
expect_error(node3_rel.execute_target_operation) | RuntimeError | dataset/ETHPy150Open cloudify-cosmo/cloudify-manager/tests/mock_plugins/mock_workflows/workflows.py/operation_mapping3 |
77 | def is_superuser_staff_or_in_translators_group(user):
if not getattr(settings, 'ROSETTA_REQUIRES_AUTH', True):
return True
try:
if not user.is_authenticated():
return False
elif user.is_superuser and user.is_staff:
return True
else:
return user.groups.filter(name='translators').exists()
except __HOLE__:
if not hasattr(user, 'is_authenticated') or not hasattr(user, 'is_superuser') or not hasattr(user, 'groups'):
raise ImproperlyConfigured('If you are using custom User Models you must implement a custom authentication method for Rosetta. See ROSETTA_ACCESS_CONTROL_FUNCTION here: https://django-rosetta.readthedocs.org/en/latest/settings.html')
raise | AttributeError | dataset/ETHPy150Open mbi/django-rosetta/rosetta/access.py/is_superuser_staff_or_in_translators_group |
78 | def can_translate_language(user, langid):
try:
if not rosetta_settings.ROSETTA_LANGUAGE_GROUPS:
return can_translate(user)
elif not user.is_authenticated():
return False
elif user.is_superuser and user.is_staff:
return True
else:
return user.groups.filter(name='translators-%s' % langid).exists()
except __HOLE__:
if not hasattr(user, 'is_authenticated') or not hasattr(user, 'is_superuser') or not hasattr(user, 'groups'):
raise ImproperlyConfigured('If you are using custom User Models you must implement a custom authentication method for Rosetta. See ROSETTA_ACCESS_CONTROL_FUNCTION here: https://django-rosetta.readthedocs.org/en/latest/settings.html')
raise | AttributeError | dataset/ETHPy150Open mbi/django-rosetta/rosetta/access.py/can_translate_language |
79 | def create_authn_response(self, identity, in_response_to, destination,
sp_entity_id, name_id_policy=None, userid=None,
name_id=None, authn=None, issuer=None,
sign_response=None, sign_assertion=None,
encrypt_cert=None, encrypt_assertion=None,
**kwargs):
""" Constructs an AuthenticationResponse
:param identity: Information about an user
:param in_response_to: The identifier of the authentication request
this response is an answer to.
:param destination: Where the response should be sent
:param sp_entity_id: The entity identifier of the Service Provider
:param name_id_policy: How the NameID should be constructed
:param userid: The subject identifier
:param authn: Dictionary with information about the authentication
context
:param issuer: Issuer of the response
:param sign_assertion: Whether the assertion should be signed or not.
:param sign_response: Whether the response should be signed or not.
:return: A response instance
"""
try:
policy = kwargs["release_policy"]
except KeyError:
policy = self.config.getattr("policy", "idp")
try:
best_effort = kwargs["best_effort"]
except KeyError:
best_effort = False
if sign_assertion is None:
sign_assertion = self.config.getattr("sign_assertion", "idp")
if sign_assertion is None:
sign_assertion = False
if sign_response is None:
sign_response = self.config.getattr("sign_response", "idp")
if sign_response is None:
sign_response = False
if encrypt_assertion is None:
encrypt_assertion = self.config.getattr("encrypt_assertion", "idp")
if encrypt_assertion is None:
encrypt_assertion = False
if encrypt_assertion:
if encrypt_cert is not None:
verify_encrypt_cert = self.config.getattr("verify_encrypt_cert", "idp")
if verify_encrypt_cert is not None:
if not verify_encrypt_cert(encrypt_cert):
raise CertificateError("Invalid certificate for encryption!")
else:
raise CertificateError("No SPCertEncType certificate for encryption contained in authentication "
"request.")
else:
encrypt_assertion = False
if not name_id:
try:
nid_formats = []
for _sp in self.metadata[sp_entity_id]["spsso_descriptor"]:
if "name_id_format" in _sp:
nid_formats.extend([n["text"] for n in
_sp["name_id_format"]])
try:
snq = name_id_policy.sp_name_qualifier
except AttributeError:
snq = sp_entity_id
if not snq:
snq = sp_entity_id
kwa = {"sp_name_qualifier": snq}
try:
kwa["format"] = name_id_policy.format
except __HOLE__:
pass
_nids = self.ident.find_nameid(userid, **kwa)
# either none or one
if _nids:
name_id = _nids[0]
else:
name_id = self.ident.construct_nameid(userid, policy,
sp_entity_id,
name_id_policy)
logger.debug("construct_nameid: %s => %s" % (userid,
name_id))
except IOError, exc:
response = self.create_error_response(in_response_to,
destination,
sp_entity_id,
exc, name_id)
return ("%s" % response).split("\n")
try:
_authn = authn
if (sign_assertion or sign_response) and self.sec.cert_handler.generate_cert():
with self.lock:
self.sec.cert_handler.update_cert(True)
return self._authn_response(in_response_to, # in_response_to
destination, # consumer_url
sp_entity_id, # sp_entity_id
identity, # identity as dictionary
name_id,
authn=_authn,
issuer=issuer,
policy=policy,
sign_assertion=sign_assertion,
sign_response=sign_response,
best_effort=best_effort,
encrypt_assertion=encrypt_assertion,
encrypt_cert=encrypt_cert)
return self._authn_response(in_response_to, # in_response_to
destination, # consumer_url
sp_entity_id, # sp_entity_id
identity, # identity as dictionary
name_id,
authn=_authn,
issuer=issuer,
policy=policy,
sign_assertion=sign_assertion,
sign_response=sign_response,
best_effort=best_effort,
encrypt_assertion=encrypt_assertion,
encrypt_cert=encrypt_cert)
except MissingValue, exc:
return self.create_error_response(in_response_to, destination,
sp_entity_id, exc, name_id) | AttributeError | dataset/ETHPy150Open cloudera/hue/desktop/core/ext-py/pysaml2-2.4.0/src/saml2/server.py/Server.create_authn_response |
80 | def create_assertion_id_request_response(self, assertion_id, sign=False,
**kwargs):
"""
:param assertion_id:
:param sign:
:return:
"""
try:
(assertion, to_sign) = self.session_db.get_assertion(assertion_id)
except __HOLE__:
raise Unknown
if to_sign:
if assertion.signature is None:
assertion.signature = pre_signature_part(assertion.id,
self.sec.my_cert, 1)
return signed_instance_factory(assertion, self.sec, to_sign)
else:
return assertion
#noinspection PyUnusedLocal | KeyError | dataset/ETHPy150Open cloudera/hue/desktop/core/ext-py/pysaml2-2.4.0/src/saml2/server.py/Server.create_assertion_id_request_response |
81 | def clean_out_user(self, name_id):
"""
Remove all authentication statements that belongs to a user identified
by a NameID instance
:param name_id: NameID instance
:return: The local identifier for the user
"""
lid = self.ident.find_local_id(name_id)
logger.info("Clean out %s" % lid)
# remove the authentications
try:
for _nid in [decode(x) for x in self.ident.db[lid].split(" ")]:
try:
self.session_db.remove_authn_statements(_nid)
except KeyError:
pass
except __HOLE__:
pass
return lid | KeyError | dataset/ETHPy150Open cloudera/hue/desktop/core/ext-py/pysaml2-2.4.0/src/saml2/server.py/Server.clean_out_user |
82 | def cpu_count():
'''
Returns the number of CPUs in the system
'''
if sys.platform == 'win32':
try:
num = int(os.environ['NUMBER_OF_PROCESSORS'])
except (ValueError, KeyError):
num = 0
elif 'bsd' in sys.platform or sys.platform == 'darwin':
comm = '/sbin/sysctl -n hw.ncpu'
if sys.platform == 'darwin':
comm = '/usr' + comm
try:
with os.popen(comm) as p:
num = int(p.read())
except ValueError:
num = 0
else:
try:
num = os.sysconf('SC_NPROCESSORS_ONLN')
except (__HOLE__, OSError, AttributeError):
num = 0
if num >= 1:
return num
else:
raise NotImplementedError('cannot determine number of cpus') | ValueError | dataset/ETHPy150Open benoitc/flower/flower/util.py/cpu_count |
83 | def extract_text(escaped_html_str):
notes = xml.sax.saxutils.unescape(escaped_html_str)
try:
from PyQt4 import QtGui
except __HOLE__:
return str(notes)
else:
fragment = QtGui.QTextDocumentFragment.fromHtml(notes)
return str(fragment.toPlainText())
# The queries are old and are preserved for reference. Some code is
# quite old (references to vis_application, for example). | ImportError | dataset/ETHPy150Open VisTrails/VisTrails/vistrails/core/query/__init__.py/extract_text |
84 | @defer.inlineCallbacks
def on_PUT(self, request, txn_id):
try:
defer.returnValue(
self.txns.get_client_transaction(request, txn_id)
)
except __HOLE__:
pass
response = yield self.on_POST(request)
self.txns.store_client_transaction(request, txn_id, response)
defer.returnValue(response) | KeyError | dataset/ETHPy150Open matrix-org/synapse/synapse/rest/client/v1/room.py/RoomCreateRestServlet.on_PUT |
85 | @defer.inlineCallbacks
def on_PUT(self, request, room_id, event_type, txn_id):
try:
defer.returnValue(
self.txns.get_client_transaction(request, txn_id)
)
except __HOLE__:
pass
response = yield self.on_POST(request, room_id, event_type, txn_id)
self.txns.store_client_transaction(request, txn_id, response)
defer.returnValue(response)
# TODO: Needs unit testing for room ID + alias joins | KeyError | dataset/ETHPy150Open matrix-org/synapse/synapse/rest/client/v1/room.py/RoomSendEventRestServlet.on_PUT |
86 | @defer.inlineCallbacks
def on_PUT(self, request, room_identifier, txn_id):
try:
defer.returnValue(
self.txns.get_client_transaction(request, txn_id)
)
except __HOLE__:
pass
response = yield self.on_POST(request, room_identifier, txn_id)
self.txns.store_client_transaction(request, txn_id, response)
defer.returnValue(response)
# TODO: Needs unit testing | KeyError | dataset/ETHPy150Open matrix-org/synapse/synapse/rest/client/v1/room.py/JoinRoomAliasServlet.on_PUT |
87 | @defer.inlineCallbacks
def on_PUT(self, request, room_id, membership_action, txn_id):
try:
defer.returnValue(
self.txns.get_client_transaction(request, txn_id)
)
except __HOLE__:
pass
response = yield self.on_POST(
request, room_id, membership_action, txn_id
)
self.txns.store_client_transaction(request, txn_id, response)
defer.returnValue(response) | KeyError | dataset/ETHPy150Open matrix-org/synapse/synapse/rest/client/v1/room.py/RoomMembershipRestServlet.on_PUT |
88 | @defer.inlineCallbacks
def on_PUT(self, request, room_id, event_id, txn_id):
try:
defer.returnValue(
self.txns.get_client_transaction(request, txn_id)
)
except __HOLE__:
pass
response = yield self.on_POST(request, room_id, event_id, txn_id)
self.txns.store_client_transaction(request, txn_id, response)
defer.returnValue(response) | KeyError | dataset/ETHPy150Open matrix-org/synapse/synapse/rest/client/v1/room.py/RoomRedactEventRestServlet.on_PUT |
89 | def get_connection(self, address):
try:
return self.connections[address]
except __HOLE__:
return None | KeyError | dataset/ETHPy150Open hazelcast/hazelcast-python-client/hazelcast/connection.py/ConnectionManager.get_connection |
90 | def get_or_connect(self, address, authenticator=None):
if address in self.connections:
return ImmediateFuture(self.connections[address])
else:
with self._new_connection_mutex:
if address in self._pending_connections:
return self._pending_connections[address]
else:
authenticator = authenticator or self._cluster_authenticator
connection = self._new_connection_func(address,
connection_closed_callback=self._connection_closed,
message_callback=self._client.invoker._handle_client_message)
def on_auth(f):
if f.is_success():
self.logger.info("Authenticated with %s", f.result())
with self._new_connection_mutex:
self.connections[connection.endpoint] = f.result()
self._pending_connections.pop(address)
for on_connection_opened, _ in self._connection_listeners:
if on_connection_opened:
on_connection_opened(f.resul())
return f.result()
else:
self.logger.debug("Error opening %s", connection)
with self._new_connection_mutex:
try:
self._pending_connections.pop(address)
except __HOLE__:
pass
raise f.exception(), None, f.traceback()
future = authenticator(connection).continue_with(on_auth)
if not future.done():
self._pending_connections[address] = future
return future | KeyError | dataset/ETHPy150Open hazelcast/hazelcast-python-client/hazelcast/connection.py/ConnectionManager.get_or_connect |
91 | def close_connection(self, address, cause):
try:
connection = self.connections[address]
connection.close(cause)
except __HOLE__:
logging.warn("No connection with %s was found to close.", address)
return False | KeyError | dataset/ETHPy150Open hazelcast/hazelcast-python-client/hazelcast/connection.py/ConnectionManager.close_connection |
92 | def _inner_acquire(self, blocking, timeout):
# make sure our election parent node exists
if not self.assured_path:
self._ensure_path()
node = None
if self.create_tried:
node = self._find_node()
else:
self.create_tried = True
if not node:
node = self.client.create(self.create_path, self.data,
ephemeral=True, sequence=True)
# strip off path to node
node = node[len(self.path) + 1:]
self.node = node
while True:
self.wake_event.clear()
# bail out with an exception if cancellation has been requested
if self.cancelled:
raise CancelledError()
children = self._get_sorted_children()
try:
our_index = children.index(node)
except __HOLE__: # pragma: nocover
# somehow we aren't in the children -- probably we are
# recovering from a session failure and our ephemeral
# node was removed
raise ForceRetryError()
if self.acquired_lock(children, our_index):
return True
if not blocking:
return False
# otherwise we are in the mix. watch predecessor and bide our time
predecessor = self.path + "/" + children[our_index - 1]
self.client.add_listener(self._watch_session)
try:
if self.client.exists(predecessor, self._watch_predecessor):
self.wake_event.wait(timeout)
if not self.wake_event.isSet():
raise LockTimeout("Failed to acquire lock on %s after %s "
"seconds" % (self.path, timeout))
finally:
self.client.remove_listener(self._watch_session) | ValueError | dataset/ETHPy150Open cloudera/hue/desktop/core/ext-py/kazoo-2.0/kazoo/recipe/lock.py/Lock._inner_acquire |
93 | def _ensure_path(self):
result = self.client.ensure_path(self.path)
self.assured_path = True
if result is True:
# node did already exist
data, _ = self.client.get(self.path)
try:
leases = int(data.decode('utf-8'))
except (ValueError, __HOLE__):
# ignore non-numeric data, maybe the node data is used
# for other purposes
pass
else:
if leases != self.max_leases:
raise ValueError(
"Inconsistent max leases: %s, expected: %s" %
(leases, self.max_leases)
)
else:
self.client.set(self.path, str(self.max_leases).encode('utf-8')) | TypeError | dataset/ETHPy150Open cloudera/hue/desktop/core/ext-py/kazoo-2.0/kazoo/recipe/lock.py/Semaphore._ensure_path |
94 | def get_partition_names(self, model):
current = model._partition_manager.current_partition_key
next = model._partition_manager.next_partition_key
current_only = self.options.get('current_only')
next_only = self.options.get('next_only')
if current_only and next_only:
raise CommandError(
u'You cannot specify current_only and next_only togethers')
try:
partition_names = [self.args[1]]
except __HOLE__:
partition_names = None
if current_only:
partition_names = [current()]
elif next_only:
partition_names = [next()]
elif not partition_names:
# No explicit partition names given, use current and next
partition_names = [current(), next()]
return partition_names | IndexError | dataset/ETHPy150Open danfairs/django-parting/parting/management/commands/ensure_partition.py/Command.get_partition_names |
95 | def get_model(self):
try:
model = self.args[0]
except IndexError:
raise CommandError(u'Please supply at least one partitioned model')
try:
module_name, model_name = model.rsplit('.', 1)
except ValueError:
raise CommandError('Bad model name {}'.format(model))
# So - we can't use get_model, because this will be an abstract model.
# Try to grab the model directly from the module.
module = importlib.import_module(module_name)
try:
m = getattr(module, model_name)
except __HOLE__:
raise CommandError('Unknown model {}'.format(model))
return m | AttributeError | dataset/ETHPy150Open danfairs/django-parting/parting/management/commands/ensure_partition.py/Command.get_model |
96 | @logging_level.setter
def logging_level(self, value):
if value is None:
value = self._default_logging_level
if type(value) is str:
try:
level = _levelNames[value.upper()]
except KeyError:
raise ValueError('Unrecognized logging level: %s' % value)
else:
try:
level = int(value)
except __HOLE__:
raise ValueError('Unrecognized logging level: %s' % value)
self.logger.setLevel(level)
return | ValueError | dataset/ETHPy150Open hvandenb/splunk-elasticsearch/search-elasticsearch/bin/splunklib/searchcommands/search_command.py/SearchCommand.logging_level |
97 | @property
def search_results_info(self):
""" Returns the search results info for this command invocation or None.
The search results info object is created from the search results info
file associated with the command invocation. Splunk does not pass the
location of this file by default. You must request it by specifying
these configuration settings in commands.conf:
.. code-block:: python
enableheader=true
requires_srinfo=true
The :code:`enableheader` setting is :code:`true` by default. Hence, you
need not set it. The :code:`requires_srinfo` setting is false by
default. Hence, you must set it.
:return: :class:`SearchResultsInfo`, if :code:`enableheader` and
:code:`requires_srinfo` are both :code:`true`. Otherwise, if either
:code:`enableheader` or :code:`requires_srinfo` are :code:`false`,
a value of :code:`None` is returned.
"""
if self._search_results_info is not None:
return self._search_results_info
try:
info_path = self.input_header['infoPath']
except KeyError:
return None
def convert_field(field):
return (field[1:] if field[0] == '_' else field).replace('.', '_')
def convert_value(field, value):
if field == 'countMap':
split = value.split(';')
value = dict((key, int(value))
for key, value in zip(split[0::2], split[1::2]))
elif field == 'vix_families':
value = ElementTree.fromstring(value)
elif value == '':
value = None
else:
try:
value = float(value)
if value.is_integer():
value = int(value)
except __HOLE__:
pass
return value
with open(info_path, 'rb') as f:
from collections import namedtuple
import csv
reader = csv.reader(f, dialect='splunklib.searchcommands')
fields = [convert_field(x) for x in reader.next()]
values = [convert_value(f, v) for f, v in zip(fields, reader.next())]
search_results_info_type = namedtuple('SearchResultsInfo', fields)
self._search_results_info = search_results_info_type._make(values)
return self._search_results_info | ValueError | dataset/ETHPy150Open hvandenb/splunk-elasticsearch/search-elasticsearch/bin/splunklib/searchcommands/search_command.py/SearchCommand.search_results_info |
98 | def process(self, args=argv, input_file=stdin, output_file=stdout):
""" Processes search results as specified by command arguments.
:param args: Sequence of command arguments
:param input_file: Pipeline input file
:param output_file: Pipeline output file
"""
self.logger.debug(u'%s arguments: %s', type(self).__name__, args)
self._configuration = None
self._output_file = output_file
try:
if len(args) >= 2 and args[1] == '__GETINFO__':
ConfigurationSettings, operation, args, reader = self._prepare(args, input_file=None)
self.parser.parse(args, self)
self._configuration = ConfigurationSettings(self)
writer = splunk_csv.DictWriter(output_file, self, self.configuration.keys(), mv_delimiter=',')
writer.writerow(self.configuration.items())
elif len(args) >= 2 and args[1] == '__EXECUTE__':
self.input_header.read(input_file)
ConfigurationSettings, operation, args, reader = self._prepare(args, input_file)
self.parser.parse(args, self)
self._configuration = ConfigurationSettings(self)
if self.show_configuration:
self.messages.append(
'info_message', '%s command configuration settings: %s'
% (self.name, self._configuration))
writer = splunk_csv.DictWriter(output_file, self)
self._execute(operation, reader, writer)
else:
file_name = path.basename(args[0])
message = (
u'Command {0} appears to be statically configured and static '
u'configuration is unsupported by splunklib.searchcommands. '
u'Please ensure that default/commands.conf contains this '
u'stanza:\n'
u'[{0}]\n'
u'filename = {1}\n'
u'supports_getinfo = true\n'
u'supports_rawargs = true\n'
u'outputheader = true'.format(type(self).name, file_name))
raise NotImplementedError(message)
except __HOLE__:
raise
except:
import traceback
import sys
error_type, error_message, error_traceback = sys.exc_info()
self.logger.error(traceback.format_exc(error_traceback))
origin = error_traceback
while origin.tb_next is not None:
origin = origin.tb_next
filename = origin.tb_frame.f_code.co_filename
lineno = origin.tb_lineno
self.write_error('%s at "%s", line %d : %s', error_type.__name__, filename, lineno, error_message)
exit(1)
return | SystemExit | dataset/ETHPy150Open hvandenb/splunk-elasticsearch/search-elasticsearch/bin/splunklib/searchcommands/search_command.py/SearchCommand.process |
99 | def create_transformer_classes(transformer_spec, config_globals, increment_id):
"""Create an importer and exporter class from a transformer spec.
Args:
transformer_spec: A bulkloader_parser.TransformerEntry.
config_globals: Dict to use to reference globals for code in the config.
increment_id: Method IncrementId(key) which will increment the
auto-allocated ids in the datastore beyond the key.id(). Can be None.
Raises:
InvalidConfig: when the config is invalid.
Returns:
Tuple, (importer class, exporter class), each which is in turn a wrapper
for the GenericImporter/GenericExporter class using a DictConvertor object
configured as per the transformer_spec.
"""
if transformer_spec.connector in CONNECTOR_FACTORIES:
connector_factory = CONNECTOR_FACTORIES[transformer_spec.connector]
elif config_globals and '.' in transformer_spec.connector:
try:
connector_factory = eval(transformer_spec.connector, config_globals)
except (__HOLE__, AttributeError):
raise bulkloader_errors.InvalidConfiguration(
'Invalid connector specified for name=%s. Could not evaluate %s.' %
(transformer_spec.name, transformer_spec.connector))
else:
raise bulkloader_errors.InvalidConfiguration(
'Invalid connector specified for name=%s. Must be either a built in '
'connector ("%s") or a factory method in a module imported via '
'python_preamble.' %
(transformer_spec.name, '", "'.join(CONNECTOR_FACTORIES)))
options = {}
if transformer_spec.connector_options:
options = transformer_spec.connector_options.ToDict()
try:
connector_object = connector_factory(options, transformer_spec.name)
except TypeError:
raise bulkloader_errors.InvalidConfiguration(
'Invalid connector specified for name=%s. Could not initialize %s.' %
(transformer_spec.name, transformer_spec.connector))
dict_to_model_object = DictConvertor(transformer_spec)
class ImporterClass(GenericImporter):
"""Class to pass to the bulkloader, wraps the specificed configuration."""
def __init__(self):
super(self.__class__, self).__init__(
connector_object.generate_import_record,
dict_to_model_object.dict_to_entity,
transformer_spec.name,
increment_id)
importer_class = ImporterClass
class ExporterClass(GenericExporter):
"""Class to pass to the bulkloader, wraps the specificed configuration."""
def __init__(self):
super(self.__class__, self).__init__(
connector_object,
dict_to_model_object.entity_to_dict,
transformer_spec.kind,
transformer_spec.sort_key_from_entity)
exporter_class = ExporterClass
return importer_class, exporter_class | NameError | dataset/ETHPy150Open AppScale/appscale/AppServer/google/appengine/ext/bulkload/bulkloader_config.py/create_transformer_classes |