input stringlengths 11 7.65k | target stringlengths 22 8.26k |
|---|---|
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def check_fresh_login():
"""Checks if the login is fresh for the current user, otherwise the user
has to reauthenticate."""
if not login_fresh():
return current_app.login_manager.needs_refresh() |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def commit(self):
context = self.pop()
if self:
# savepoint
self[-1]['cbs'].extend(context['cbs'])
self[-1]['dirty'] = self[-1]['dirty'] or context['dirty']
else:
# transaction
for func, args, kwargs in context['cbs']:
f... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def overview():
# user and group stats
banned_users = User.query.filter(
Group.banned == True,
Group.id == User.primary_group_id
).count()
if not current_app.config["REDIS_ENABLED"]:
online_users = User.query.filter(User.lastseen >= time_diff()).count()
else:
online_u... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def rollback(self):
self.pop() |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def settings(slug=None):
slug = slug if slug else "general"
# get the currently active group
active_group = SettingsGroup.query.filter_by(key=slug).first_or_404()
# get all groups - used to build the navigation
all_groups = SettingsGroup.query.all()
SettingsForm = Setting.get_form(active_group... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def push(self, item):
self[-1]['cbs'].append(item) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def users():
page = request.args.get("page", 1, type=int)
search_form = UserSearchForm()
if search_form.validate():
users = search_form.get_results().\
paginate(page, flaskbb_config['USERS_PER_PAGE'], False)
return render_template("management/users.html", users=users,
... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def mark_dirty(self):
self[-1]['dirty'] = True |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def edit_user(user_id):
user = User.query.filter_by(id=user_id).first_or_404()
if not Permission(CanEditUser, identity=current_user):
flash(_("You are not allowed to edit this user."), "danger")
return redirect(url_for("management.users"))
member_group = db.and_(*[db.not_(getattr(Group, p)... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def is_dirty(self):
return any(context['dirty'] for context in self) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def delete_user(user_id=None):
# ajax request
if request.is_xhr:
ids = request.get_json()["ids"]
data = []
for user in User.query.filter(User.id.in_(ids)).all():
# do not delete current user
if current_user.id == user.id:
continue
if ... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __init__(self):
super(TransactionStates, self).__init__()
self._states = defaultdict(TransactionState) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def add_user():
form = AddUserForm()
if form.validate_on_submit():
form.save()
flash(_("User added."), "success")
return redirect(url_for("management.users"))
return render_template("management/user_form.html", form=form,
title=_("Add User")) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __getitem__(self, key):
return self._states[key or DEFAULT_DB_ALIAS] |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def banned_users():
page = request.args.get("page", 1, type=int)
search_form = UserSearchForm()
users = User.query.filter(
Group.banned == True,
Group.id == User.primary_group_id
).paginate(page, flaskbb_config['USERS_PER_PAGE'], False)
if search_form.validate():
users = se... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def is_dirty(self, dbs):
return any(self[db].is_dirty() for db in dbs) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def ban_user(user_id=None):
if not Permission(CanBanUser, identity=current_user):
flash(_("You do not have the permissions to ban this user."), "danger")
return redirect(url_for("management.overview"))
# ajax request
if request.is_xhr:
ids = request.get_json()["ids"]
data =... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def queue_when_in_transaction(call):
if transaction_states[call.using]:
transaction_states[call.using].push((call, (), {}))
else:
return call() |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def unban_user(user_id=None):
if not Permission(CanBanUser, identity=current_user):
flash(_("You do not have the permissions to unban this user."),
"danger")
return redirect(url_for("management.overview"))
# ajax request
if request.is_xhr:
ids = request.get_json()["ids... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __enter__(self):
entering = not transaction_states[self.using]
transaction_states[self.using].begin()
self._no_monkey.__enter__(self)
if entering:
on_commit(transaction_states[self.using].commit, self.using) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def reports():
page = request.args.get("page", 1, type=int)
reports = Report.query.\
order_by(Report.id.asc()).\
paginate(page, flaskbb_config['USERS_PER_PAGE'], False)
return render_template("management/reports.html", reports=reports) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __exit__(self, exc_type, exc_value, traceback):
connection = get_connection(self.using)
try:
self._no_monkey.__exit__(self, exc_type, exc_value, traceback)
except DatabaseError:
transaction_states[self.using].rollback()
else:
if not connection.clos... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def unread_reports():
page = request.args.get("page", 1, type=int)
reports = Report.query.\
filter(Report.zapped == None).\
order_by(Report.id.desc()).\
paginate(page, flaskbb_config['USERS_PER_PAGE'], False)
return render_template("management/unread_reports.html", reports=reports) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def callproc(self, procname, params=None):
result = self._no_monkey.callproc(self, procname, params)
if transaction_states[self.db.alias]:
transaction_states[self.db.alias].mark_dirty()
return result |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def report_markread(report_id=None):
# AJAX request
if request.is_xhr:
ids = request.get_json()["ids"]
data = []
for report in Report.query.filter(Report.id.in_(ids)).all():
report.zapped_by = current_user.id
report.zapped = time_utcnow()
report.save(... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def execute(self, sql, params=None):
result = self._no_monkey.execute(self, sql, params)
if transaction_states[self.db.alias] and is_sql_dirty(sql):
transaction_states[self.db.alias].mark_dirty()
return result |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def groups():
page = request.args.get("page", 1, type=int)
groups = Group.query.\
order_by(Group.id.asc()).\
paginate(page, flaskbb_config['USERS_PER_PAGE'], False)
return render_template("management/groups.html", groups=groups) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def executemany(self, sql, param_list):
result = self._no_monkey.executemany(self, sql, param_list)
if transaction_states[self.db.alias] and is_sql_dirty(sql):
transaction_states[self.db.alias].mark_dirty()
return result |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def edit_group(group_id):
group = Group.query.filter_by(id=group_id).first_or_404()
form = EditGroupForm(group)
if form.validate_on_submit():
form.populate_obj(group)
group.save()
if group.guest:
Guest.invalidate_cache()
flash(_("Group updated."), "success")
... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def is_sql_dirty(sql):
# This should not happen as using bytes in Python 3 is against db protocol,
# but some people will pass it anyway
if isinstance(sql, bytes):
sql = sql.decode()
# NOTE: not using regex here for speed
sql = sql.lower()
for action in ('update', 'insert', 'delete'):
... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def delete_group(group_id=None):
if request.is_xhr:
ids = request.get_json()["ids"]
if not (set(ids) & set(["1", "2", "3", "4", "5"])):
data = []
for group in Group.query.filter(Group.id.in_(ids)).all():
group.delete()
data.append({
... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def add_group():
form = AddGroupForm()
if form.validate_on_submit():
form.save()
flash(_("Group added."), "success")
return redirect(url_for("management.groups"))
return render_template("management/group_form.html", form=form,
title=_("Add Group")) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def forums():
categories = Category.query.order_by(Category.position.asc()).all()
return render_template("management/forums.html", categories=categories) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def edit_forum(forum_id):
forum = Forum.query.filter_by(id=forum_id).first_or_404()
form = EditForumForm(forum)
if form.validate_on_submit():
form.save()
flash(_("Forum updated."), "success")
return redirect(url_for("management.edit_forum", forum_id=forum.id))
else:
if f... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def delete_forum(forum_id):
forum = Forum.query.filter_by(id=forum_id).first_or_404()
involved_users = User.query.filter(Topic.forum_id == forum.id,
Post.user_id == User.id).all()
forum.delete(involved_users)
flash(_("Forum deleted."), "success")
return redi... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def add_forum(category_id=None):
form = AddForumForm()
if form.validate_on_submit():
form.save()
flash(_("Forum added."), "success")
return redirect(url_for("management.forums"))
else:
form.groups.data = Group.query.order_by(Group.id.asc()).all()
if category_id:
... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def add_category():
form = CategoryForm()
if form.validate_on_submit():
form.save()
flash(_("Category added."), "success")
return redirect(url_for("management.forums"))
return render_template("management/category_form.html", form=form,
title=_("Add Catego... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def edit_category(category_id):
category = Category.query.filter_by(id=category_id).first_or_404()
form = CategoryForm(obj=category)
if form.validate_on_submit():
form.populate_obj(category)
flash(_("Category updated."), "success")
category.save()
return render_template("manag... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def delete_category(category_id):
category = Category.query.filter_by(id=category_id).first_or_404()
involved_users = User.query.filter(Forum.category_id == category.id,
Topic.forum_id == Forum.id,
Post.user_id == User.id).all()
... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def plugins():
plugins = get_all_plugins()
return render_template("management/plugins.html", plugins=plugins) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def enable_plugin(plugin):
plugin = get_plugin_from_all(plugin)
if plugin.enabled:
flash(_("Plugin %(plugin)s is already enabled.", plugin=plugin.name),
"info")
return redirect(url_for("management.plugins"))
try:
plugin.enable()
flash(_("Plugin %(plugin)s enab... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def disable_plugin(plugin):
try:
plugin = get_plugin(plugin)
except KeyError:
flash(_("Plugin %(plugin)s not found.", plugin=plugin.name), "danger")
return redirect(url_for("management.plugins"))
try:
plugin.disable()
flash(_("Plugin %(plugin)s disabled. Please resta... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def uninstall_plugin(plugin):
plugin = get_plugin_from_all(plugin)
if plugin.uninstallable:
plugin.uninstall()
Setting.invalidate_cache()
flash(_("Plugin has been uninstalled."), "success")
else:
flash(_("Cannot uninstall plugin."), "danger")
return redirect(url_for("ma... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def plugin(self):
return plugins.get(self.plugin_name) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def setUpModule():
base.enabledPlugins.append('provenance')
base.startServer() |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __repr__(self):
return "Authorization(id={id})".format(id=self.id) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def tearDownModule():
base.stopServer() |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def setUp(self):
base.TestCase.setUp(self)
# Create some test documents with an item
admin = {
'email': 'admin@email.com',
'login': 'adminlogin',
'firstName': 'Admin',
'lastName': 'Last',
'password': 'adminpassword',
'admin'... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def _checkProvenance(self, resp, item, version, user, eventType,
matches=None, fileInfo=None, resource='item'):
if resp is None:
resp = self._getProvenance(item, user, resource=resource)
self.assertStatusOk(resp)
itemProvenance = resp.json
self.assert... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def _getProvenance(self, item, user, version=None, resource='item',
checkOk=True):
params = {}
if version is not None:
params = {'version': version}
resp = self.request(
path='/%s/%s/provenance' % (resource, item['_id']),
method='GET', u... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def _getProvenanceAfterMetadata(self, item, meta, user):
resp = self.request(path='/item/%s/metadata' % item['_id'],
method='PUT', user=user, body=json.dumps(meta),
type='application/json')
self.assertStatusOk(resp)
return self._getProvenan... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testProvenanceItemMetadata(self):
"""
Test item provenance endpoint with metadata and basic changes
"""
item = self.item1
user = self.user
admin = self.admin
# check that the first version of the item exists
# ensure version 1, created by admin user, ... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testProvenanceItemFiles(self):
"""
Test item provenance when adding, modifying, and deleting files.
"""
item = self.item1
admin = self.admin
# Test adding a new file to an existing item
fileData1 = 'Hello world'
fileData2 = 'Hello world, again'
... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testProvenanceFolder(self):
"""
Test folder provenance, including turning off and on the provenance
handling of folders.
"""
folder1 = self.folder1
user = self.admin
# check that the first version of the folder provenance exists
self._checkProvenance(... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def _rmsprop_update_numpy(self, var, g, mg, rms, mom, lr, decay, momentum,
centered):
rms_t = rms * decay + (1 - decay) * g * g
if centered:
mg_t = mg * decay + (1 - decay) * g
denom_t = rms_t - mg_t * mg_t
else:
mg_t = mg
denom_t = rms_t
mom_t = momen... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def _sparse_rmsprop_update_numpy(self, var, gindexs, gvalues, mg, rms, mom,
lr, decay, momentum, centered):
mg_t = copy.deepcopy(mg)
rms_t = copy.deepcopy(rms)
mom_t = copy.deepcopy(mom)
var_t = copy.deepcopy(var)
for i in range(len(gindexs)):
gindex = gindex... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testDense(self, dtype, param_value):
(learning_rate, decay, momentum, epsilon, centered, use_resource) = tuple(
param_value)
with self.session(use_gpu=True):
# Initialize variables for numpy implementation.
var0_np = np.array([1.0, 2.0], dtype=dtype.as_numpy_dtype)
grads0_np = np.a... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testMinimizeSparseResourceVariable(self, dtype):
with self.cached_session():
var0 = resource_variable_ops.ResourceVariable([[1.0, 2.0]], dtype=dtype)
x = constant_op.constant([[4.0], [5.0]], dtype=dtype)
pred = math_ops.matmul(embedding_ops.embedding_lookup([var0], [0]), x)
loss = pred *... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testMinimizeSparseResourceVariableCentered(self, dtype):
with self.cached_session():
var0 = resource_variable_ops.ResourceVariable([[1.0, 2.0]], dtype=dtype)
x = constant_op.constant([[4.0], [5.0]], dtype=dtype)
pred = math_ops.matmul(embedding_ops.embedding_lookup([var0], [0]), x)
loss ... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testSparse(self, dtype, param_value):
(learning_rate, decay, momentum, epsilon, centered, _) = tuple(
param_value)
with self.session(use_gpu=True):
# Initialize variables for numpy implementation.
var0_np = np.array([1.0, 2.0], dtype=dtype.as_numpy_dtype)
grads0_np = np.array([0.1]... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testWithoutMomentum(self, dtype):
with self.session(use_gpu=True):
var0 = variables.Variable([1.0, 2.0], dtype=dtype)
var1 = variables.Variable([3.0, 4.0], dtype=dtype)
grads0 = constant_op.constant([0.1, 0.1], dtype=dtype)
grads1 = constant_op.constant([0.01, 0.01], dtype=dtype)
o... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testWithMomentum(self, dtype):
with self.session(use_gpu=True):
var0 = variables.Variable([1.0, 2.0], dtype=dtype)
var1 = variables.Variable([3.0, 4.0], dtype=dtype)
grads0 = constant_op.constant([0.1, 0.1], dtype=dtype)
grads1 = constant_op.constant([0.01, 0.01], dtype=dtype)
opt... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __init__(self):
self.mainFrame = gui.mainFrame.MainFrame.getInstance() |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def display(self, callingWindow, srcContext, mainItem):
if srcContext not in ("marketItemGroup", "marketItemMisc") or self.mainFrame.getActiveFit() is None:
return False
if mainItem is None:
return False
for attr in ("emDamage", "thermalDamage", "explosiveDamage", "kine... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def getText(self, callingWindow, itmContext, mainItem):
return "Set {} as Damage Pattern".format(itmContext if itmContext is not None else "Item") |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def activate(self, callingWindow, fullContext, mainItem, i):
fitID = self.mainFrame.getActiveFit()
Fit.getInstance().setAsPattern(fitID, mainItem)
wx.PostEvent(self.mainFrame, GE.FitChanged(fitIDs=(fitID,))) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def getBitmap(self, callingWindow, context, mainItem):
return None |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testProcessPriorTo24(self):
"""Tests the Process function on a Firefox History database file."""
# This is probably version 23 but potentially an older version.
plugin = firefox_history.FirefoxHistoryPlugin()
storage_writer = self._ParseDatabaseFileWithPlugin(
['places.sqlite'], plugin)
... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def testProcessVersion25(self):
"""Tests the Process function on a Firefox History database file v 25."""
plugin = firefox_history.FirefoxHistoryPlugin()
storage_writer = self._ParseDatabaseFileWithPlugin(
['places_new.sqlite'], plugin)
# The places.sqlite file contains 84 events:
# 34 ... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def each(f):
if f.body:
f.hashes = []
for hash_type, h in HashFile.extract_hashes(f.body.contents):
hash_object = Hash.get_or_create(value=h.hexdigest())
hash_object.add_source("analytics")
hash_object.save()
f.active_link_t... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __init__(self, queue, level, formatter):
super(QueueingLogHandler, self).__init__()
self._queue = queue
self.setLevel(level)
self.setFormatter(formatter) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def emit(self, record):
msg = self.format(record)
self._queue.put_nowait(msg) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def close(self):
super(QueueingLogHandler, self).close()
self._queue.put_nowait(None) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def emitted(self):
return self._queue |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __init__(self):
self._logging_handlers = set() |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def test(self, logger_name, logger_level, message):
logger = logging.getLogger(logger_name)
getattr(logger, logger_level.lower())(message) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def available_loggers(self):
""" List of initalized loggers """
return logging.getLogger().manager.loggerDict.keys() |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def close_log_streams(self):
""" Closes all log_stream streams. """
while self._logging_handlers:
self._logging_handlers.pop().close() |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def log_stream(self, logger_name, level_name, format_str):
""" Attaches a log handler to the specified logger and sends emitted logs
back as stream.
"""
if logger_name != "" and logger_name not in self.available_loggers():
raise ValueError("logger {0} is not available".... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def create(params, env=None, headers=None):
return request.send('post', request.uri_path("plans"), params, env, headers) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def update(id, params=None, env=None, headers=None):
return request.send('post', request.uri_path("plans",id), params, env, headers) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def list(params=None, env=None, headers=None):
return request.send_list_request('get', request.uri_path("plans"), params, env, headers) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def retrieve(id, env=None, headers=None):
return request.send('get', request.uri_path("plans",id), None, env, headers) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def delete(id, env=None, headers=None):
return request.send('post', request.uri_path("plans",id,"delete"), None, env, headers) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def copy(params, env=None, headers=None):
return request.send('post', request.uri_path("plans","copy"), params, env, headers) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def wrapper%(signature)s:
with ldap3mock:
return func%(funcargs)s |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def generateUUID(): # pylint: disable=invalid-name
""" Utility function; generates UUIDs """
return str(uuid.uuid4()) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def _convert_objectGUID(item):
item = uuid.UUID("{{{0!s}}}".format(item)).bytes_le
item = escape_bytes(item)
return item |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def refund_user(self, user_id):
# Do logic here... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __init__(self):
self._calls = [] |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def with_status_check(obj, *args, **kwargs):
if obj.status not in valid_start_statuses:
exception_msg = (
u"Error calling {} {}: status is '{}', must be one of: {}"
).format(func, obj, obj.status, valid_start_statuses)
raise VerificationExc... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __iter__(self):
return iter(self._calls) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def expiration_datetime(self):
"""Datetime that the verification will expire. """
days_good_for = settings.VERIFY_STUDENT["DAYS_GOOD_FOR"]
return self.created_at + timedelta(days=days_good_for) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __len__(self):
return len(self._calls) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def should_display_status_to_user(self):
"""Whether or not the status from this attempt should be displayed to the user."""
return True |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __getitem__(self, idx):
return self._calls[idx] |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def active_at_datetime(self, deadline):
"""Check whether the verification was active at a particular datetime.
Arguments:
deadline (datetime): The date at which the verification was active
(created before and expiration datetime is after today).
Returns:
... |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def setdata(self, request, response):
self._calls.append(Call(request, response)) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def __unicode__(self):
return 'ManualIDVerification for {name}, status: {status}'.format(
name=self.name,
status=self.status,
) |
def emit(self, level, message):
raise NotImplementedError('Please implement an emit method') | def reset(self):
self._calls = [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.