def instance_host(self, value):
self.instance_host_backend.set(self, value)
instance_config = self.credentials
self.client_id = instance_config.get("client_id")
lazy.invalidate(self.session, "token")
def test_result_shadows_descriptor(self):
# The result of the function call should be stored in
# the object __dict__, shadowing the descriptor.
called = []
class Foo(object):
@lazy
def foo(self):
called.append('foo')
return 1
f = Foo()
self.assertTrue(isinstance(Foo.foo, lazy))
self.assertTrue(f.foo is f.foo)
self.assertTrue(f.foo is f.__dict__['foo']) # !
self.assertEqual(len(called), 1)
self.assertEqual(f.foo, 1)
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 1)
lazy.invalidate(f, 'foo')
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 2)
self.assertEqual(f.foo, 1)
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 2)
def test_result_shadows_descriptor(self):
# The result of the function call should be stored in
# the object __dict__, shadowing the descriptor.
called = []
class Foo(object):
@lazy
def foo(self):
called.append('foo')
return 1
f = Foo()
self.assertTrue(isinstance(Foo.foo, lazy))
self.assertTrue(f.foo is f.foo)
self.assertTrue(f.foo is f.__dict__['foo']) # !
self.assertEqual(len(called), 1)
self.assertEqual(f.foo, 1)
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 1)
lazy.invalidate(f, 'foo')
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 2)
self.assertEqual(f.foo, 1)
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 2)
def token(self, value):
_token = value
if _token and _token.get("expires_in"):
# Set the `expires_at` value, overwriting any value
# that may already be there.
delta = timedelta(seconds=_token["expires_in"])
expires_at = datetime.utcnow() + delta
_token["expires_at"] = timestamp_from_datetime(expires_at)
self.backend.set(self, _token)
lazy.invalidate(self.session, "token")
def token(self, value):
_token = value
if _token and _token.get("expires_in"):
# Set the `expires_at` value, overwriting any value
# that may already be there.
delta = timedelta(seconds=_token["expires_in"])
expires_at = datetime.utcnow() + delta
_token["expires_at"] = timestamp_from_datetime(expires_at)
self.backend.set(self, _token)
lazy.invalidate(self.session, "token")
def patch_descriptor_kvs(library_descriptor):
"""
Metadata inheritance can be done purely through XBlocks, but in the import phase
a root block with an InheritanceKeyValueStore is assumed to be at the top of the hierarchy.
This should change in the future, but as XBlocks don't have this KVS, we have to patch it
here manually.
"""
init_dict = {key: getattr(library_descriptor, key) for key in library_descriptor.fields.keys()}
# if set, invalidate '_unwrapped_field_data' so it will be reset
# the next time it will be called
lazy.invalidate(library_descriptor, '_unwrapped_field_data')
# pylint: disable=protected-access
library_descriptor._field_data = inheriting_field_data(InheritanceKeyValueStore(init_dict))
def patch_descriptor_kvs(library_descriptor):
"""
Metadata inheritance can be done purely through XBlocks, but in the import phase
a root block with an InheritanceKeyValueStore is assumed to be at the top of the hierarchy.
This should change in the future, but as XBlocks don't have this KVS, we have to patch it
here manually.
"""
init_dict = {key: getattr(library_descriptor, key) for key in library_descriptor.fields.keys()}
# if set, invalidate '_unwrapped_field_data' so it will be reset
# the next time it will be called
lazy.invalidate(library_descriptor, '_unwrapped_field_data')
# pylint: disable=protected-access
library_descriptor._field_data = inheriting_field_data(InheritanceKeyValueStore(init_dict))
def test_invalidate_uncalled_attribute(self):
# It should be possible to invalidate an empty attribute
# cache without causing harm.
called = []
class Foo(object):
@lazy
def foo(self):
called.append('foo')
return 1
f = Foo()
self.assertEqual(len(called), 0)
lazy.invalidate(f, 'foo') # Nothing happens
def test_invalidate_uncalled_attribute(self):
# It should be possible to invalidate an empty attribute
# cache without causing harm.
called = []
class Foo(object):
@lazy
def foo(self):
called.append('foo')
return 1
f = Foo()
self.assertEqual(len(called), 0)
lazy.invalidate(f, 'foo') # Nothing happens
def compute(self, student, course_structure, scores_client,
submissions_scores):
"""
Compute the grade of this subsection for the given student and course.
"""
lazy.invalidate(self, 'scores')
for descendant_key in course_structure.post_order_traversal(
filter_func=possibly_scored,
start_node=self.location,
):
self._compute_block_score(student, descendant_key,
course_structure, scores_client,
submissions_scores)
self.all_total, self.graded_total = graders.aggregate_scores(
self.scores, self.display_name, self.location)
def compute(self, student, course_structure, scores_client, submissions_scores):
"""
Compute the grade of this subsection for the given student and course.
"""
try:
for descendant_key in course_structure.post_order_traversal(
filter_func=possibly_scored,
start_node=self.location,
):
self._compute_block_score(student, descendant_key, course_structure, scores_client, submissions_scores)
finally:
# self.scores may hold outdated data, force it to refresh on next access
lazy.invalidate(self, 'scores')
self.all_total, self.graded_total = graders.aggregate_scores(self.scores, self.display_name, self.location)
def test_invalidate_reserved_attribute(self):
# It should be possible to invalidate a reserved lazy attribute.
called = []
class Foo(object):
@lazy
def __foo__(self):
called.append('foo')
return 1
f = Foo()
self.assertEqual(f.__foo__, 1)
self.assertEqual(len(called), 1)
lazy.invalidate(f, '__foo__')
self.assertEqual(f.__foo__, 1)
self.assertEqual(len(called), 2)
def test_invalidate_subclass_attribute(self):
# Whereas lazy.invalidate CAN invalidate a subclass (cached) attribute.
called = []
class Bar(object):
@cached
def bar(self):
called.append('bar')
return 1
b = Bar()
self.assertEqual(b.bar, 1)
self.assertEqual(len(called), 1)
lazy.invalidate(b, 'bar')
self.assertEqual(b.bar, 1)
self.assertEqual(len(called), 2)
def __init__(self,
name,
import_name,
static_folder=None,
static_url_path=None,
template_folder=None,
url_prefix=None,
subdomain=None,
url_defaults=None,
root_path=None,
login_url=None,
authorized_url=None,
backend=None):
bp_kwargs = dict(
name=name,
import_name=import_name,
static_folder=static_folder,
static_url_path=static_url_path,
template_folder=template_folder,
url_prefix=url_prefix,
subdomain=subdomain,
url_defaults=url_defaults,
root_path=root_path,
)
# `root_path` didn't exist in 0.10, and will cause an error if it's
# passed in that version. Only pass `root_path` if it's set.
if bp_kwargs["root_path"] is None:
del bp_kwargs["root_path"]
flask.Blueprint.__init__(self, **bp_kwargs)
login_url = login_url or "/{bp.name}"
authorized_url = authorized_url or "/{bp.name}/authorized"
self.add_url_rule(
rule=login_url.format(bp=self),
endpoint="login",
view_func=self.login,
)
self.add_url_rule(
rule=authorized_url.format(bp=self),
endpoint="authorized",
view_func=self.authorized,
)
if backend is None:
self.backend = SessionBackend()
elif callable(backend):
self.backend = backend()
else:
self.backend = backend
self.logged_in_funcs = []
self.from_config = {}
invalidate_token = lambda d: lazy.invalidate(self.session, "token")
self.config = CallbackDict(on_update=invalidate_token)
self.before_app_request(self.load_config)
def test_invalidate_attribute(self):
# It should be possible to invalidate a lazy attribute.
called = []
class Foo(object):
@lazy
def foo(self):
called.append('foo')
return 1
f = Foo()
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 1)
lazy.invalidate(f, 'foo')
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 2)
def test_invalidate_attribute(self):
# It should be possible to invalidate a lazy attribute.
called = []
class Foo(object):
@lazy
def foo(self):
called.append('foo')
return 1
f = Foo()
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 1)
lazy.invalidate(f, 'foo')
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 2)
def test_invalidate_reserved_attribute(self):
# It should be possible to invalidate a reserved lazy attribute.
called = []
class Foo(object):
@lazy
def __foo__(self):
called.append('foo')
return 1
f = Foo()
self.assertEqual(f.__foo__, 1)
self.assertEqual(len(called), 1)
lazy.invalidate(f, '__foo__')
self.assertEqual(f.__foo__, 1)
self.assertEqual(len(called), 2)
def test_invalidate_subclass_attribute(self):
# Whereas lazy.invalidate CAN invalidate a subclass (cached) attribute.
called = []
class Bar(object):
@cached
def bar(self):
called.append('bar')
return 1
b = Bar()
self.assertEqual(b.bar, 1)
self.assertEqual(len(called), 1)
lazy.invalidate(b, 'bar')
self.assertEqual(b.bar, 1)
self.assertEqual(len(called), 2)
def __init__(self,
name,
import_name,
static_folder=None,
static_url_path=None,
template_folder=None,
url_prefix=None,
subdomain=None,
url_defaults=None,
root_path=None,
login_url=None,
authorized_url=None,
backend=None):
bp_kwargs = dict(
name=name,
import_name=import_name,
static_folder=static_folder,
static_url_path=static_url_path,
template_folder=template_folder,
url_prefix=url_prefix,
subdomain=subdomain,
url_defaults=url_defaults,
root_path=root_path,
)
# `root_path` didn't exist until 1.0
if StrictVersion(flask.__version__) < StrictVersion('1.0'):
del bp_kwargs["root_path"]
flask.Blueprint.__init__(self, **bp_kwargs)
login_url = login_url or "/{bp.name}"
authorized_url = authorized_url or "/{bp.name}/authorized"
self.add_url_rule(
rule=login_url.format(bp=self),
endpoint="login",
view_func=self.login,
)
self.add_url_rule(
rule=authorized_url.format(bp=self),
endpoint="authorized",
view_func=self.authorized,
)
if backend is None:
self.backend = SessionBackend()
elif callable(backend):
self.backend = backend()
else:
self.backend = backend
self.logged_in_funcs = []
self.from_config = {}
self.config = Dictective(
lambda d: lazy.invalidate(self.session, "token"))
self.before_app_request(self.load_config)
def test_invalidate_private_attribute(self):
# It should be possible to invalidate a private lazy attribute.
called = []
class Foo(object):
@lazy
def __foo(self):
called.append('foo')
return 1
def get_foo(self):
return self.__foo
f = Foo()
self.assertEqual(f.get_foo(), 1)
self.assertEqual(len(called), 1)
lazy.invalidate(f, '__foo')
self.assertEqual(f.get_foo(), 1)
self.assertEqual(len(called), 2)
def test_invalidate_attribute_twice(self):
# It should be possible to invalidate a lazy attribute
# twice without causing harm.
called = []
class Foo(object):
@lazy
def foo(self):
called.append('foo')
return 1
f = Foo()
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 1)
lazy.invalidate(f, 'foo')
lazy.invalidate(f, 'foo') # Nothing happens
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 2)
def test_invalidate_attribute_twice(self):
# It should be possible to invalidate a lazy attribute
# twice without causing harm.
called = []
class Foo(object):
@lazy
def foo(self):
called.append('foo')
return 1
f = Foo()
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 1)
lazy.invalidate(f, 'foo')
lazy.invalidate(f, 'foo') # Nothing happens
self.assertEqual(f.foo, 1)
self.assertEqual(len(called), 2)
def test_invalidate_private_attribute(self):
# It should be possible to invalidate a private lazy attribute.
called = []
class Foo(object):
@lazy
def __foo(self):
called.append('foo')
return 1
def get_foo(self):
return self.__foo
f = Foo()
self.assertEqual(f.get_foo(), 1)
self.assertEqual(len(called), 1)
lazy.invalidate(f, '__foo')
self.assertEqual(f.get_foo(), 1)
self.assertEqual(len(called), 2)
def __init__(self, name, import_name,
static_folder=None, static_url_path=None, template_folder=None,
url_prefix=None, subdomain=None, url_defaults=None, root_path=None,
login_url=None, authorized_url=None, backend=None):
bp_kwargs = dict(
name=name,
import_name=import_name,
static_folder=static_folder,
static_url_path=static_url_path,
template_folder=template_folder,
url_prefix=url_prefix,
subdomain=subdomain,
url_defaults=url_defaults,
root_path=root_path,
)
# `root_path` didn't exist in 0.10, and will cause an error if it's
# passed in that version. Only pass `root_path` if it's set.
if bp_kwargs["root_path"] is None:
del bp_kwargs["root_path"]
flask.Blueprint.__init__(self, **bp_kwargs)
login_url = login_url or "/{bp.name}"
authorized_url = authorized_url or "/{bp.name}/authorized"
self.add_url_rule(
rule=login_url.format(bp=self),
endpoint="login",
view_func=self.login,
)
self.add_url_rule(
rule=authorized_url.format(bp=self),
endpoint="authorized",
view_func=self.authorized,
)
if backend is None:
self.backend = SessionBackend()
elif callable(backend):
self.backend = backend()
else:
self.backend = backend
self.logged_in_funcs = []
self.from_config = {}
invalidate_token = lambda d: lazy.invalidate(self.session, "token")
self.config = CallbackDict(on_update=invalidate_token)
self.before_app_request(self.load_config)
def __init__(self, name, import_name,
static_folder=None, static_url_path=None, template_folder=None,
url_prefix=None, subdomain=None, url_defaults=None, root_path=None,
login_url=None, authorized_url=None, backend=None):
bp_kwargs = dict(
name=name,
import_name=import_name,
static_folder=static_folder,
static_url_path=static_url_path,
template_folder=template_folder,
url_prefix=url_prefix,
subdomain=subdomain,
url_defaults=url_defaults,
root_path=root_path,
)
# `root_path` didn't exist until 1.0
if StrictVersion(flask.__version__) < StrictVersion('1.0'):
del bp_kwargs["root_path"]
flask.Blueprint.__init__(self, **bp_kwargs)
login_url = login_url or "/{bp.name}"
authorized_url = authorized_url or "/{bp.name}/authorized"
self.add_url_rule(
rule=login_url.format(bp=self),
endpoint="login",
view_func=self.login,
)
self.add_url_rule(
rule=authorized_url.format(bp=self),
endpoint="authorized",
view_func=self.authorized,
)
if backend is None:
self.backend = SessionBackend()
elif callable(backend):
self.backend = backend()
else:
self.backend = backend
self.logged_in_funcs = []
self.from_config = {}
self.config = Dictective(lambda d: lazy.invalidate(self.session, "token"))
self.before_app_request(self.load_config)
def teardown_session(self, exception=None):
lazy.invalidate(self, "session")
def __setitem__(self, key, value):
lazy.invalidate(self, 'all_messages')
self.json_data[key] = value
def token(self, value):
self.backend.set(self, value)
lazy.invalidate(self.session, "token")
def teardown_session(self, exception=None):
lazy.invalidate(self, "session")
def instance_host(self):
self.instance_host_backend.delete(self)
lazy.invalidate(self.session, "token")
def __init__(self, blueprint=None, base_url=None, *args, **kwargs):
super(OAuth2Session, self).__init__(*args, **kwargs)
self.blueprint = blueprint
self.base_url = URLObject(base_url)
lazy.invalidate(self, "token")
def token(self):
self.backend.delete(self)
lazy.invalidate(self.session, "token")
def token(self, value):
self.backend.set(self, value)
lazy.invalidate(self.session, "token")
def __init__(self, blueprint=None, base_url=None, *args, **kwargs):
super(OAuth2Session, self).__init__(*args, **kwargs)
self.blueprint = blueprint
self.base_url = URLObject(base_url)
lazy.invalidate(self, "token")
def token(self):
self.backend.delete(self)
lazy.invalidate(self.session, "token")
def reset_perishable_history(self):
#self.reaction_graph.reset()
lazy.invalidate(self, 'raf')
lazy.invalidate(self, 'reduction_sg')
self.n_reactions.clear()
