Unnamed: 0
int64 0
10k
| function
stringlengths 79
138k
| label
stringclasses 20
values | info
stringlengths 42
261
|
|---|---|---|---|
4,900 | def set_body_reader(self):
chunked = False
content_length = None
for (name, value) in self.headers:
if name == "CONTENT-LENGTH":
content_length = value
elif name == "TRANSFER-ENCODING":
chunked = value.lower() == "chunked"
elif name == "SEC-WEBSOCKET-KEY1":
content_length = 8
if chunked:
self.body = Body(ChunkedReader(self, self.unreader))
elif content_length is not None:
try:
content_length = int(content_length)
except __HOLE__:
raise InvalidHeader("CONTENT-LENGTH", req=self)
if content_length < 0:
raise InvalidHeader("CONTENT-LENGTH", req=self)
self.body = Body(LengthReader(self.unreader, content_length))
else:
self.body = Body(EOFReader(self.unreader)) | ValueError | dataset/ETHPy150Open chalasr/Flask-P2P/venv/lib/python2.7/site-packages/gunicorn/http/message.py/Message.set_body_reader |
4,901 | def parse_proxy_protocol(self, line):
bits = line.split()
if len(bits) != 6:
raise InvalidProxyLine(line)
# Extract data
proto = bits[1]
s_addr = bits[2]
d_addr = bits[3]
# Validation
if proto not in ["TCP4", "TCP6"]:
raise InvalidProxyLine("protocol '%s' not supported" % proto)
if proto == "TCP4":
try:
socket.inet_pton(socket.AF_INET, s_addr)
socket.inet_pton(socket.AF_INET, d_addr)
except socket.error:
raise InvalidProxyLine(line)
elif proto == "TCP6":
try:
socket.inet_pton(socket.AF_INET6, s_addr)
socket.inet_pton(socket.AF_INET6, d_addr)
except socket.error:
raise InvalidProxyLine(line)
try:
s_port = int(bits[4])
d_port = int(bits[5])
except __HOLE__:
raise InvalidProxyLine("invalid port %s" % line)
if not ((0 <= s_port <= 65535) and (0 <= d_port <= 65535)):
raise InvalidProxyLine("invalid port %s" % line)
# Set data
self.proxy_protocol_info = {
"proxy_protocol": proto,
"client_addr": s_addr,
"client_port": s_port,
"proxy_addr": d_addr,
"proxy_port": d_port
} | ValueError | dataset/ETHPy150Open chalasr/Flask-P2P/venv/lib/python2.7/site-packages/gunicorn/http/message.py/Request.parse_proxy_protocol |
4,902 | def form_invalid(self, form):
result = super(SingleObjectCreateView, self).form_invalid(form)
try:
messages.error(
self.request,
_('Error creating new %s.') % self.extra_context['object_name']
)
except __HOLE__:
messages.error(self.request, _('Error creating object.'))
return result | KeyError | dataset/ETHPy150Open mayan-edms/mayan-edms/mayan/apps/common/generics.py/SingleObjectCreateView.form_invalid |
4,903 | def form_valid(self, form):
# This overrides the original Django form_valid method
self.object = form.save(commit=False)
if hasattr(self, 'get_instance_extra_data'):
for key, value in self.get_instance_extra_data().items():
setattr(self.object, key, value)
if hasattr(self, 'get_save_extra_data'):
save_extra_data = self.get_save_extra_data()
else:
save_extra_data = {}
self.object.save(**save_extra_data)
try:
messages.success(
self.request,
_(
'%s created successfully.'
) % self.extra_context['object_name']
)
except __HOLE__:
messages.success(
self.request, _('New object created successfully.')
)
return HttpResponseRedirect(self.get_success_url()) | KeyError | dataset/ETHPy150Open mayan-edms/mayan-edms/mayan/apps/common/generics.py/SingleObjectCreateView.form_valid |
4,904 | def delete(self, request, *args, **kwargs):
try:
result = super(SingleObjectDeleteView, self).delete(request, *args, **kwargs)
except Exception as exception:
try:
messages.error(
self.request,
_('Error deleting %s.') % self.extra_context['object_name']
)
except KeyError:
messages.error(
self.request, _('Error deleting object.')
)
raise exception
else:
try:
messages.success(
self.request,
_(
'%s deleted successfully.'
) % self.extra_context['object_name']
)
except __HOLE__:
messages.success(
self.request, _('Object deleted successfully.')
)
return result | KeyError | dataset/ETHPy150Open mayan-edms/mayan-edms/mayan/apps/common/generics.py/SingleObjectDeleteView.delete |
4,905 | def form_invalid(self, form):
result = super(SingleObjectEditView, self).form_invalid(form)
try:
messages.error(
self.request,
_(
'Error saving %s details.'
) % self.extra_context['object_name']
)
except __HOLE__:
messages.error(
self.request, _('Error saving details.')
)
return result | KeyError | dataset/ETHPy150Open mayan-edms/mayan-edms/mayan/apps/common/generics.py/SingleObjectEditView.form_invalid |
4,906 | def form_valid(self, form):
# This overrides the original Django form_valid method
self.object = form.save(commit=False)
if hasattr(self, 'get_instance_extra_data'):
for key, value in self.get_instance_extra_data().items():
setattr(self.object, key, value)
if hasattr(self, 'get_save_extra_data'):
save_extra_data = self.get_save_extra_data()
else:
save_extra_data = {}
self.object.save(**save_extra_data)
try:
messages.success(
self.request,
_(
'%s details saved successfully.'
) % self.extra_context['object_name']
)
except __HOLE__:
messages.success(
self.request, _('Details saved successfully.')
)
return HttpResponseRedirect(self.get_success_url()) | KeyError | dataset/ETHPy150Open mayan-edms/mayan-edms/mayan/apps/common/generics.py/SingleObjectEditView.form_valid |
4,907 | def _kurtosis(a):
'''wrapper for scipy.stats.kurtosis that returns nan instead of raising Error
missing options
'''
try:
res = stats.kurtosis(a)
except __HOLE__:
res = np.nan
return res | ValueError | dataset/ETHPy150Open statsmodels/statsmodels/statsmodels/stats/descriptivestats.py/_kurtosis |
4,908 | def _skew(a):
'''wrapper for scipy.stats.skew that returns nan instead of raising Error
missing options
'''
try:
res = stats.skew(a)
except __HOLE__:
res = np.nan
return res | ValueError | dataset/ETHPy150Open statsmodels/statsmodels/statsmodels/stats/descriptivestats.py/_skew |
4,909 | def _is_dtype_like(self, col):
"""
Check whether self.dataset.[col][0] behaves like a string, numbern
unknown. `numpy.lib._iotools._is_string_like`
"""
def string_like():
#TODO: not sure what the result is if the first item is some type of
# missing value
try:
self.dataset[col][0] + ''
except (TypeError, ValueError):
return False
return True
def number_like():
try:
self.dataset[col][0] + 1.0
except (TypeError, __HOLE__):
return False
return True
if number_like()==True and string_like()==False:
return 'number'
elif number_like()==False and string_like()==True:
return 'string'
else:
assert (number_like()==True or string_like()==True), '\
Not sure of dtype'+str(self.dataset[col][0])
#@property | ValueError | dataset/ETHPy150Open statsmodels/statsmodels/statsmodels/stats/descriptivestats.py/Describe._is_dtype_like |
4,910 | def tuple_values_dict(currtuple, newtuple=None):
"""Return dictionary of attributes with their values
:param currtuple: current Tuple
:param newtuple: optional Tuple with new values
:return: dictionary of attributes and values
"""
valdict = {}
for attr in currtuple.__dict__:
if attr in RESERVED_ATTRIBUTE_NAMES:
continue
currval = getattr(currtuple, attr)
if newtuple is None:
valdict.update({attr: currval})
elif hasattr(newtuple, attr):
newval = getattr(newtuple, attr)
try:
diff = currval != newval
except __HOLE__:
# TODO: more needed for naive vs. aware datetime/time
if isinstance(newval, datetime) or isinstance(newval, time):
if newval.utcoffset() is None:
diff = True
else:
raise
if diff:
valdict.update({attr: newval})
if newtuple is not None:
for newattr in newtuple.__dict__:
if newattr in RESERVED_ATTRIBUTE_NAMES:
continue
if newattr not in currtuple.__dict__:
valdict.update({newattr: getattr(newtuple, newattr)})
return valdict | TypeError | dataset/ETHPy150Open perseas/Pyrseas/pyrseas/relation/tuple.py/tuple_values_dict |
4,911 | def runtests():
if not settings.configured:
settings.configure(**DEFAULT_SETTINGS)
# Compatibility with Django 1.7's stricter initialization
if hasattr(django, 'setup'):
django.setup()
print(sys.path)
try:
from django.test.runner import DiscoverRunner
runner_class = DiscoverRunner
test_args = ['djangosecure.tests']
except __HOLE__:
from django.test.simple import DjangoTestSuiteRunner
runner_class = DjangoTestSuiteRunner
test_args = ['tests']
failures = runner_class(
verbosity=1, interactive=True, failfast=False).run_tests(test_args)
sys.exit(failures) | ImportError | dataset/ETHPy150Open carljm/django-secure/runtests.py/runtests |
4,912 | def clean(self):
self.tfile.close()
try:
os.unlink(self.get_full_path())
except __HOLE__:
pass | OSError | dataset/ETHPy150Open tooxie/shiva-server/shiva/resources/upload.py/UploadHandler.clean |
4,913 | def get_path(self):
path = ''
upload_path = app.config.get('UPLOAD_PATH')
if not upload_path:
raise NoUploadPathConfigError()
_artist = app.config.get('UPLOAD_DEFAULT_ARTIST', '')
_album = app.config.get('UPLOAD_DEFAULT_ALBUM', '')
artist = slugify(self.mdma.artist) or _artist
album = slugify(self.mdma.album) or _album
path = os.path.join(upload_path, artist, album)
try:
os.makedirs(path)
except __HOLE__: # File exists
pass
return path | OSError | dataset/ETHPy150Open tooxie/shiva-server/shiva/resources/upload.py/UploadHandler.get_path |
4,914 | def parseExtensionArgs(self, args):
"""Set the state of this request to be that expressed in these
PAPE arguments
@param args: The PAPE arguments without a namespace
@rtype: None
@raises ValueError: When the max_auth_age is not parseable as
an integer
"""
# preferred_auth_policies is a space-separated list of policy URIs
self.preferred_auth_policies = []
policies_str = args.get('preferred_auth_policies')
if policies_str:
for uri in policies_str.split(' '):
if uri not in self.preferred_auth_policies:
self.preferred_auth_policies.append(uri)
# max_auth_age is base-10 integer number of seconds
max_auth_age_str = args.get('max_auth_age')
self.max_auth_age = None
if max_auth_age_str:
try:
self.max_auth_age = int(max_auth_age_str)
except __HOLE__:
pass | ValueError | dataset/ETHPy150Open CollabQ/CollabQ/openid/extensions/pape.py/Request.parseExtensionArgs |
4,915 | def parseExtensionArgs(self, args, strict=False):
"""Parse the provider authentication policy arguments into the
internal state of this object
@param args: unqualified provider authentication policy
arguments
@param strict: Whether to raise an exception when bad data is
encountered
@returns: None. The data is parsed into the internal fields of
this object.
"""
policies_str = args.get('auth_policies')
if policies_str:
self.auth_policies = policies_str.split(' ')
nist_level_str = args.get('nist_auth_level')
if nist_level_str:
try:
nist_level = int(nist_level_str)
except ValueError:
if strict:
raise ValueError('nist_auth_level must be an integer between '
'zero and four, inclusive')
else:
self.nist_auth_level = None
else:
if 0 <= nist_level < 5:
self.nist_auth_level = nist_level
auth_age_str = args.get('auth_age')
if auth_age_str:
try:
auth_age = int(auth_age_str)
except __HOLE__:
if strict:
raise
else:
if auth_age >= 0:
self.auth_age = auth_age
elif strict:
raise ValueError('Auth age must be above zero') | ValueError | dataset/ETHPy150Open CollabQ/CollabQ/openid/extensions/pape.py/Response.parseExtensionArgs |
4,916 | def execute(self, *args, **options):
if len(args) != 1:
raise CommandError("You must provide a file to import!")
self.site = options["site"]
if not isinstance(self.site, Site):
try:
self.site = Site.objects.get(domain=options["site"])
except __HOLE__:
raise CommandError("No site found for domain: %s"
% options["site"])
filepath = args[0]
if filepath == '-':
rows = _get_rows(sys.stdin)
_create_redirects(self.site, rows)
else:
try:
with open(filepath) as fp:
rows = _get_rows(fp)
_create_redirects(self.site, rows)
except IOError as e:
if e.errno == errno.ENOENT:
raise CommandError("The specified file does not exist!")
else:
raise | ObjectDoesNotExist | dataset/ETHPy150Open okfn/foundation/foundation/redirector/management/commands/import_redirect_csv.py/Command.execute |
4,917 | @access.public
def getImageFeatures(self, params):
try:
import cv2
import numpy as np
cv2_available = True
except __HOLE__:
cv2_available = False
# Disabling opencv for now
cv2_available = False
if 'url' in params:
data = requests.get(params['url'], verify=False).content
else:
data = str(cherrypy.request.body.read())
# Run Tika once
parsed = parser.from_buffer(data)
tika = {}
for (k, v) in parsed["metadata"].iteritems():
k = k.lower().replace(':', '_').replace(' ', '_').replace('-', '_')
tika[k] = v[0] if type(v) is list and len(v) else v
tika['content'] = parsed["content"]
if cv2_available:
file_bytes = np.asarray(bytearray(data), dtype=np.uint8)
image = cv2.imdecode(file_bytes, flags=cv2.CV_LOAD_IMAGE_UNCHANGED);
if image is not None:
if len(image.shape) < 3 or image.shape[2] == 1:
image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
v = cv2.calcHist([image], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256])
v = v.flatten()
hist = v / sum(v)
tika['histogram'] = hist.tolist()
return tika | ImportError | dataset/ETHPy150Open memex-explorer/image_space/imagespace/server/imagefeatures_rest.py/ImageFeatures.getImageFeatures |
4,918 | def get_geo_from_ip(ip_addr):
try:
from geoip import geolite2
return geolite2.lookup(ip_addr)
except __HOLE__:
return
except ValueError:
return | ImportError | dataset/ETHPy150Open frappe/frappe/frappe/sessions.py/get_geo_from_ip |
4,919 | def supported(cls, stream=sys.stdout):
"""
A class method that returns True if the current platform supports
coloring terminal output using this method. Returns False otherwise.
"""
if not stream.isatty():
return False # auto color only on TTYs
try:
import curses
except __HOLE__:
return False
else:
try:
try:
return curses.tigetnum("colors") > 2
except curses.error:
curses.setupterm()
return curses.tigetnum("colors") > 2
except:
# guess false in case of error
return False | ImportError | dataset/ETHPy150Open twisted/twisted/twisted/trial/reporter.py/_AnsiColorizer.supported |
4,920 | def supported(cls, stream=sys.stdout):
try:
import win32console
screenBuffer = win32console.GetStdHandle(
win32console.STD_OUTPUT_HANDLE)
except __HOLE__:
return False
import pywintypes
try:
screenBuffer.SetConsoleTextAttribute(
win32console.FOREGROUND_RED |
win32console.FOREGROUND_GREEN |
win32console.FOREGROUND_BLUE)
except pywintypes.error:
return False
else:
return True | ImportError | dataset/ETHPy150Open twisted/twisted/twisted/trial/reporter.py/_Win32Colorizer.supported |
4,921 | @pytest.mark.hookwrapper
def pytest_runtest_makereport(item, call):
outcome = yield
# Only run through this at the end of the test
if call.when != 'call':
return
# Don't continue if this isn't a screenshot test
if 'screenshot' not in item.fixturenames:
return
# Don't add screenshots if we can't create a screenshot
try:
screenshot = Screenshot(item=item)
except __HOLE__:
return
report = outcome.get_result()
xfail = hasattr(report, 'wasxfail')
failure = (report.skipped and xfail) or (report.failed and not xfail)
pytest_html = item.config.pluginmanager.getplugin('html')
# Don't add screenshots if test passed
if failure:
diff = pytest_html.extras.image(screenshot.get_diff_as_base64(), '')
base = pytest_html.extras.image(screenshot.get_base_as_base64(), '')
test = pytest_html.extras.image(screenshot.get_current_as_base64(), '')
# Override existing extra and logs for screenshot tests (keeps output manageable)
report.extra = [test, diff, base]
report.longrepr = '' | AssertionError | dataset/ETHPy150Open bokeh/bokeh/tests/integration/integration_tests_plugin.py/pytest_runtest_makereport |
4,922 | def class_for_kind(kind):
"""Return base-class responsible for implementing kind.
Necessary to recover the class responsible for implementing provided
kind.
Args:
kind: Entity kind string.
Returns:
Class implementation for kind.
Raises:
KindError when there is no implementation for kind.
"""
try:
return _kind_map[kind]
except __HOLE__:
raise KindError('No implementation for kind \'%s\'' % kind) | KeyError | dataset/ETHPy150Open AppScale/appscale/AppServer/google/appengine/ext/db/__init__.py/class_for_kind |
4,923 | def __get__(self, model_instance, model_class):
"""Returns the value for this property on the given model instance.
See http://docs.python.org/ref/descriptors.html for a description of
the arguments to this class and what they mean."""
if model_instance is None:
return self
try:
return getattr(model_instance, self._attr_name())
except __HOLE__:
return None | AttributeError | dataset/ETHPy150Open AppScale/appscale/AppServer/google/appengine/ext/db/__init__.py/Property.__get__ |
4,924 | def _populate_internal_entity(self, _entity_class=datastore.Entity):
"""Populates self._entity, saving its state to the datastore.
After this method is called, calling is_saved() will return True.
Returns:
Populated self._entity
"""
self._entity = self._populate_entity(_entity_class=_entity_class)
for prop in self.properties().values():
new_value = prop.get_updated_value_for_datastore(self)
if new_value is not AUTO_UPDATE_UNCHANGED:
self.__set_property(self._entity, prop.name, new_value)
for attr in ('_key_name', '_key'):
try:
delattr(self, attr)
except __HOLE__:
pass
return self._entity | AttributeError | dataset/ETHPy150Open AppScale/appscale/AppServer/google/appengine/ext/db/__init__.py/Model._populate_internal_entity |
4,925 | @classmethod
def _load_entity_values(cls, entity):
"""Load dynamic properties from entity.
Loads attributes which are not defined as part of the entity in
to the model instance.
Args:
entity: Entity which contain values to search dyanmic properties for.
"""
entity_values = {}
for prop in cls.properties().values():
if prop.name in entity:
try:
value = entity[prop.name]
except __HOLE__:
entity_values[prop.name] = []
else:
if entity.is_projection():
value = prop.make_value_from_datastore_index_value(value)
else:
value = prop.make_value_from_datastore(value)
entity_values[prop.name] = value
return entity_values | KeyError | dataset/ETHPy150Open AppScale/appscale/AppServer/google/appengine/ext/db/__init__.py/Model._load_entity_values |
4,926 | def delete_async(models, **kwargs):
"""Asynchronous version of delete one or more Model instances.
Identical to db.delete() except returns an asynchronous object. Call
get_result() on the return value to block on the call.
"""
if isinstance(models, (basestring, Model, Key)):
models = [models]
else:
try:
models = iter(models)
except __HOLE__:
models = [models]
keys = [_coerce_to_key(v) for v in models]
return datastore.DeleteAsync(keys, **kwargs) | TypeError | dataset/ETHPy150Open AppScale/appscale/AppServer/google/appengine/ext/db/__init__.py/delete_async |
4,927 | def get(self, **kwargs):
"""Get first result from this.
Beware: get() ignores the LIMIT clause on GQL queries.
Args:
kwargs: Any keyword arguments accepted by datastore_query.QueryOptions().
Returns:
First result from running the query if there are any, else None.
"""
results = self.run(limit=1, **kwargs)
try:
return results.next()
except __HOLE__:
return None | StopIteration | dataset/ETHPy150Open AppScale/appscale/AppServer/google/appengine/ext/db/__init__.py/_BaseQuery.get |
4,928 | def validate(self, value):
"""Validate property.
Returns:
A valid value.
Raises:
BadValueError if property is not an instance of data_type.
"""
if value is not None and not isinstance(value, self.data_type):
try:
value = self.data_type(value)
except __HOLE__, err:
raise BadValueError('Property %s must be convertible '
'to a %s instance (%s)' %
(self.name, self.data_type.__name__, err))
value = super(UnindexedProperty, self).validate(value)
if value is not None and not isinstance(value, self.data_type):
raise BadValueError('Property %s must be a %s instance' %
(self.name, self.data_type.__name__))
return value | TypeError | dataset/ETHPy150Open AppScale/appscale/AppServer/google/appengine/ext/db/__init__.py/UnindexedProperty.validate |
4,929 | def validate(self, value):
"""Validate ByteString property.
Returns:
A valid value.
Raises:
BadValueError if property is not instance of 'ByteString'.
"""
if value is not None and not isinstance(value, ByteString):
try:
value = ByteString(value)
except __HOLE__, err:
raise BadValueError('Property %s must be convertible '
'to a ByteString instance (%s)' % (self.name, err))
value = super(ByteStringProperty, self).validate(value)
if value is not None and not isinstance(value, ByteString):
raise BadValueError('Property %s must be a ByteString instance'
% self.name)
if value is not None and len(value) > self.MAX_LENGTH:
raise BadValueError(
'Property %s is %d bytes long; it must be %d or less.'
% (self.name, len(value), self.MAX_LENGTH))
return value | TypeError | dataset/ETHPy150Open AppScale/appscale/AppServer/google/appengine/ext/db/__init__.py/ByteStringProperty.validate |
4,930 | def load_class(path):
"""
Load class from path.
"""
try:
mod_name, klass_name = path.rsplit('.', 1)
mod = import_module(mod_name)
except AttributeError as e:
raise ImproperlyConfigured('Error importing {0}: "{1}"'.format(mod_name, e))
try:
klass = getattr(mod, klass_name)
except __HOLE__:
raise ImproperlyConfigured('Module "{0}" does not define a "{1}" class'.format(mod_name, klass_name))
return klass | AttributeError | dataset/ETHPy150Open niwinz/django-jinja/django_jinja/utils.py/load_class |
4,931 | def load_bytecode(self, f):
"""Loads bytecode from a file or file like object."""
# make sure the magic header is correct
magic = f.read(len(bc_magic))
if magic != bc_magic:
self.reset()
return
# the source code of the file changed, we need to reload
checksum = pickle.load(f)
if self.checksum != checksum:
self.reset()
return
# if marshal_load fails then we need to reload
try:
self.code = marshal_load(f)
except (EOFError, __HOLE__, TypeError):
self.reset()
return | ValueError | dataset/ETHPy150Open GoogleCloudPlatform/appengine-flask-skeleton/lib/jinja2/bccache.py/Bucket.load_bytecode |
4,932 | def _get_default_cache_dir(self):
def _unsafe_dir():
raise RuntimeError('Cannot determine safe temp directory. You '
'need to explicitly provide one.')
tmpdir = tempfile.gettempdir()
# On windows the temporary directory is used specific unless
# explicitly forced otherwise. We can just use that.
if os.name == 'nt':
return tmpdir
if not hasattr(os, 'getuid'):
_unsafe_dir()
dirname = '_jinja2-cache-%d' % os.getuid()
actual_dir = os.path.join(tmpdir, dirname)
try:
os.mkdir(actual_dir, stat.S_IRWXU)
except __HOLE__ as e:
if e.errno != errno.EEXIST:
raise
try:
os.chmod(actual_dir, stat.S_IRWXU)
actual_dir_stat = os.lstat(actual_dir)
if actual_dir_stat.st_uid != os.getuid() \
or not stat.S_ISDIR(actual_dir_stat.st_mode) \
or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU:
_unsafe_dir()
except OSError as e:
if e.errno != errno.EEXIST:
raise
actual_dir_stat = os.lstat(actual_dir)
if actual_dir_stat.st_uid != os.getuid() \
or not stat.S_ISDIR(actual_dir_stat.st_mode) \
or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU:
_unsafe_dir()
return actual_dir | OSError | dataset/ETHPy150Open GoogleCloudPlatform/appengine-flask-skeleton/lib/jinja2/bccache.py/FileSystemBytecodeCache._get_default_cache_dir |
4,933 | def clear(self):
# imported lazily here because google app-engine doesn't support
# write access on the file system and the function does not exist
# normally.
from os import remove
files = fnmatch.filter(listdir(self.directory), self.pattern % '*')
for filename in files:
try:
remove(path.join(self.directory, filename))
except __HOLE__:
pass | OSError | dataset/ETHPy150Open GoogleCloudPlatform/appengine-flask-skeleton/lib/jinja2/bccache.py/FileSystemBytecodeCache.clear |
4,934 | def check_ils_booking(gadget_url_base):
"""
Checks the session and returns when the lab is free (in UTC). If None is returned, it means that there is no ongoing session so they can use the lab.
"""
ils_student_id = extract_ils_id(request.args.get('ils_student_url'))
ils_teacher_id = extract_ils_id(request.args.get('ils_teacher_url'))
# BOOKING_URL = url_for('.mock_golabz_booking_service', _external=True)
BOOKING_URL = 'http://www.golabz.eu/rest/lab-booking/retrieve.json'
try:
r = requests.get(BOOKING_URL, headers = {
'Cache-Control': 'no-cache',
'Pragma': 'no-cache',
})
r.raise_for_status()
booking_slots = r.json()
except Exception as e:
traceback.print_exc()
# We can not stop students using the labs if the service is temporarily down
return None
affected_ilss = []
oldest_affected_endtime = datetime.datetime.utcnow()
for booking_slot in booking_slots:
is_current_lab = False
for lab_app in booking_slot.get('lab_apps', []):
lab_url = lab_app.get('app_url', '')
if lab_url.startswith(gadget_url_base):
is_current_lab = True
break
if not is_current_lab:
continue
start_time_str = booking_slot.get('start_time', '2000-01-01T00:00:00')
end_time_str = booking_slot.get('end_time', '2000-01-01T00:00:00')
FORMAT = '%Y-%m-%dT%H:%M:%S'
try:
start_time = datetime.datetime.strptime(start_time_str, FORMAT)
end_time = datetime.datetime.strptime(end_time_str, FORMAT)
except __HOLE__:
traceback.print_exc()
continue
now = datetime.datetime.utcnow()
if end_time > now > start_time:
ils_id = extract_ils_id(booking_slot.get('ils_url')) or 'does.not.exist'
if end_time > oldest_affected_endtime:
oldest_affected_endtime = end_time
affected_ilss.append(ils_id)
if affected_ilss:
for affected_ils_id in affected_ilss:
if affected_ils_id in (ils_student_id, ils_teacher_id):
return None
# If there are affected ILS, but we're not part of them, we're not authorized
return oldest_affected_endtime
else:
# If there is no affected ILS, it doesn't matter if we're in the group or not
return None | ValueError | dataset/ETHPy150Open gateway4labs/labmanager/labmanager/views/opensocial.py/check_ils_booking |
4,935 | def test_config_from_envvar(self):
env = os.environ
try:
os.environ = {}
app = flask.Flask(__name__)
try:
app.config.from_envvar('FOO_SETTINGS')
except __HOLE__, e:
self.assert_("'FOO_SETTINGS' is not set" in str(e))
else:
self.assert_(0, 'expected exception')
self.assert_(not app.config.from_envvar('FOO_SETTINGS', silent=True))
os.environ = {'FOO_SETTINGS': __file__.rsplit('.', 1)[0] + '.py'}
self.assert_(app.config.from_envvar('FOO_SETTINGS'))
self.common_object_test(app)
finally:
os.environ = env | RuntimeError | dataset/ETHPy150Open baseblack/ReproWeb/3rdParty/python/flask/testsuite/config.py/ConfigTestCase.test_config_from_envvar |
4,936 | def test_config_from_envvar_missing(self):
env = os.environ
try:
os.environ = {'FOO_SETTINGS': 'missing.cfg'}
try:
app = flask.Flask(__name__)
app.config.from_envvar('FOO_SETTINGS')
except __HOLE__, e:
msg = str(e)
self.assert_(msg.startswith('[Errno 2] Unable to load configuration '
'file (No such file or directory):'))
self.assert_(msg.endswith("missing.cfg'"))
else:
self.fail('expected IOError')
self.assertFalse(app.config.from_envvar('FOO_SETTINGS', silent=True))
finally:
os.environ = env | IOError | dataset/ETHPy150Open baseblack/ReproWeb/3rdParty/python/flask/testsuite/config.py/ConfigTestCase.test_config_from_envvar_missing |
4,937 | def test_config_missing(self):
app = flask.Flask(__name__)
try:
app.config.from_pyfile('missing.cfg')
except __HOLE__, e:
msg = str(e)
self.assert_(msg.startswith('[Errno 2] Unable to load configuration '
'file (No such file or directory):'))
self.assert_(msg.endswith("missing.cfg'"))
else:
self.assert_(0, 'expected config')
self.assert_(not app.config.from_pyfile('missing.cfg', silent=True)) | IOError | dataset/ETHPy150Open baseblack/ReproWeb/3rdParty/python/flask/testsuite/config.py/ConfigTestCase.test_config_missing |
4,938 | def test_explicit_instance_paths(self):
here = os.path.abspath(os.path.dirname(__file__))
try:
flask.Flask(__name__, instance_path='instance')
except __HOLE__, e:
self.assert_('must be absolute' in str(e))
else:
self.fail('Expected value error')
app = flask.Flask(__name__, instance_path=here)
self.assert_equal(app.instance_path, here) | ValueError | dataset/ETHPy150Open baseblack/ReproWeb/3rdParty/python/flask/testsuite/config.py/InstanceTestCase.test_explicit_instance_paths |
4,939 | def _get_impl():
"""Delay import of rpc_backend until configuration is loaded."""
global _RPCIMPL
if _RPCIMPL is None:
try:
_RPCIMPL = importutils.import_module(CONF.rpc_backend)
except __HOLE__:
# For backwards compatibility with older nova config.
impl = CONF.rpc_backend.replace('nova.rpc',
'nova.openstack.common.rpc')
_RPCIMPL = importutils.import_module(impl)
return _RPCIMPL | ImportError | dataset/ETHPy150Open Havate/havate-openstack/proto-build/gui/horizon/Horizon_GUI/openstack_dashboard/openstack/common/rpc/__init__.py/_get_impl |
4,940 | @classmethod
def __get_pp_ip(cls, addr_family, ip_string, which):
try:
packed = socket.inet_pton(addr_family, ip_string.decode('ascii'))
return socket.inet_ntop(addr_family, packed)
except (__HOLE__, socket.error):
msg = 'Invalid proxy protocol {0} IP format'.format(which)
raise AssertionError(msg) | UnicodeDecodeError | dataset/ETHPy150Open slimta/python-slimta/slimta/util/proxyproto.py/ProxyProtocolV1.__get_pp_ip |
4,941 | @classmethod
def __get_pp_port(cls, port_string, which):
try:
port_num = int(port_string)
except __HOLE__:
msg = 'Invalid proxy protocol {0} port format'.format(which)
raise AssertionError(msg)
assert port_num >= 0 and port_num <= 65535, \
'Proxy protocol {0} port out of range'.format(which)
return port_num | ValueError | dataset/ETHPy150Open slimta/python-slimta/slimta/util/proxyproto.py/ProxyProtocolV1.__get_pp_port |
4,942 | def handle(self, sock, addr):
"""Intercepts calls to :meth:`~slimta.edge.EdgeServer.handle`, reads
the proxy protocol header, and then resumes the original call.
"""
try:
src_addr, _ = self.process_pp_v1(sock, b'')
except __HOLE__ as exc:
log.proxyproto_invalid(sock, exc)
src_addr = invalid_pp_source_address
else:
log.proxyproto_success(sock, src_addr)
return super(ProxyProtocolV1, self).handle(sock, src_addr) | AssertionError | dataset/ETHPy150Open slimta/python-slimta/slimta/util/proxyproto.py/ProxyProtocolV1.handle |
4,943 | def handle(self, sock, addr):
"""Intercepts calls to :meth:`~slimta.edge.EdgeServer.handle`, reads
the proxy protocol header, and then resumes the original call.
"""
try:
src_addr, _ = self.process_pp_v2(sock, b'')
except LocalConnection:
log.proxyproto_local(sock)
return
except __HOLE__ as exc:
log.proxyproto_invalid(sock, exc)
src_addr = invalid_pp_source_address
else:
log.proxyproto_success(sock, src_addr)
return super(ProxyProtocolV2, self).handle(sock, src_addr) | AssertionError | dataset/ETHPy150Open slimta/python-slimta/slimta/util/proxyproto.py/ProxyProtocolV2.handle |
4,944 | def handle(self, sock, addr):
"""Intercepts calls to :meth:`~slimta.edge.EdgeServer.handle`, reads
the proxy protocol header, and then resumes the original call.
"""
try:
initial = self.__read_pp_initial(sock)
if initial.startswith(b'PROXY '):
src_addr, _ = ProxyProtocolV1.process_pp_v1(sock, initial)
elif initial == b'\r\n\r\n\x00\r\nQ':
src_addr, _ = ProxyProtocolV2.process_pp_v2(sock, initial)
else:
raise AssertionError('Invalid proxy protocol signature')
except LocalConnection:
log.proxyproto_local(sock)
return
except __HOLE__ as exc:
log.proxyproto_invalid(sock, exc)
src_addr = invalid_pp_source_address
else:
log.proxyproto_success(sock, src_addr)
return super(ProxyProtocol, self).handle(sock, src_addr)
# vim:et:fdm=marker:sts=4:sw=4:ts=4 | AssertionError | dataset/ETHPy150Open slimta/python-slimta/slimta/util/proxyproto.py/ProxyProtocol.handle |
4,945 | def prompt_for_yn(prompt_str, default=None):
if default == True:
prompt = prompt_str + ' [Y/n]: '
elif default == False:
prompt = prompt_str + ' [y/N]: '
else:
prompt = prompt_str + ' [y/n]: '
while True:
try:
value = input(prompt)
except __HOLE__:
print('')
exit(1)
except EOFError:
print('')
exit(1)
if value != '':
if value.lower()[0] == 'y':
return True
elif value.lower()[0] == 'n':
return False
else:
print('Error: unrecognized response')
elif default is not None:
return default | KeyboardInterrupt | dataset/ETHPy150Open dnanexus/dx-toolkit/src/python/dxpy/cli/__init__.py/prompt_for_yn |
4,946 | def access_token(self, token):
"""Return request for access token value"""
try:
return self.get_querystring(self.ACCESS_TOKEN_URL,
auth=self.oauth_auth(token))
except __HOLE__ as err:
# Evernote returns a 401 error when AuthCanceled
if err.response.status_code == 401:
raise AuthCanceled(self, response=err.response)
else:
raise | HTTPError | dataset/ETHPy150Open omab/python-social-auth/social/backends/evernote.py/EvernoteOAuth.access_token |
4,947 | def remove_file(self, filename):
"""Remove a file, noop if file does not exist."""
# Unlike os.remove, if the file does not exist,
# then this method does nothing.
try:
os.remove(filename)
except __HOLE__:
pass | OSError | dataset/ETHPy150Open boto/boto3/boto3/s3/transfer.py/OSUtils.remove_file |
4,948 | def __getattr__(self, attr):
try:
return self.__getitem__(attr)
except __HOLE__:
return super(EnhancedDictionary, self).__getattr__(attr) | KeyError | dataset/ETHPy150Open kivy/kivy/kivy/input/motionevent.py/EnhancedDictionary.__getattr__ |
4,949 | def read_parameter_file(path, name):
try:
raw = misc.read_file(path, name + filename_extension)
except __HOLE__:
raw = "{}"
cooked = ast.literal_eval(raw)
return cooked | IOError | dataset/ETHPy150Open laforest/Octavo/Generator/Misc/parameters_misc.py/read_parameter_file |
4,950 | def parse_cmdline(entries):
parameters = {}
if len(entries) == 0:
return parameters
if entries[0] == "-f" and filename_extension in entries[1]:
path, name = os.path.split(entries[1])
name = name.replace(filename_extension, '')
parameters = read_parameter_file(path, name)
del entries[0:2]
for entry in entries:
parts = entry.split('=')
assert len(parts) == 2, "Incorrect parameter formating for {0}. Use 'key=value'.".format(entry)
key, value = tuple(parts)
try:
value = ast.literal_eval(value)
except __HOLE__:
if not (value == "ON" or value == "OFF"):
raise ValueError, value
parameters.update({key:value})
return parameters | ValueError | dataset/ETHPy150Open laforest/Octavo/Generator/Misc/parameters_misc.py/parse_cmdline |
4,951 | def test_connection(self):
class DocA(Document):
structure = {
"doc_a":{'foo':int},
}
self.connection.register([DocA])
assertion = True
try:
DocA.connection
except AttributeError:
assertion = True
assert assertion
try:
DocA.db
except __HOLE__:
assertion = True
assert assertion
try:
DocA.collection
except AttributeError:
assertion = True
assert assertion
assert self.col.DocA.connection == Connection("localhost", 27017)
assert self.col.DocA.collection == Connection("localhost", 27017)['test']['mongokit']
assert self.col.DocA.db == Connection("localhost", 27017)['test'] | AttributeError | dataset/ETHPy150Open namlook/mongokit/tests/test_api.py/ApiTestCase.test_connection |
4,952 | def test_rewind(self):
class MyDoc(Document):
structure = {
'foo':int,
}
self.connection.register([MyDoc])
for i in range(10):
doc = self.col.MyDoc()
doc['foo'] = i
doc.save()
cur = self.col.MyDoc.find()
for i in cur:
assert isinstance(i, MyDoc), type(MyDoc)
try:
cur.next()
except __HOLE__:
pass
cur.rewind()
for i in cur:
assert isinstance(i, MyDoc), type(MyDoc)
for i in cur.rewind():
assert isinstance(i, MyDoc), type(MyDoc) | StopIteration | dataset/ETHPy150Open namlook/mongokit/tests/test_api.py/ApiTestCase.test_rewind |
4,953 | def test_database_name_filled(self):
failed = False
@self.connection.register
class MyDoc(Document):
__database__ = 'mydoc'
structure = {
'foo':int,
}
try:
doc = self.connection.MyDoc()
except __HOLE__, e:
failed = True
self.assertEqual(str(e), 'MyDoc: __collection__ attribute not '
'found. You cannot specify the `__database__` attribute '
'without the `__collection__` attribute')
self.assertEqual(failed, True)
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydoc'
structure = {
'foo':int,
}
# test directly from a connection
mydoc = self.connection.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mydoc')
self.assertEqual(mydoc.collection.database.name, 'test')
self.assertEqual(self.col.MyDoc.find_one(), None)
raw_doc = self.connection.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
# test directly from a database
mydoc = self.connection.othertest.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mydoc')
self.assertEqual(mydoc.collection.database.name, 'othertest')
self.assertEqual(self.col.MyDoc.find_one(), None)
raw_doc = self.connection.othertest.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
# and still can use it via a collection
mydoc = self.col.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mongokit')
self.assertEqual(mydoc.collection.database.name, 'test')
raw_doc = self.col.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc) | AttributeError | dataset/ETHPy150Open namlook/mongokit/tests/test_api.py/ApiTestCase.test_database_name_filled |
4,954 | def test_unwrapped_cursor(self):
self.assertEqual(self.col.count(), 0)
doc_id = self.col.save({}, safe=True)
self.assertEqual(self.col.count(), 1)
try:
self.col.find(_id=doc_id)[0]
except __HOLE__:
self.fail("Cursor.__getitem__ raised TypeError unexpectedly!") | TypeError | dataset/ETHPy150Open namlook/mongokit/tests/test_api.py/ApiTestCase.test_unwrapped_cursor |
4,955 | def force_unicode(s):
try:
return unicode(s)
except __HOLE__:
return str(s) | NameError | dataset/ETHPy150Open ffunenga/pipgh/pipgh/tools.py/force_unicode |
4,956 | def __init__(self, node, level=0):
self.level = level
def is_str(s):
try:
return type(s) == unicode
except __HOLE__:
return type(s) == str
_test = lambda i: (type(i[1]) == dict or
(type(i[1]) != dict and
not normalize(i[1]).startswith('http')))
self.children = [n for n in node.items()] # if _test(n)]
self.children.sort(key=lambda i: i[0]) | NameError | dataset/ETHPy150Open ffunenga/pipgh/pipgh/tools.py/ShowNode.__init__ |
4,957 | def __enter__(self):
try:
os.mkdir(self.path)
except __HOLE__ as e:
if e.errno != 17: # File exists
raise
shutil.rmtree(self.path)
os.mkdir(self.path)
finally:
os.chdir(self.path)
return self | OSError | dataset/ETHPy150Open ffunenga/pipgh/pipgh/tools.py/TempDirContext.__enter__ |
4,958 | def __init__(self, inner_node):
"""
Instantiated with a inner_node as an argument
This node comes from the from the do_include function
"""
self.inner_node = inner_node
# attempting to get the tmplate name
# depends whether it is an IncludeNode or ConstantIncludeNode
try:
self.template_name = inner_node.template_name
except __HOLE__:
self.template_name = inner_node.template.name | AttributeError | dataset/ETHPy150Open haystack/eyebrowse-server/common/templatetags/jstemplate.py/JsTemplateBaseNode.__init__ |
4,959 | def _limit_inf(expr, n):
try:
return Limit(expr, n, S.Infinity).doit(deep=False, sequence=False)
except (__HOLE__, PoleError):
return None | NotImplementedError | dataset/ETHPy150Open sympy/sympy/sympy/series/limitseq.py/_limit_inf |
4,960 | def merge(dict_1, dict_2, func=lambda x, y: x + y):
"""doc"""
res = dict_1.copy() # "= dict(d1)" for lists of tuples
for key, val in dict_2.iteritems(): # ".. in d2" for lists of tuple
try:
res[key] = func(res[key], val)
except __HOLE__:
res[key] = val
return res | KeyError | dataset/ETHPy150Open columbia/libtrack/libtrack/parser/src/telesphorus/helpers/dict_utils.py/merge |
4,961 | def isDBPort(host, port, db, timeout=10):
if host in (RDFTURTLEFILE_HOSTNAME, RDFXMLFILE_HOSTNAME):
return True
# determine if postgres port
t = 2
while t < timeout:
try:
conn = urllib.request.urlopen("http://{0}:{1}/{2}/status".format(host, port or '80', db))
return True # success but doesn't need password
except __HOLE__:
return False # success, this is really a postgres socket, wants user name
except URLError:
return False # something is there but not postgres
except socket.timeout:
t = t + 2 # relax - try again with longer timeout
return False
# deferred rdflib import | HTTPError | dataset/ETHPy150Open Arelle/Arelle/arelle/plugin/xbrlDB/XbrlSemanticRdfDB.py/isDBPort |
4,962 | def __init__(self, modelXbrl, user, password, host, port, database, timeout):
try:
initRdflibNamespaces()
except __HOLE__:
raise XRDBException("xrdfDB:MissingRdflib",
_("Rdflib is not installed or is not available in this build"))
self.modelXbrl = modelXbrl
self.disclosureSystem = modelXbrl.modelManager.disclosureSystem
#self.conn = RexProConnection(host, int(port or '8182'), (database or 'emptygraph'),
# user=user, password=password)
self.isRdfTurtleFile = host == RDFTURTLEFILE_HOSTNAME
self.isRdfXmlFile = host == RDFXMLFILE_HOSTNAME
if self.isRdfTurtleFile or self.isRdfXmlFile:
self.turtleFile = database
else:
connectionUrl = "http://{0}:{1}".format(host, port or '80')
self.url = connectionUrl
if database:
self.url += '/' + database
# Create an OpenerDirector with support for Basic HTTP Authentication...
auth_handler = urllib.request.HTTPBasicAuthHandler()
if user:
auth_handler.add_password(realm=None,
uri=connectionUrl,
user=user,
passwd=password)
self.conn = urllib.request.build_opener(auth_handler)
self.timeout = timeout or 60
self.verticePropTypes = {} | ImportError | dataset/ETHPy150Open Arelle/Arelle/arelle/plugin/xbrlDB/XbrlSemanticRdfDB.py/XbrlSemanticRdfDatabaseConnection.__init__ |
4,963 | def execute(self, activity, graph=None, query=None):
if graph is not None:
headers = {'User-agent': 'Arelle/1.0',
'Accept': 'application/sparql-results+json',
'Content-Type': "text/turtle; charset='UTF-8'"}
data = graph.serialize(format='pretty-xml' if self.isRdfXmlFile else 'turtle',
encoding='utf=8')
elif query is not None:
headers = {'User-agent': 'Arelle/1.0',
'Accept': 'application/sparql-results+json'}
data = ("query=" + query).encode('utf-8')
else:
return None
# turtle may be mixture of line strings and strings with \n-separated lines
if TRACERDFFILE:
with io.open(TRACERDFFILE, "ab") as fh:
fh.write(b"\n\n>>> sent: \n")
fh.write(data)
if (self.isRdfTurtleFile or self.isRdfXmlFile) and data is not None:
with io.open(self.turtleFile, "ab") as fh:
fh.write(data)
return None
if graph is not None or query is not None:
url = self.url + "/sparql"
request = urllib.request.Request(url,
data=data,
headers=headers)
try:
with self.conn.open(request, timeout=self.timeout) as fp:
results = fp.read().decode('utf-8')
try:
results = json.loads(results)
except __HOLE__:
pass # leave results as string
except HTTPError as err:
results = err.fp.read().decode('utf-8')
if TRACERDFFILE:
with io.open(TRACERDFFILE, "a", encoding='utf-8') as fh:
fh.write("\n\n>>> received: \n{0}".format(str(results)))
if isinstance(results, str) and query is not None:
parser = etree.HTMLParser()
htmlDoc = etree.parse(io.StringIO(results), parser)
body = htmlDoc.find("//body")
if body is not None:
error = "".join(text for text in body.itertext())
else:
error = results
raise XRDBException("xrdfDB:DatabaseError",
_("%(activity)s not successful: %(error)s"),
activity=activity, error=error)
return results | ValueError | dataset/ETHPy150Open Arelle/Arelle/arelle/plugin/xbrlDB/XbrlSemanticRdfDB.py/XbrlSemanticRdfDatabaseConnection.execute |
4,964 | def identifyPreexistingDocuments(self):
self.existingDocumentUris = set()
if not (self.isRdfTurtleFile or self.isRdfXmlFile):
docFilters = []
for modelDocument in self.modelXbrl.urlDocs.values():
if modelDocument.type == Type.SCHEMA:
docFilters.append('STR(?doc) = "{}"'.format(UrlUtil.ensureUrl(modelDocument.uri)))
results = self.execute(
"select",
query="""
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX DTS: <http://xbrl.org/2013/rdf/DTS/>
SELECT distinct ?doc WHERE { ?doc rdf:type DTS:Document
FILTER( """ + '\n|| '.join(docFilters) + ") .}")
try:
for result in results['results']['bindings']:
doc = result['doc']
if doc.get('type') == 'uri':
self.existingDocumentUris.add(doc['value'])
except __HOLE__:
pass # no existingDocumentUris | KeyError | dataset/ETHPy150Open Arelle/Arelle/arelle/plugin/xbrlDB/XbrlSemanticRdfDB.py/XbrlSemanticRdfDatabaseConnection.identifyPreexistingDocuments |
4,965 | @classmethod
def _create_ip_ranges_on_notation(cls, instance):
"""Create IP-address ranges basing on 'notation' field of 'meta' field
:param instance: NetworkGroup instance
:type instance: models.NetworkGroup
:return: None
"""
notation = instance.meta.get("notation")
if notation:
try:
if notation == 'cidr':
cls._update_range_from_cidr(
instance, IPNetwork(instance.cidr).cidr,
instance.meta.get('use_gateway'))
elif notation == 'ip_ranges' and instance.meta.get("ip_range"):
cls._set_ip_ranges(instance, [instance.meta["ip_range"]])
else:
raise errors.CannotCreate()
except (
errors.CannotCreate,
IndexError,
__HOLE__
):
raise errors.CannotCreate(
"IPAddrRange object cannot be created for network '{0}' "
"with notation='{1}', ip_range='{2}'".format(
instance.name,
instance.meta.get('notation'),
instance.meta.get('ip_range'))
) | TypeError | dataset/ETHPy150Open openstack/fuel-web/nailgun/nailgun/extensions/network_manager/objects/network_group.py/NetworkGroup._create_ip_ranges_on_notation |
4,966 | def __call__(self, text, append_newline=1):
if not self.print_it:
return
if append_newline: text = text + '\n'
try:
sys.stdout.write(unicode(text))
except __HOLE__:
# Stdout might be connected to a pipe that has been closed
# by now. The most likely reason for the pipe being closed
# is that the user has press ctrl-c. It this is the case,
# then SCons is currently shutdown. We therefore ignore
# IOError's here so that SCons can continue and shutdown
# properly so that the .sconsign is correctly written
# before SCons exits.
pass | IOError | dataset/ETHPy150Open kayhayen/Nuitka/nuitka/build/inline_copy/lib/scons-2.3.2/SCons/Util.py/DisplayEngine.__call__ |
4,967 | def to_String_for_signature(obj, to_String_for_subst=to_String_for_subst,
AttributeError=AttributeError):
try:
f = obj.for_signature
except __HOLE__:
return to_String_for_subst(obj)
else:
return f()
# The SCons "semi-deep" copy.
#
# This makes separate copies of lists (including UserList objects)
# dictionaries (including UserDict objects) and tuples, but just copies
# references to anything else it finds.
#
# A special case is any object that has a __semi_deepcopy__() method,
# which we invoke to create the copy. Currently only used by
# BuilderDict to actually prevent the copy operation (as invalid on that object)
#
# The dispatch table approach used here is a direct rip-off from the
# normal Python copy module. | AttributeError | dataset/ETHPy150Open kayhayen/Nuitka/nuitka/build/inline_copy/lib/scons-2.3.2/SCons/Util.py/to_String_for_signature |
4,968 | def WhereIs(file, path=None, pathext=None, reject=[]):
if path is None:
try:
path = os.environ['PATH']
except __HOLE__:
return None
if is_String(path):
path = path.split(os.pathsep)
if pathext is None:
try:
pathext = os.environ['PATHEXT']
except KeyError:
pathext = '.COM;.EXE;.BAT;.CMD'
if is_String(pathext):
pathext = pathext.split(os.pathsep)
for ext in pathext:
if ext.lower() == file[-len(ext):].lower():
pathext = ['']
break
if not is_List(reject) and not is_Tuple(reject):
reject = [reject]
for dir in path:
f = os.path.join(dir, file)
for ext in pathext:
fext = f + ext
if os.path.isfile(fext):
try:
reject.index(fext)
except ValueError:
return os.path.normpath(fext)
continue
return None | KeyError | dataset/ETHPy150Open kayhayen/Nuitka/nuitka/build/inline_copy/lib/scons-2.3.2/SCons/Util.py/WhereIs |
4,969 | def WhereIs(file, path=None, pathext=None, reject=[]):
if path is None:
try:
path = os.environ['PATH']
except KeyError:
return None
if is_String(path):
path = path.split(os.pathsep)
if pathext is None:
pathext = ['.exe', '.cmd']
for ext in pathext:
if ext.lower() == file[-len(ext):].lower():
pathext = ['']
break
if not is_List(reject) and not is_Tuple(reject):
reject = [reject]
for dir in path:
f = os.path.join(dir, file)
for ext in pathext:
fext = f + ext
if os.path.isfile(fext):
try:
reject.index(fext)
except __HOLE__:
return os.path.normpath(fext)
continue
return None | ValueError | dataset/ETHPy150Open kayhayen/Nuitka/nuitka/build/inline_copy/lib/scons-2.3.2/SCons/Util.py/WhereIs |
4,970 | def WhereIs(file, path=None, pathext=None, reject=[]):
import stat
if path is None:
try:
path = os.environ['PATH']
except __HOLE__:
return None
if is_String(path):
path = path.split(os.pathsep)
if not is_List(reject) and not is_Tuple(reject):
reject = [reject]
for d in path:
f = os.path.join(d, file)
if os.path.isfile(f):
try:
st = os.stat(f)
except OSError:
# os.stat() raises OSError, not IOError if the file
# doesn't exist, so in this case we let IOError get
# raised so as to not mask possibly serious disk or
# network issues.
continue
if stat.S_IMODE(st[stat.ST_MODE]) & 0111:
try:
reject.index(f)
except ValueError:
return os.path.normpath(f)
continue
return None | KeyError | dataset/ETHPy150Open kayhayen/Nuitka/nuitka/build/inline_copy/lib/scons-2.3.2/SCons/Util.py/WhereIs |
4,971 | def popitem(self):
try:
key = self._keys[-1]
except __HOLE__:
raise KeyError('dictionary is empty')
val = self[key]
del self[key]
return (key, val) | IndexError | dataset/ETHPy150Open kayhayen/Nuitka/nuitka/build/inline_copy/lib/scons-2.3.2/SCons/Util.py/OrderedDict.popitem |
4,972 | def __call__(self, env, source, ext=None):
if ext is None:
try:
ext = source[0].suffix
except __HOLE__:
ext = ""
try:
return self[ext]
except KeyError:
# Try to perform Environment substitution on the keys of
# the dictionary before giving up.
s_dict = {}
for (k,v) in self.items():
if k is not None:
s_k = env.subst(k)
if s_k in s_dict:
# We only raise an error when variables point
# to the same suffix. If one suffix is literal
# and a variable suffix contains this literal,
# the literal wins and we don't raise an error.
raise KeyError(s_dict[s_k][0], k, s_k)
s_dict[s_k] = (k,v)
try:
return s_dict[ext][1]
except KeyError:
try:
return self[None]
except KeyError:
return None | IndexError | dataset/ETHPy150Open kayhayen/Nuitka/nuitka/build/inline_copy/lib/scons-2.3.2/SCons/Util.py/Selector.__call__ |
4,973 | def unique(s):
"""Return a list of the elements in s, but without duplicates.
For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
unique("abcabc") some permutation of ["a", "b", "c"], and
unique(([1, 2], [2, 3], [1, 2])) some permutation of
[[2, 3], [1, 2]].
For best speed, all sequence elements should be hashable. Then
unique() will usually work in linear time.
If not possible, the sequence elements should enjoy a total
ordering, and if list(s).sort() doesn't raise TypeError it's
assumed that they do enjoy a total ordering. Then unique() will
usually work in O(N*log2(N)) time.
If that's not possible either, the sequence elements must support
equality-testing. Then unique() will usually work in quadratic
time.
"""
n = len(s)
if n == 0:
return []
# Try using a dict first, as that's the fastest and will usually
# work. If it doesn't work, it will usually fail quickly, so it
# usually doesn't cost much to *try* it. It requires that all the
# sequence elements be hashable, and support equality comparison.
u = {}
try:
for x in s:
u[x] = 1
except TypeError:
pass # move on to the next method
else:
return list(u.keys())
del u
# We can't hash all the elements. Second fastest is to sort,
# which brings the equal elements together; then duplicates are
# easy to weed out in a single pass.
# NOTE: Python's list.sort() was designed to be efficient in the
# presence of many duplicate elements. This isn't true of all
# sort functions in all languages or libraries, so this approach
# is more effective in Python than it may be elsewhere.
try:
t = sorted(s)
except __HOLE__:
pass # move on to the next method
else:
assert n > 0
last = t[0]
lasti = i = 1
while i < n:
if t[i] != last:
t[lasti] = last = t[i]
lasti = lasti + 1
i = i + 1
return t[:lasti]
del t
# Brute force is all that's left.
u = []
for x in s:
if x not in u:
u.append(x)
return u
# From Alex Martelli,
# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52560
# ASPN: Python Cookbook: Remove duplicates from a sequence
# First comment, dated 2001/10/13.
# (Also in the printed Python Cookbook.) | TypeError | dataset/ETHPy150Open kayhayen/Nuitka/nuitka/build/inline_copy/lib/scons-2.3.2/SCons/Util.py/unique |
4,974 | def write(self, arg):
try:
self.file.write(arg)
self.file.flush()
except __HOLE__:
# Stdout might be connected to a pipe that has been closed
# by now. The most likely reason for the pipe being closed
# is that the user has press ctrl-c. It this is the case,
# then SCons is currently shutdown. We therefore ignore
# IOError's here so that SCons can continue and shutdown
# properly so that the .sconsign is correctly written
# before SCons exits.
pass | IOError | dataset/ETHPy150Open kayhayen/Nuitka/nuitka/build/inline_copy/lib/scons-2.3.2/SCons/Util.py/Unbuffered.write |
4,975 | def silent_intern(x):
"""
Perform sys.intern() on the passed argument and return the result.
If the input is ineligible (e.g. a unicode string) the original argument is
returned and no exception is thrown.
"""
try:
return sys.intern(x)
except __HOLE__:
return x
# From Dinu C. Gherman,
# Python Cookbook, second edition, recipe 6.17, p. 277.
# Also:
# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/68205
# ASPN: Python Cookbook: Null Object Design Pattern
#TODO??? class Null(object): | TypeError | dataset/ETHPy150Open kayhayen/Nuitka/nuitka/build/inline_copy/lib/scons-2.3.2/SCons/Util.py/silent_intern |
4,976 | def sync(self):
'''Copy disk image to path, regenerate OVF descriptor'''
self.copy_disk()
self.ovf_descriptor = self.new_ovf_descriptor()
ovf_xml = self.ovf_descriptor.generate_ovf_xml()
try:
os.makedirs(os.path.dirname(self.ovf_path))
except __HOLE__, e:
if "File exists" not in e:
raise
ovf_xml.write(self.ovf_path) | OSError | dataset/ETHPy150Open redhat-imaging/imagefactory/imagefactory_plugins/ovfcommon/ovfcommon.py/OVFPackage.sync |
4,977 | def get_jellyroll_items(parser, token):
"""
Load jellyroll ``Item`` objects into the context.In the simplest mode, the
most recent N items will be returned.
::
{# Fetch 10 most recent items #}
{% get_jellyroll_items limit 10 as items %}
Newer items will be first in the list (i.e. ordered by timstamp descending)
unless you ask for them to be reversed::
{# Fetch the 10 earliest items #}
{% get_jellyroll_items limit 10 reversed as items %}
You can also fetch items between two given dates::
{% get_jellyroll_items between "2007-01-01" and "2007-01-31" as items %}
Dates can be in any format understood by ``dateutil.parser``, and can of
course be variables. Items must be limited in some way; you must either pass
``limit`` or ``between``.
Dates can also be the magic strings "now" or "today"::
{% get_jellyroll_items between "2007-01-01" and "today" as items %}
You can also limit items by type::
{# Fetch the 10 most recent videos and photos #}
{% get_jellyroll_items oftype video oftype photo limit 10 as items %}
``oftype`` can be given as many times as you like; only those types will be
returned. The arguments to ``oftype`` are the lowercased class names of
jellyroll'd items.
You can similarly exclude types using ``excludetype``::
{# Fetch the 10 most items that are not videos #}
{% get_jellyroll_items excludetype video limit 10 as items %}
You can give ``excludetype`` as many times as you like, but it is an error
to use both ``oftype`` and ``excludetype`` in the same tag invocation.
"""
# Parse out the arguments
bits = token.split_contents()
tagname = bits[0]
bits = iter(bits[1:])
args = {}
for bit in bits:
try:
if bit == "limit":
try:
args["limit"] = int(bits.next())
except ValueError:
raise template.TemplateSyntaxError("%r tag: 'limit' requires an integer argument" % tagname)
elif bit == "between":
args["start"] = bits.next()
and_ = bits.next()
args["end"] = bits.next()
if and_ != "and":
raise template.TemplateSyntaxError("%r tag: expected 'and' in 'between' clause, but got %r" % (tagname, and_))
elif bit == "oftype":
args.setdefault("oftypes", []).append(bits.next())
elif bit == "excludetype":
args.setdefault("excludetypes", []).append(bits.next())
elif bit == "reversed":
args["reversed"] = True
elif bit == "as":
args["asvar"] = bits.next()
else:
raise template.TemplateSyntaxError("%r tag: unknown argument: %r" % (tagname, bit))
except StopIteration:
raise template.TemplateSyntaxError("%r tag: an out of arguments when parsing %r clause" % (tagname, bit))
# Make sure "as" was given
if "asvar" not in args:
raise template.TemplateSyntaxError("%r tag: missing 'as'" % tagname)
# Either "limit" or "between" has to be specified
if "limit" not in args and ("start" not in args or "end" not in args):
raise template.TemplateSyntaxError("%r tag: 'limit' or a full 'between' clause is required" % tagname)
# It's an error to have both "oftype" and "excludetype"
if "oftype" in args and "excludetype" in args:
raise template.TemplateSyntaxError("%r tag: can't handle both 'oftype' and 'excludetype'" % tagname)
# Each of the "oftype" and "excludetype" arguments has be a valid model
for arg in ("oftypes", "excludetypes"):
if arg in args:
model_list = []
for name in args[arg]:
try:
model_list.append(Item.objects.models_by_name[name])
except __HOLE__:
raise template.TemplateSyntaxError("%r tag: invalid model name: %r" % (tagname, name))
args[arg] = model_list
return GetJellyrollItemsNode(**args) | KeyError | dataset/ETHPy150Open jacobian-archive/jellyroll/src/jellyroll/templatetags/jellyroll.py/get_jellyroll_items |
4,978 | def resolve_date(self, d, context):
"""Resolve start/end, handling literals"""
try:
d = template.resolve_variable(d, context)
except template.VariableDoesNotExist:
return None
# Handle date objects
if isinstance(d, (datetime.date, datetime.datetime)):
return d
# Assume literals or strings
if d == "now":
return datetime.datetime.now()
if d == "today":
return datetime.date.today()
try:
return dateutil.parser.parse(d)
except __HOLE__:
return None | ValueError | dataset/ETHPy150Open jacobian-archive/jellyroll/src/jellyroll/templatetags/jellyroll.py/GetJellyrollItemsNode.resolve_date |
4,979 | def delete(self):
"""Removes from disk atomically, can not then subsequently call read(), write() or addChildren()
"""
os.remove(self.getJobFileName()) #This is the atomic operation, if this file is not present the job is deleted.
dirToRemove = self.jobDir
while 1:
head, tail = os.path.split(dirToRemove)
if re.match("t[0-9]+$", tail):
command = "rm -rf %s" % dirToRemove
else:
command = "rm -rf %s/*" % dirToRemove #We're at the root
try:
system(command)
except __HOLE__:
pass #This is not a big deal, as we expect collisions
dirToRemove = head
try:
if len(os.listdir(dirToRemove)) != 0:
break
except os.error: #In case stuff went wrong, but as this is not critical we let it slide
break | RuntimeError | dataset/ETHPy150Open benedictpaten/jobTree/src/job.py/Job.delete |
4,980 | def main(nick=None, user=None, dest=None):
if nick is None: # pragma: no cover
try:
nick = sys.argv[1]
except __HOLE__:
print(__doc__)
sys.exit(-1)
dest = dest or os.getcwd()
user = user or os.environ.get('USER', 'mynick')
config = dict(nick=nick, user=user, hash='${hash}')
data = get_template('config.ini', **config)
with open(os.path.join(dest, 'config.ini'), 'w') as fd:
fd.write(data)
data = get_template('plugin.py', **config)
filename = os.path.join(dest, '{nick}_plugin.py'.format(**config))
with open(filename, 'w') as fd:
fd.write(data) | IndexError | dataset/ETHPy150Open gawel/irc3/irc3/template/__init__.py/main |
4,981 | def _setConfigParamsInPDU(self, pdu, kwargs):
"""Check for PDU's mandatory parameters and try to set
remaining unset params (in kwargs) from the config default
values
"""
for param in pdu.mandatoryParams:
if param not in kwargs:
try:
pdu.params[param] = getattr(self.config, param)
except __HOLE__:
pdu.params[param] = None
return pdu | AttributeError | dataset/ETHPy150Open jookies/jasmin/jasmin/protocols/smpp/operations.py/SMPPOperationFactory._setConfigParamsInPDU |
4,982 | def SubmitSM(self, short_message, data_coding=0, **kwargs):
"""Depending on the short_message length, this method will return a classical SubmitSM or
a serie of linked SubmitSMs (parted message)
"""
kwargs['short_message'] = short_message
kwargs['data_coding'] = data_coding
# Possible data_coding values : 0,1,2,3,4,5,6,7,8,9,10,13,14
# Set the max short message length depending on the
# coding (7, 8 or 16 bits)
if kwargs['data_coding'] in [3, 6, 7, 10]:
# 8 bit coding
bits = 8
maxSmLength = 140
slicedMaxSmLength = maxSmLength - 6
elif kwargs['data_coding'] in [2, 4, 5, 8, 9, 13, 14]:
# 16 bit coding
bits = 16
maxSmLength = 70
slicedMaxSmLength = maxSmLength - 3
else:
# 7 bit coding is the default
# for data_coding in [0, 1] or any other invalid value
bits = 7
maxSmLength = 160
slicedMaxSmLength = 153
longMessage = kwargs['short_message']
if bits == 16:
smLength = len(kwargs['short_message']) / 2
else:
smLength = len(kwargs['short_message'])
# if SM is longer than maxSmLength, build multiple SubmitSMs
# and link them
if smLength > maxSmLength:
total_segments = int(math.ceil(smLength / float(slicedMaxSmLength)))
# Obey to configured longContentMaxParts
if total_segments > self.long_content_max_parts:
total_segments = self.long_content_max_parts
msg_ref_num = self.claimLongMsgRefNum()
for i in range(total_segments):
segment_seqnum = i+1
# Keep in memory previous PDU in order to set nextPdu in it later
try:
tmpPdu
previousPdu = tmpPdu
except __HOLE__:
previousPdu = None
if bits == 16:
kwargs['short_message'] = longMessage[slicedMaxSmLength*i*2:slicedMaxSmLength*(i+1)*2]
else:
kwargs['short_message'] = longMessage[slicedMaxSmLength*i:slicedMaxSmLength*(i+1)]
tmpPdu = self._setConfigParamsInPDU(SubmitSM(**kwargs), kwargs)
if self.long_content_split == 'sar':
# Slice short_message and create the PDU using SAR options
tmpPdu.params['sar_total_segments'] = total_segments
tmpPdu.params['sar_segment_seqnum'] = segment_seqnum
tmpPdu.params['sar_msg_ref_num'] = msg_ref_num
elif self.long_content_split == 'udh':
# Slice short_message and create the PDU using UDH options
tmpPdu.params['esm_class'] = EsmClass(
EsmClassMode.DEFAULT, EsmClassType.DEFAULT, [EsmClassGsmFeatures.UDHI_INDICATOR_SET])
if segment_seqnum < total_segments:
tmpPdu.params['more_messages_to_send'] = MoreMessagesToSend.MORE_MESSAGES
else:
tmpPdu.params['more_messages_to_send'] = MoreMessagesToSend.NO_MORE_MESSAGES
# UDH composition:
udh = []
# Length of User Data Header
udh.append(struct.pack('!B', 5))
# Information Element Identifier, equal to 00
# (Concatenated short messages, 8-bit reference number)
udh.append(struct.pack('!B', 0))
# Length of the header, excluding the first two fields; equal to 03
udh.append(struct.pack('!B', 3))
udh.append(struct.pack('!B', msg_ref_num))
udh.append(struct.pack('!B', total_segments))
udh.append(struct.pack('!B', segment_seqnum))
tmpPdu.params['short_message'] = ''.join(udh) + kwargs['short_message']
# - The first PDU is the one we return back
# - sar_msg_ref_num takes the seqnum of the initial submit_sm
if i == 0:
pdu = tmpPdu
# PDU chaining
if previousPdu is not None:
previousPdu.nextPdu = tmpPdu
else:
pdu = self._setConfigParamsInPDU(SubmitSM(**kwargs), kwargs)
return pdu | NameError | dataset/ETHPy150Open jookies/jasmin/jasmin/protocols/smpp/operations.py/SMPPOperationFactory.SubmitSM |
4,983 | def _remove_file(filepath):
if not filepath:
return
try:
os.remove(filepath)
except __HOLE__:
pass | OSError | dataset/ETHPy150Open openstack/cloudbase-init/cloudbaseinit/tests/plugins/common/test_execcmd.py/_remove_file |
4,984 | def __getitem__(self, index):
while 1:
try:
file = self.files[self.index]
self.index = self.index + 1
except __HOLE__:
self.index = 0
self.directory = self.stack.pop()
self.files = os.listdir(self.directory)
else:
fullname = os.path.join(self.directory, file)
if os.path.isdir(fullname) and not os.path.islink(fullname):
self.stack.append(fullname)
if not (file.startswith('.') or file.startswith('#') or file.endswith('~')) \
and fnmatch.fnmatch(file, self.pattern):
return fullname | IndexError | dataset/ETHPy150Open uwdata/termite-data-server/web2py/extras/build_web2py/setup_app.py/reglob.__getitem__ |
4,985 | def send(self, data_to_send):
""" Immediately sends the data passed in to :func:`service_endpoint_uri`. If the service request fails, the
passed in items are pushed back to the :func:`queue`.
Args:
data_to_send (Array): an array of :class:`contracts.Envelope` objects to send to the service.
"""
request_payload = json.dumps([ a.write() for a in data_to_send ])
request = HTTPClient.Request(self._service_endpoint_uri, bytearray(request_payload, 'utf-8'), { 'Accept': 'application/json', 'Content-Type' : 'application/json; charset=utf-8' })
try:
response = HTTPClient.urlopen(request)
status_code = response.getcode()
if 200 <= status_code < 300:
return
except __HOLE__ as e:
if e.getcode() == 400:
return
except Exception as e:
pass
# Add our unsent data back on to the queue
for data in data_to_send:
self._queue.put(data) | HTTPError | dataset/ETHPy150Open Microsoft/ApplicationInsights-Python/applicationinsights/channel/SenderBase.py/SenderBase.send |
4,986 | @background.setter
def background(self, value):
self._color = value
self.refresh()
# propagate changes to every clone
if self.editor:
for clone in self.editor.clones:
try:
clone.modes.get(self.__class__).background = value
except __HOLE__:
# this should never happen since we're working with clones
pass | KeyError | dataset/ETHPy150Open OpenCobolIDE/OpenCobolIDE/open_cobol_ide/extlibs/pyqode/core/modes/line_highlighter.py/LineHighlighterMode.background |
4,987 | def convert_datestr(datestr):
"""Converts dates like `12/31/2010` into datetime objects."""
try:
return dateutil.parser.parse(datestr)
except (__HOLE__, ValueError, AttributeError):
return None | TypeError | dataset/ETHPy150Open buildingenergy/buildingenergy-platform/seed/utils/time.py/convert_datestr |
4,988 | def patch_translation_field(self, db_field, field, **kwargs):
if db_field.name in self.trans_opts.fields:
if field.required:
field.required = False
field.blank = True
self._orig_was_required['%s.%s' % (db_field.model._meta, db_field.name)] = True
# For every localized field copy the widget from the original field
# and add a css class to identify a modeltranslation widget.
try:
orig_field = db_field.translated_field
except __HOLE__:
pass
else:
orig_formfield = self.formfield_for_dbfield(orig_field, **kwargs)
field.widget = deepcopy(orig_formfield.widget)
if orig_field.name in self.both_empty_values_fields:
from modeltranslation.forms import NullableField, NullCharField
form_class = field.__class__
if issubclass(form_class, NullCharField):
# NullableField don't work with NullCharField
form_class.__bases__ = tuple(
b for b in form_class.__bases__ if b != NullCharField)
field.__class__ = type(
'Nullable%s' % form_class.__name__, (NullableField, form_class), {})
if (
(
db_field.empty_value == 'both' or
orig_field.name in self.both_empty_values_fields
) and isinstance(field.widget, (forms.TextInput, forms.Textarea))
):
field.widget = ClearableWidgetWrapper(field.widget)
css_classes = field.widget.attrs.get('class', '').split(' ')
css_classes.append('mt')
# Add localized fieldname css class
css_classes.append(build_css_class(db_field.name, 'mt-field'))
# Add mt-bidi css class if language is bidirectional
if(get_language_bidi(db_field.language)):
css_classes.append('mt-bidi')
if db_field.language == mt_settings.DEFAULT_LANGUAGE:
# Add another css class to identify a default modeltranslation widget
css_classes.append('mt-default')
if (orig_formfield.required or self._orig_was_required.get(
'%s.%s' % (orig_field.model._meta, orig_field.name))):
# In case the original form field was required, make the
# default translation field required instead.
orig_formfield.required = False
orig_formfield.blank = True
field.required = True
field.blank = False
# Hide clearable widget for required fields
if isinstance(field.widget, ClearableWidgetWrapper):
field.widget = field.widget.widget
field.widget.attrs['class'] = ' '.join(css_classes) | AttributeError | dataset/ETHPy150Open deschler/django-modeltranslation/modeltranslation/admin.py/TranslationBaseModelAdmin.patch_translation_field |
4,989 | def __init__(self, search_query):
if not isinstance(search_query, str):
raise ValueError("Expected str for 1st parameter (search_query).")
self.avail_files = OrderedDict()
self.visible_files = None
self.adj_tokens = {False: None, True: None}
self.vf_iter = None
self.search_params = {"maxResults": 10,
"order": self.preferences["order"]} # relevance by default
self.yts_opts = dict()
parsed = self.__searchParser(search_query)
# search params
self.search_params.update(parsed[0])
# YTa options
_pref = deepcopy(self.preferences) # new object, just to not affect other intances.
if 'metadata' in parsed[1]:
try:
meta_list = parsed[1]['metadata'].split(',')
except __HOLE__:
meta_list = []
if 'desc' in meta_list: _pref['metadata']['desc'] = True
else: _pref['metadata']['desc'] = False
if 'thumb' in meta_list: _pref['metadata']['thumb'] = True
else: _pref['metadata']['thumb'] = False
self.preferences = _pref
# YTs options
self.yts_opts = parsed[1]
if 'audio' in parsed[1] and 'video' not in parsed[1]: self.yts_opts['video'] = False
if 'video' in parsed[1] and 'audio' not in parsed[1]: self.yts_opts['audio'] = False
try:
self.__getChannelId()
except requests.exceptions.ConnectionError:
raise ConnectionError
if parsed[0].get("publishedBefore"): self.search_params["publishedBefore"] += "T00:00:00Z"
if parsed[0].get("publishedAfter"): self.search_params["publishedAfter"] += "T00:00:00Z" | AttributeError | dataset/ETHPy150Open rasguanabana/ytfs/ytfs/actions.py/YTActions.__init__ |
4,990 | def __getChannelId(self):
"""
Obtain channel id for channel name, if present in ``self.search_params``.
"""
if not self.search_params.get("channelId"):
return
api_fixed_url = "https://www.googleapis.com/youtube/v3/channels?part=id&maxResults=1&fields=items%2Fid&"
url = api_fixed_url + urlencode({"key": self.api_key, "forUsername": self.search_params["channelId"]})
get = requests.get(url).json()
try:
self.search_params["channelId"] = get['items'][0]['id']
return # got it
except IndexError:
pass # try searching now...
api_fixed_url = "https://www.googleapis.com/youtube/v3/search?part=snippet&type=channel&fields=items%2Fid&"
url = api_fixed_url + urlencode({"key": self.api_key, "q": self.search_params['channelId']})
get = requests.get(url).json()
try:
self.search_params["channelId"] = get['items'][0]['id']['channelId']
except __HOLE__:
del self.search_params["channelId"] # channel not found | IndexError | dataset/ETHPy150Open rasguanabana/ytfs/ytfs/actions.py/YTActions.__getChannelId |
4,991 | def __searchParser(self, query):
"""
Parse `query` for advanced search options.
Parameters
----------
query : str
Search query to parse. Besides a search query, user can specify additional search parameters and YTFS
specific options. Syntax:
Additional search parameters: ``option:value``. if `value` contains spaces, then surround it with
parentheses; available parameters: `channel`, `max`, `before`, `after`, `order`.
YTFS options: specify options between ``[`` and ``]``; Available options: `a`, `v`, `f`, `P`, `s`, `m`.
If an option takes a parameter, then specify it beetween parentheses.
Examples: ``channel:foo search query``, ``my favourite music [a]``,
``channel:(the famous funny cats channel) [vf(240)P] funny cats max:20``.
Invalid parameters/options are ignored.
Returns
-------
params : tuple
Tuple: 0 - dictionary of url GET parameters; 1 - dictionary of YTStor options.
"""
ret = dict()
parse_params = True
buf = ""
ptr = ""
p_avail = ("channel", "max", "before", "after", "order")
opts = dict()
par_open = False
translate = {
'a': 'audio',
'v': 'video',
'f': 'format',
's': 'stream',
'P': 'stream',
'm': 'metadata',
'max': 'maxResults',
'channel': 'channelId',
'before': 'publishedBefore',
'after': 'publishedAfter',
'order': 'order',
'': 'q'
}
for i in query+' ':
if parse_params:
if not par_open:
if i == ' ': # flush buf
try:
if ret.get(translate[ptr]):
ret[ translate[ptr] ] += ' '
else:
ret[ translate[ptr] ] = ''
ret[ translate[ptr] ] += buf
except KeyError:
pass
ptr = ""
buf = ""
elif i == ':' and buf in p_avail:
ptr = buf
buf = ""
elif not buf and i == '[': # buf must be empty
parse_params = False
ptr = ""
elif i != '(':
buf += i
elif not (par_open == 1 and i == ')'):
buf += i
if i == '(': par_open += 1
if par_open > 0 and i == ')': par_open -= 1
else:
if i == ']':
parse_params = True
par_open = False
ptr = ""
buf = ""
elif ptr and not par_open and i == '(':
par_open = True
elif par_open:
if i == ')':
try:
opts[ translate[ptr] ] = buf
except KeyError:
pass
par_open = False
buf = ""
else:
buf += i
elif i.isalpha():
ptr = i
try:
opts[ translate[ptr] ] = not i.isupper()
except __HOLE__:
pass
return (ret, opts) | KeyError | dataset/ETHPy150Open rasguanabana/ytfs/ytfs/actions.py/YTActions.__searchParser |
4,992 | def updateResults(self, forward=None):
"""
Reload search results or load another "page".
Parameters
----------
forward : bool or None, optional
Whether move forwards or backwards (``True`` or ``False``). If ``None``, then first page is loaded.
"""
# this choses data we need.
files = lambda x: {
i['snippet']['title'].replace('/', '\\'): YTStor(
{'yid': i['id']['videoId'], 'pub_date': i['snippet']['publishedAt']},
opts=self.yts_opts) for i in x['items']
}
descs = lambda x: {
(i['snippet']['title'].replace('/', '\\') + '.txt'): YTMetaStor(
{
'title': i['snippet']['title'],
'yid': i['id']['videoId'],
'desc': i['snippet']['description'],
'channel': i['snippet']['channelTitle'],
'pub_date': i['snippet']['publishedAt']
},
opts=dict()
) for i in x['items']
}
thumbs = lambda x: {
(i['snippet']['title'].replace('/', '\\') + '.jpg'): YTMetaStor(
{'url': i['snippet']['thumbnails']['high']['url'], 'pub_date': i['snippet']['publishedAt']}, opts=dict()
) for i in x['items']
}
try:
if self.adj_tokens[forward] is None: # in case someone would somehow cross boundary.
forward = None
except KeyError:
pass
recv = None
try:
try:
data = self.avail_files[ self.adj_tokens[forward] ] # maybe data is already available locally.
except __HOLE__:
recv = self.__search( self.adj_tokens[forward] ) # nope, we have to search.
except KeyError: # wrong index in adj_tokens
if forward is None:
recv = self.__search()
else:
raise ValueError("Valid values for forward are True, False or None (default).")
if recv is not None:
_d = files(recv)
if self.preferences['metadata']['desc']: _d.update(descs(recv))
if self.preferences['metadata']['thumb']: _d.update(thumbs(recv))
data = (None, _d) # little format unification.
if len(self.avail_files) > 4:
pop = self.avail_files.popitem(False) # get rid of the oldest data.
for s in pop[1][1].values(): s.clean()
adj_t = deepcopy(self.adj_tokens) # this will we write to avail_files, now we update self.adj_tokens.
if data[0] is None: # get tokens from obtained results.
try:
self.adj_tokens[False] = recv['prevPageToken']
except KeyError:
self.adj_tokens[False] = None
try:
self.adj_tokens[True] = recv['nextPageToken']
except KeyError:
self.adj_tokens[True] = None
else: # already in avail_files.
self.adj_tokens = data[0]
if forward is not None:
# backup last results in avail_files:
self.avail_files[ self.adj_tokens[not forward] ] = (adj_t, self.visible_files)
self.visible_files = data[1] | KeyError | dataset/ETHPy150Open rasguanabana/ytfs/ytfs/actions.py/YTActions.updateResults |
4,993 | def act(self):
try:
address = self.command[0]
self.window.buffer.read(address)
except __HOLE__:
pass | IndexError | dataset/ETHPy150Open elmar-hinz/Python.Vii/vii/Interpreter.py/EditAction.act |
4,994 | def act(self):
try:
address = self.command[0]
self.window.buffer.write(address)
except __HOLE__:
self.window.buffer.write() | IndexError | dataset/ETHPy150Open elmar-hinz/Python.Vii/vii/Interpreter.py/WriteAction.act |
4,995 | def get_class_from_string(path, default=None):
"""
Return the class specified by the string.
IE: django.contrib.auth.models.User
Will return the user class or cause an ImportError
"""
try:
from importlib import import_module
except __HOLE__:
from django.utils.importlib import import_module
i = path.rfind('.')
module, attr = path[:i], path[i + 1:]
mod = import_module(module)
try:
return getattr(mod, attr)
except AttributeError:
if default:
return default
else:
raise ImportError(
'Cannot import name {} (from {})'.format(attr, mod)) | ImportError | dataset/ETHPy150Open GetStream/stream-django/stream_django/utils.py/get_class_from_string |
4,996 | def tno_can_add(self, node, add_object):
""" Returns whether a given object is droppable on the node.
"""
from mayavi.core.filter import Filter
try:
if issubclass(add_object, Filter) or \
issubclass(add_object, ModuleManager):
return True
except __HOLE__:
if isinstance(add_object, Filter) or \
isinstance(add_object, ModuleManager):
return True
return False | TypeError | dataset/ETHPy150Open enthought/mayavi/mayavi/core/source.py/Source.tno_can_add |
4,997 | def action(self):
'''
Should only run once to cleanup stale lane uxd files.
'''
if not is_windows() and self.opts.value.get('sock_dir'):
sockdirpath = os.path.abspath(self.opts.value['sock_dir'])
console.concise("Cleaning up uxd files in {0}\n".format(sockdirpath))
protecteds = self.opts.value.get('raet_cleanup_protecteds', [])
for name in os.listdir(sockdirpath):
path = os.path.join(sockdirpath, name)
if os.path.isdir(path):
continue
root, ext = os.path.splitext(name)
if ext != '.uxd':
continue
if not all(root.partition('.')):
continue
if path in protecteds:
continue
try:
os.unlink(path)
console.concise("Removed {0}\n".format(path))
except __HOLE__:
console.concise("Failed removing {0}\n".format(path))
raise | OSError | dataset/ETHPy150Open saltstack/salt/salt/daemons/flo/core.py/SaltRaetCleanup.action |
4,998 | def _process_road_rxmsg(self, msg, sender):
'''
Send to the right queue
msg is the message body dict
sender is the unique name of the remote estate that sent the message
'''
try:
s_estate, s_yard, s_share = msg['route']['src']
d_estate, d_yard, d_share = msg['route']['dst']
except (__HOLE__, IndexError):
log.error('Received invalid message: {0}'.format(msg))
return
if s_estate is None: # drop
return
log.debug("**** Road Router rxMsg **** id={0} estate={1} yard={2}\n"
" msg= {3}\n".format(
self.opts.value['id'],
self.road_stack.value.local.name,
self.lane_stack.value.local.name,
msg))
if d_estate is not None and d_estate != self.road_stack.value.local.name:
log.error(
'Road Router Received message for wrong estate: {0}'.format(d_estate))
return
if d_yard is not None:
# Meant for another yard, send it off!
if d_yard in self.lane_stack.value.nameRemotes:
self.lane_stack.value.transmit(msg,
self.lane_stack.value.nameRemotes[d_yard].uid)
return
if d_share is None:
# No queue destination!
log.error('Received message without share: {0}'.format(msg))
return
elif d_share == 'event_fire': # rebroadcast events from other masters
self.event.value.append(msg)
#log.debug("\n**** Event Fire \n {0}\n".format(msg))
return
elif d_share == 'local_cmd':
# Refuse local commands over the wire
log.error('Received local command remotely! Ignoring: {0}'.format(msg))
return
elif d_share == 'remote_cmd':
# Send it to a remote worker
if 'load' in msg:
role = self.road_stack.value.nameRemotes[sender].role
msg['load']['id'] = role # sender # should this be role XXXX
self.lane_stack.value.transmit(msg,
self.lane_stack.value.fetchUidByName(next(self.workers.value))) | ValueError | dataset/ETHPy150Open saltstack/salt/salt/daemons/flo/core.py/SaltRaetRouterMaster._process_road_rxmsg |
4,999 | def _process_lane_rxmsg(self, msg, sender):
'''
Send uxd messages tot he right queue or forward them to the correct
yard etc.
msg is message body dict
sender is unique name of remote that sent the message
'''
try:
s_estate, s_yard, s_share = msg['route']['src']
d_estate, d_yard, d_share = msg['route']['dst']
except (ValueError, __HOLE__):
log.error('Lane Router Received invalid message: {0}'.format(msg))
return
if s_yard is None:
return # drop message
if s_estate is None: # substitute local estate
s_estate = self.road_stack.value.local.name
msg['route']['src'] = (s_estate, s_yard, s_share)
log.debug("**** Lane Router rxMsg **** id={0} estate={1} yard={2}\n"
" msg={3}\n".format(
self.opts.value['id'],
self.road_stack.value.local.name,
self.lane_stack.value.local.name,
msg))
if d_estate is None:
pass
elif d_estate != self.road_stack.value.local.name:
# Forward to the correct estate
if d_estate in self.road_stack.value.nameRemotes:
self.road_stack.value.message(msg,
self.road_stack.value.nameRemotes[d_estate].uid)
return
if d_share == 'pub_ret':
# only publish to available minions
msg['return']['ret']['minions'] = self._availablize(msg['return']['ret']['minions'])
if msg.get('__worker_verify') == self.worker_verify.value:
self.publish.value.append(msg)
if d_yard is None:
pass
elif d_yard != self.lane_stack.value.local.name:
# Meant for another yard, send it off!
if d_yard in self.lane_stack.value.nameRemotes:
self.lane_stack.value.transmit(msg,
self.lane_stack.value.nameRemotes[d_yard].uid)
return
if d_share is None:
# No queue destination!
log.error('Lane Router Received message without share: {0}'.format(msg))
return
elif d_share == 'local_cmd':
self.lane_stack.value.transmit(msg,
self.lane_stack.value.fetchUidByName(next(self.workers.value)))
elif d_share == 'event_req':
self.event_req.value.append(msg)
#log.debug("\n**** Event Subscribe \n {0}\n".format(msg))
elif d_share == 'event_fire':
self.event.value.append(msg)
#log.debug("\n**** Event Fire \n {0}\n".format(msg))
elif d_share == 'presence_req':
self.presence_req.value.append(msg)
#log.debug("\n**** Presence Request \n {0}\n".format(msg))
elif d_share == 'stats_req':
self.stats_req.value.append(msg)
#log.debug("\n**** Stats Request \n {0}\n".format(msg)) | IndexError | dataset/ETHPy150Open saltstack/salt/salt/daemons/flo/core.py/SaltRaetRouterMaster._process_lane_rxmsg |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.