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 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 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 __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 __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 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 reset_perishable_history(self): #self.reaction_graph.reset() lazy.invalidate(self, 'raf') lazy.invalidate(self, 'reduction_sg') self.n_reactions.clear()