vassili/seitime-frappe
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

refactor: frappe.cache() usage to frappe.cache (#21282)

Browse source
This commit is contained in:
Ankush Menat 2023-06-08 11:47:17 +05:30 • committed by GitHub
parent b6669bb56e
commit fa6dc03cc8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
89 changed files with 313 additions and 339 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
frappe/__init__.py
View file

@ -380,7 +380,7 @@ def errprint(msg: str) -> None:
def print_sql(enable: bool = True) -> None: def print_sql(enable: bool = True) -> None:
return cache().set_value("flag_print_sql", enable) return cache.set_value("flag_print_sql", enable)
def log(msg: str) -> None: def log(msg: str) -> None:
@ -1016,7 +1016,7 @@ def is_table(doctype: str) -> bool:
def get_tables(): def get_tables():
return db.get_values("DocType", filters={"istable": 1}, order_by=None, pluck=True) return db.get_values("DocType", filters={"istable": 1}, order_by=None, pluck=True)
tables = cache().get_value("is_table", get_tables) tables = cache.get_value("is_table", get_tables)
return doctype in tables return doctype in tables
@ -1043,7 +1043,7 @@ def generate_hash(txt: str | None = None, length: int = 56) -> str:
def reset_metadata_version(): def reset_metadata_version():
"""Reset `metadata_version` (Client (Javascript) build ID) hash.""" """Reset `metadata_version` (Client (Javascript) build ID) hash."""
v = generate_hash() v = generate_hash()
cache().set_value("metadata_version", v) cache.set_value("metadata_version", v)
return v return v
@ -1079,7 +1079,7 @@ def set_value(doctype, docname, fieldname, value=None):
def get_cached_doc(*args, **kwargs) -> "Document": def get_cached_doc(*args, **kwargs) -> "Document":
if (key := can_cache_doc(args)) and (doc := cache().get_value(key)): if (key := can_cache_doc(args)) and (doc := cache.get_value(key)):
return doc return doc
# Not found in cache, fetch from DB # Not found in cache, fetch from DB
@ -1095,7 +1095,7 @@ def get_cached_doc(*args, **kwargs) -> "Document":
def _set_document_in_cache(key: str, doc: "Document") -> None: def _set_document_in_cache(key: str, doc: "Document") -> None:
cache().set_value(key, doc) cache.set_value(key, doc)
def can_cache_doc(args) -> str | None: def can_cache_doc(args) -> str | None:
@ -1122,9 +1122,9 @@ def get_document_cache_key(doctype: str, name: str):
def clear_document_cache(doctype: str, name: str | None = None) -> None: def clear_document_cache(doctype: str, name: str | None = None) -> None:
def clear_in_redis(): def clear_in_redis():
if name is not None: if name is not None:
cache().delete_value(get_document_cache_key(doctype, name)) cache.delete_value(get_document_cache_key(doctype, name))
else: else:
cache().delete_keys(get_document_cache_key(doctype, "")) cache.delete_keys(get_document_cache_key(doctype, ""))
clear_in_redis() clear_in_redis()
if hasattr(db, "after_commit"): if hasattr(db, "after_commit"):
@ -1214,7 +1214,7 @@ def get_doc(*args, **kwargs):
doc = frappe.model.document.get_doc(*args, **kwargs) doc = frappe.model.document.get_doc(*args, **kwargs)
# Replace cache if stale one exists # Replace cache if stale one exists
if (key := can_cache_doc(args)) and cache().exists(key): if (key := can_cache_doc(args)) and cache.exists(key):
_set_document_in_cache(key, doc) _set_document_in_cache(key, doc)
return doc return doc
@ -1448,13 +1448,13 @@ def get_installed_apps(sort=False, frappe_last=False, *, _ensure_on_bench=False)
if sort: if sort:
if not local.all_apps: if not local.all_apps:
local.all_apps = cache().get_value("all_apps", get_all_apps) local.all_apps = cache.get_value("all_apps", get_all_apps)
deprecation_warning("`sort` argument is deprecated and will be removed in v15.") deprecation_warning("`sort` argument is deprecated and will be removed in v15.")
installed = [app for app in local.all_apps if app in installed] installed = [app for app in local.all_apps if app in installed]
if _ensure_on_bench: if _ensure_on_bench:
all_apps = cache().get_value("all_apps", get_all_apps) all_apps = cache.get_value("all_apps", get_all_apps)
installed = [app for app in installed if app in all_apps] installed = [app for app in installed if app in all_apps]
if frappe_last: if frappe_last:
@ -1525,7 +1525,7 @@ def get_hooks(
if conf.developer_mode: if conf.developer_mode:
hooks = _dict(_load_app_hooks()) hooks = _dict(_load_app_hooks())
else: else:
hooks = _dict(cache().get_value("app_hooks", _load_app_hooks)) hooks = _dict(cache.get_value("app_hooks", _load_app_hooks))
if hook: if hook:
return hooks.get(hook, ([] if default == "_KEEP_DEFAULT_LIST" else default)) return hooks.get(hook, ([] if default == "_KEEP_DEFAULT_LIST" else default))
@ -1555,11 +1555,9 @@ def append_hook(target, key, value):
def setup_module_map(): def setup_module_map():
"""Rebuild map of all modules (internal).""" """Rebuild map of all modules (internal)."""
_cache = cache()
if conf.db_name: if conf.db_name:
local.app_modules = _cache.get_value("app_modules") local.app_modules = cache.get_value("app_modules")
local.module_app = _cache.get_value("module_app") local.module_app = cache.get_value("module_app")
if not (local.app_modules and local.module_app): if not (local.app_modules and local.module_app):
local.module_app, local.app_modules = {}, {} local.module_app, local.app_modules = {}, {}
@ -1571,8 +1569,8 @@ def setup_module_map():
local.app_modules[app].append(module) local.app_modules[app].append(module)
if conf.db_name: if conf.db_name:
_cache.set_value("app_modules", local.app_modules) cache.set_value("app_modules", local.app_modules)
_cache.set_value("module_app", local.module_app) cache.set_value("module_app", local.module_app)
def get_file_items(path, raise_not_found=False, ignore_empty_lines=True): def get_file_items(path, raise_not_found=False, ignore_empty_lines=True):
@ -1861,7 +1859,7 @@ def redirect_to_message(title, html, http_status_code=None, context=None, indica
if indicator_color: if indicator_color:
message["context"].update({"indicator_color": indicator_color}) message["context"].update({"indicator_color": indicator_color})
cache().set_value(f"message_id:{message_id}", message, expires_in_sec=60) cache.set_value(f"message_id:{message_id}", message, expires_in_sec=60)
location = f"/message?id={message_id}" location = f"/message?id={message_id}"
if not getattr(local, "is_ajax", False): if not getattr(local, "is_ajax", False):

16
frappe/auth.py
View file

@ -188,10 +188,10 @@ class LoginManager:
frappe.response["full_name"] = self.full_name frappe.response["full_name"] = self.full_name
# redirect information # redirect information
redirect_to = frappe.cache().hget("redirect_after_login", self.user) redirect_to = frappe.cache.hget("redirect_after_login", self.user)
if redirect_to: if redirect_to:
frappe.local.response["redirect_to"] = redirect_to frappe.local.response["redirect_to"] = redirect_to
frappe.cache().hdel("redirect_after_login", self.user) frappe.cache.hdel("redirect_after_login", self.user)
frappe.local.cookie_manager.set_cookie("full_name", self.full_name) frappe.local.cookie_manager.set_cookie("full_name", self.full_name)
frappe.local.cookie_manager.set_cookie("user_id", self.user) frappe.local.cookie_manager.set_cookie("user_id", self.user)
@ -482,15 +482,15 @@ class LoginAttemptTracker:
@property @property
def login_failed_count(self): def login_failed_count(self):
return frappe.cache().hget("login_failed_count", self.user_name) return frappe.cache.hget("login_failed_count", self.user_name)
@login_failed_count.setter @login_failed_count.setter
def login_failed_count(self, count): def login_failed_count(self, count):
frappe.cache().hset("login_failed_count", self.user_name, count) frappe.cache.hset("login_failed_count", self.user_name, count)
@login_failed_count.deleter @login_failed_count.deleter
def login_failed_count(self): def login_failed_count(self):
frappe.cache().hdel("login_failed_count", self.user_name) frappe.cache.hdel("login_failed_count", self.user_name)
@property @property
def login_failed_time(self): def login_failed_time(self):
@ -498,15 +498,15 @@ class LoginAttemptTracker:
For every user we track only First failed login attempt time within lock interval of time. For every user we track only First failed login attempt time within lock interval of time.
""" """
return frappe.cache().hget("login_failed_time", self.user_name) return frappe.cache.hget("login_failed_time", self.user_name)
@login_failed_time.setter @login_failed_time.setter
def login_failed_time(self, timestamp): def login_failed_time(self, timestamp):
frappe.cache().hset("login_failed_time", self.user_name, timestamp) frappe.cache.hset("login_failed_time", self.user_name, timestamp)
@login_failed_time.deleter @login_failed_time.deleter
def login_failed_time(self): def login_failed_time(self):
frappe.cache().hdel("login_failed_time", self.user_name) frappe.cache.hdel("login_failed_time", self.user_name)
def add_failure_attempt(self): def add_failure_attempt(self):
"""Log user failure attempts into the system. """Log user failure attempts into the system.

2
frappe/automation/doctype/milestone_tracker/test_milestone_tracker.py
View file

@ -9,7 +9,7 @@ class TestMilestoneTracker(FrappeTestCase):
def test_milestone(self): def test_milestone(self):
frappe.db.delete("Milestone Tracker") frappe.db.delete("Milestone Tracker")
frappe.cache().delete_key("milestone_tracker_map") frappe.cache.delete_key("milestone_tracker_map")
milestone_tracker = frappe.get_doc( milestone_tracker = frappe.get_doc(
dict(doctype="Milestone Tracker", document_type="ToDo", track_field="status") dict(doctype="Milestone Tracker", document_type="ToDo", track_field="status")

6
frappe/boot.py
View file

@ -149,10 +149,8 @@ def get_allowed_report_names(cache=False) -> set[str]:
def get_user_pages_or_reports(parent, cache=False): def get_user_pages_or_reports(parent, cache=False):
_cache = frappe.cache()
if cache: if cache:
has_role = _cache.get_value("has_role:" + parent, user=frappe.session.user) has_role = frappe.cache.get_value("has_role:" + parent, user=frappe.session.user)
if has_role: if has_role:
return has_role return has_role
@ -254,7 +252,7 @@ def get_user_pages_or_reports(parent, cache=False):
has_role.pop(r, None) has_role.pop(r, None)
# Expire every six hours # Expire every six hours
_cache.set_value("has_role:" + parent, has_role, frappe.session.user, 21600) frappe.cache.set_value("has_role:" + parent, has_role, frappe.session.user, 21600)
return has_role return has_role

42
frappe/cache_manager.py
View file

@ -79,28 +79,25 @@ doctype_cache_keys = (
def clear_user_cache(user=None): def clear_user_cache(user=None):
cache = frappe.cache()
# this will automatically reload the global cache # this will automatically reload the global cache
# so it is important to clear this first # so it is important to clear this first
clear_notifications(user) clear_notifications(user)
if user: if user:
for name in user_cache_keys: for name in user_cache_keys:
cache.hdel(name, user) frappe.cache.hdel(name, user)
cache.delete_keys("user:" + user) frappe.cache.delete_keys("user:" + user)
clear_defaults_cache(user) clear_defaults_cache(user)
else: else:
for name in user_cache_keys: for name in user_cache_keys:
cache.delete_key(name) frappe.cache.delete_key(name)
clear_defaults_cache() clear_defaults_cache()
clear_global_cache() clear_global_cache()
def clear_domain_cache(user=None): def clear_domain_cache(user=None):
cache = frappe.cache()
domain_cache_keys = ("domain_restricted_doctypes", "domain_restricted_pages") domain_cache_keys = ("domain_restricted_doctypes", "domain_restricted_pages")
cache.delete_value(domain_cache_keys) frappe.cache.delete_value(domain_cache_keys)
def clear_global_cache(): def clear_global_cache():
@ -108,17 +105,17 @@ def clear_global_cache():
clear_doctype_cache() clear_doctype_cache()
clear_website_cache() clear_website_cache()
frappe.cache().delete_value(global_cache_keys) frappe.cache.delete_value(global_cache_keys)
frappe.cache().delete_value(bench_cache_keys) frappe.cache.delete_value(bench_cache_keys)
frappe.setup_module_map() frappe.setup_module_map()
def clear_defaults_cache(user=None): def clear_defaults_cache(user=None):
if user: if user:
for p in [user] + common_default_keys: for p in [user] + common_default_keys:
frappe.cache().hdel("defaults", p) frappe.cache.hdel("defaults", p)
elif frappe.flags.in_install != "frappe": elif frappe.flags.in_install != "frappe":
frappe.cache().delete_key("defaults") frappe.cache.delete_key("defaults")
def clear_doctype_cache(doctype=None): def clear_doctype_cache(doctype=None):
@ -131,15 +128,13 @@ def clear_doctype_cache(doctype=None):
def _clear_doctype_cache_form_redis(doctype: str | None = None): def _clear_doctype_cache_form_redis(doctype: str | None = None):
cache = frappe.cache()
for key in ("is_table", "doctype_modules"): for key in ("is_table", "doctype_modules"):
cache.delete_value(key) frappe.cache.delete_value(key)
def clear_single(dt): def clear_single(dt):
frappe.clear_document_cache(dt) frappe.clear_document_cache(dt)
for name in doctype_cache_keys: for name in doctype_cache_keys:
cache.hdel(name, dt) frappe.cache.hdel(name, dt)
if doctype: if doctype:
clear_single(doctype) clear_single(doctype)
@ -163,8 +158,8 @@ def _clear_doctype_cache_form_redis(doctype: str | None = None):
else: else:
# clear all # clear all
for name in doctype_cache_keys: for name in doctype_cache_keys:
cache.delete_value(name) frappe.cache.delete_value(name)
cache.delete_keys("document_cache::") frappe.cache.delete_keys("document_cache::")
def clear_controller_cache(doctype=None): def clear_controller_cache(doctype=None):
@ -177,7 +172,7 @@ def clear_controller_cache(doctype=None):
def get_doctype_map(doctype, name, filters=None, order_by=None): def get_doctype_map(doctype, name, filters=None, order_by=None):
return frappe.cache().hget( return frappe.cache.hget(
get_doctype_map_key(doctype), get_doctype_map_key(doctype),
name, name,
lambda: frappe.get_all(doctype, filters=filters, order_by=order_by, ignore_ddl=True), lambda: frappe.get_all(doctype, filters=filters, order_by=order_by, ignore_ddl=True),
@ -185,7 +180,7 @@ def get_doctype_map(doctype, name, filters=None, order_by=None):
def clear_doctype_map(doctype, name): def clear_doctype_map(doctype, name):
frappe.cache().hdel(frappe.scrub(doctype) + "_map", name) frappe.cache.hdel(frappe.scrub(doctype) + "_map", name)
def build_table_count_cache(): def build_table_count_cache():
@ -198,7 +193,6 @@ def build_table_count_cache():
): ):
return return
_cache = frappe.cache()
table_name = frappe.qb.Field("table_name").as_("name") table_name = frappe.qb.Field("table_name").as_("name")
table_rows = frappe.qb.Field("table_rows").as_("count") table_rows = frappe.qb.Field("table_rows").as_("count")
information_schema = frappe.qb.Schema("information_schema") information_schema = frappe.qb.Schema("information_schema")
@ -207,7 +201,7 @@ def build_table_count_cache():
as_dict=True as_dict=True
) )
counts = {d.get("name").replace("tab", "", 1): d.get("count", None) for d in data} counts = {d.get("name").replace("tab", "", 1): d.get("count", None) for d in data}
_cache.set_value("information_schema:counts", counts) frappe.cache.set_value("information_schema:counts", counts)
return counts return counts
@ -221,11 +215,10 @@ def build_domain_restriced_doctype_cache(*args, **kwargs):
or frappe.flags.in_setup_wizard or frappe.flags.in_setup_wizard
): ):
return return
_cache = frappe.cache()
active_domains = frappe.get_active_domains() active_domains = frappe.get_active_domains()
doctypes = frappe.get_all("DocType", filters={"restrict_to_domain": ("IN", active_domains)}) doctypes = frappe.get_all("DocType", filters={"restrict_to_domain": ("IN", active_domains)})
doctypes = [doc.name for doc in doctypes] doctypes = [doc.name for doc in doctypes]
_cache.set_value("domain_restricted_doctypes", doctypes) frappe.cache.set_value("domain_restricted_doctypes", doctypes)
return doctypes return doctypes
@ -239,10 +232,9 @@ def build_domain_restriced_page_cache(*args, **kwargs):
or frappe.flags.in_setup_wizard or frappe.flags.in_setup_wizard
): ):
return return
_cache = frappe.cache()
active_domains = frappe.get_active_domains() active_domains = frappe.get_active_domains()
pages = frappe.get_all("Page", filters={"restrict_to_domain": ("IN", active_domains)}) pages = frappe.get_all("Page", filters={"restrict_to_domain": ("IN", active_domains)})
pages = [page.name for page in pages] pages = [page.name for page in pages]
_cache.set_value("domain_restricted_pages", pages) frappe.cache.set_value("domain_restricted_pages", pages)
return pages return pages

4
frappe/core/doctype/data_import/importer.py
View file

@ -62,7 +62,7 @@ class Importer:
def before_import(self): def before_import(self):
# set user lang for translations # set user lang for translations
frappe.cache().hdel("lang", frappe.session.user) frappe.cache.hdel("lang", frappe.session.user)
frappe.set_user_lang(frappe.session.user) frappe.set_user_lang(frappe.session.user)
# set flags # set flags
@ -1207,7 +1207,7 @@ def get_df_for_column_header(doctype, header):
def build_fields_dict_for_doctype(): def build_fields_dict_for_doctype():
return build_fields_dict_for_column_matching(doctype) return build_fields_dict_for_column_matching(doctype)
df_by_labels_and_fieldname = frappe.cache().hget( df_by_labels_and_fieldname = frappe.cache.hget(
"data_import_column_header_map", doctype, generator=build_fields_dict_for_doctype "data_import_column_header_map", doctype, generator=build_fields_dict_for_doctype
) )
return df_by_labels_and_fieldname.get(header) return df_by_labels_and_fieldname.get(header)

2
frappe/core/doctype/doctype/doctype.py
View file

@ -1710,7 +1710,7 @@ def check_fieldname_conflicts(docfield):
def clear_linked_doctype_cache(): def clear_linked_doctype_cache():
frappe.cache().delete_value("linked_doctypes_without_ignore_user_permissions_enabled") frappe.cache.delete_value("linked_doctypes_without_ignore_user_permissions_enabled")
def check_email_append_to(doc): def check_email_append_to(doc):

4
frappe/core/doctype/domain_settings/domain_settings.py
View file

@ -73,7 +73,7 @@ def get_active_domains():
active_domains.append("") active_domains.append("")
return active_domains return active_domains
return frappe.cache().get_value("active_domains", _get_active_domains) return frappe.cache.get_value("active_domains", _get_active_domains)
def get_active_modules(): def get_active_modules():
@ -87,4 +87,4 @@ def get_active_modules():
active_modules.append(m.name) active_modules.append(m.name)
return active_modules return active_modules
return frappe.cache().get_value("active_modules", _get_active_modules) return frappe.cache.get_value("active_modules", _get_active_modules)

2
frappe/core/doctype/report/report.py
View file

@ -137,7 +137,7 @@ class Report(Document):
if execution_time > threshold and not self.prepared_report: if execution_time > threshold and not self.prepared_report:
self.db_set("prepared_report", 1) self.db_set("prepared_report", 1)
frappe.cache().hset("report_execution_time", self.name, execution_time) frappe.cache.hset("report_execution_time", self.name, execution_time)
return res return res

2
frappe/core/doctype/role/role.py
View file

@ -24,7 +24,7 @@ class Role(Document):
frappe.throw(frappe._("Standard roles cannot be renamed")) frappe.throw(frappe._("Standard roles cannot be renamed"))
def after_insert(self): def after_insert(self):
frappe.cache().hdel("roles", "Administrator") frappe.cache.hdel("roles", "Administrator")
def validate(self): def validate(self):
if self.disabled: if self.disabled:

6
frappe/core/doctype/server_script/server_script.py
View file

@ -19,7 +19,7 @@ class ServerScript(Document):
self.check_if_compilable_in_restricted_context() self.check_if_compilable_in_restricted_context()
def on_update(self): def on_update(self):
frappe.cache().delete_value("server_script_map") frappe.cache.delete_value("server_script_map")
self.sync_scheduler_events() self.sync_scheduler_events()
def on_trash(self): def on_trash(self):
@ -168,11 +168,11 @@ class ServerScript(Document):
out.append([key, score]) out.append([key, score])
return out return out
items = frappe.cache().get_value("server_script_autocompletion_items") items = frappe.cache.get_value("server_script_autocompletion_items")
if not items: if not items:
items = get_keys(get_safe_globals()) items = get_keys(get_safe_globals())
items = [{"value": d[0], "score": d[1]} for d in items] items = [{"value": d[0], "score": d[1]} for d in items]
frappe.cache().set_value("server_script_autocompletion_items", items) frappe.cache.set_value("server_script_autocompletion_items", items)
return items return items

4
frappe/core/doctype/server_script/server_script_utils.py
View file

@ -55,7 +55,7 @@ def get_server_script_map():
if frappe.flags.in_patch and not frappe.db.table_exists("Server Script"): if frappe.flags.in_patch and not frappe.db.table_exists("Server Script"):
return {} return {}
script_map = frappe.cache().get_value("server_script_map") script_map = frappe.cache.get_value("server_script_map")
if script_map is None: if script_map is None:
script_map = {"permission_query": {}} script_map = {"permission_query": {}}
enabled_server_scripts = frappe.get_all( enabled_server_scripts = frappe.get_all(
@ -73,6 +73,6 @@ def get_server_script_map():
else: else:
script_map.setdefault("_api", {})[script.api_method] = script.name script_map.setdefault("_api", {})[script.api_method] = script.name
frappe.cache().set_value("server_script_map", script_map) frappe.cache.set_value("server_script_map", script_map)
return script_map return script_map

4
frappe/core/doctype/server_script/test_server_script.py
View file

@ -104,10 +104,10 @@ class TestServerScript(FrappeTestCase):
def tearDownClass(cls): def tearDownClass(cls):
frappe.db.commit() frappe.db.commit()
frappe.db.truncate("Server Script") frappe.db.truncate("Server Script")
frappe.cache().delete_value("server_script_map") frappe.cache.delete_value("server_script_map")
def setUp(self): def setUp(self):
frappe.cache().delete_value("server_script_map") frappe.cache.delete_value("server_script_map")
def test_doctype_event(self): def test_doctype_event(self):
todo = frappe.get_doc(dict(doctype="ToDo", description="hello")).insert() todo = frappe.get_doc(dict(doctype="ToDo", description="hello")).insert()

4
frappe/core/doctype/system_settings/system_settings.py
View file

@ -64,8 +64,8 @@ class SystemSettings(Document):
def on_update(self): def on_update(self):
self.set_defaults() self.set_defaults()
frappe.cache().delete_value("system_settings") frappe.cache.delete_value("system_settings")
frappe.cache().delete_value("time_zone") frappe.cache.delete_value("time_zone")
if frappe.flags.update_last_reset_password_date: if frappe.flags.update_last_reset_password_date:
update_last_reset_password_date() update_last_reset_password_date()

4
frappe/core/doctype/translation/translation.py
View file

@ -89,5 +89,5 @@ def create_translations(translation_map, language):
def clear_user_translation_cache(lang): def clear_user_translation_cache(lang):
frappe.cache().hdel(USER_TRANSLATION_KEY, lang) frappe.cache.hdel(USER_TRANSLATION_KEY, lang)
frappe.cache().hdel(MERGED_TRANSLATION_KEY, lang) frappe.cache.hdel(MERGED_TRANSLATION_KEY, lang)

4
frappe/core/doctype/user/test_user.py
View file

@ -283,7 +283,7 @@ class TestUser(FrappeTestCase):
# Clear rate limit tracker to start fresh # Clear rate limit tracker to start fresh
key = f"rl:{data['cmd']}:{data['user']}" key = f"rl:{data['cmd']}:{data['user']}"
frappe.cache().delete(key) frappe.cache.delete(key)
c = FrappeClient(url) c = FrappeClient(url)
res1 = c.session.post(url, data=data, verify=c.verify, headers=c.headers) res1 = c.session.post(url, data=data, verify=c.verify, headers=c.headers)
@ -330,7 +330,7 @@ class TestUser(FrappeTestCase):
sign_up(random_user, random_user_name, "/welcome"), sign_up(random_user, random_user_name, "/welcome"),
(1, "Please check your email for verification"), (1, "Please check your email for verification"),
) )
self.assertEqual(frappe.cache().hget("redirect_after_login", random_user), "/welcome") self.assertEqual(frappe.cache.hget("redirect_after_login", random_user), "/welcome")
# re-register # re-register
self.assertTupleEqual( self.assertTupleEqual(

22
frappe/core/doctype/user/user.py
View file

@ -60,8 +60,8 @@ class User(Document):
def after_insert(self): def after_insert(self):
create_notification_settings(self.name) create_notification_settings(self.name)
frappe.cache().delete_key("users_for_mentions") frappe.cache.delete_key("users_for_mentions")
frappe.cache().delete_key("enabled_users") frappe.cache.delete_key("enabled_users")
def validate(self): def validate(self):
# clear new password # clear new password
@ -143,10 +143,10 @@ class User(Document):
frappe.defaults.set_default("time_zone", self.time_zone, self.name) frappe.defaults.set_default("time_zone", self.time_zone, self.name)
if self.has_value_changed("enabled"): if self.has_value_changed("enabled"):
frappe.cache().delete_key("users_for_mentions") frappe.cache.delete_key("users_for_mentions")
frappe.cache().delete_key("enabled_users") frappe.cache.delete_key("enabled_users")
elif self.has_value_changed("allow_in_mentions") or self.has_value_changed("user_type"): elif self.has_value_changed("allow_in_mentions") or self.has_value_changed("user_type"):
frappe.cache().delete_key("users_for_mentions") frappe.cache.delete_key("users_for_mentions")
def has_website_permission(self, ptype, user, verbose=False): def has_website_permission(self, ptype, user, verbose=False):
"""Returns true if current user is the session user""" """Returns true if current user is the session user"""
@ -462,9 +462,9 @@ class User(Document):
frappe.delete_doc("Notification Settings", self.name, ignore_permissions=True) frappe.delete_doc("Notification Settings", self.name, ignore_permissions=True)
if self.get("allow_in_mentions"): if self.get("allow_in_mentions"):
frappe.cache().delete_key("users_for_mentions") frappe.cache.delete_key("users_for_mentions")
frappe.cache().delete_key("enabled_users") frappe.cache.delete_key("enabled_users")
# delete user permissions # delete user permissions
frappe.db.delete("User Permission", {"user": self.name}) frappe.db.delete("User Permission", {"user": self.name})
@ -760,10 +760,10 @@ def update_password(
user_doc, redirect_url = reset_user_data(user) user_doc, redirect_url = reset_user_data(user)
# get redirect url from cache # get redirect url from cache
redirect_to = frappe.cache().hget("redirect_after_login", user) redirect_to = frappe.cache.hget("redirect_after_login", user)
if redirect_to: if redirect_to:
redirect_url = redirect_to redirect_url = redirect_to
frappe.cache().hdel("redirect_after_login", user) frappe.cache.hdel("redirect_after_login", user)
frappe.local.login_manager.login_as(user) frappe.local.login_manager.login_as(user)
@ -921,7 +921,7 @@ def sign_up(email: str, full_name: str, redirect_to: str) -> tuple[int, str]:
user.add_roles(default_role) user.add_roles(default_role)
if redirect_to: if redirect_to:
frappe.cache().hset("redirect_after_login", user.name, redirect_to) frappe.cache.hset("redirect_after_login", user.name, redirect_to)
if user.flags.email_sent: if user.flags.email_sent:
return 1, _("Please check your email for verification") return 1, _("Please check your email for verification")
@ -1234,4 +1234,4 @@ def get_enabled_users():
enabled_users = frappe.get_all("User", filters={"enabled": "1"}, pluck="name") enabled_users = frappe.get_all("User", filters={"enabled": "1"}, pluck="name")
return enabled_users return enabled_users
return frappe.cache().get_value("enabled_users", _get_enabled_users) return frappe.cache.get_value("enabled_users", _get_enabled_users)

4
frappe/core/doctype/user_group/user_group.py
View file

@ -9,7 +9,7 @@ from frappe.model.document import Document
class UserGroup(Document): class UserGroup(Document):
def after_insert(self): def after_insert(self):
frappe.cache().delete_key("user_groups") frappe.cache.delete_key("user_groups")
def on_trash(self): def on_trash(self):
frappe.cache().delete_key("user_groups") frappe.cache.delete_key("user_groups")

2
frappe/core/doctype/user_permission/test_user_permission.py
View file

@ -178,7 +178,7 @@ class TestUserPermission(FrappeTestCase):
frappe.db.set_value( frappe.db.set_value(
"User Permission", {"allow": "Person", "for_value": parent_record.name}, "hide_descendants", 1 "User Permission", {"allow": "Person", "for_value": parent_record.name}, "hide_descendants", 1
) )
frappe.cache().delete_value("user_permissions") frappe.cache.delete_value("user_permissions")
# check if adding perm on a group record with hide_descendants enabled, # check if adding perm on a group record with hide_descendants enabled,
# hides child records # hides child records

8
frappe/core/doctype/user_permission/user_permission.py
View file

@ -17,11 +17,11 @@ class UserPermission(Document):
self.validate_default_permission() self.validate_default_permission()
def on_update(self): def on_update(self):
frappe.cache().hdel("user_permissions", self.user) frappe.cache.hdel("user_permissions", self.user)
frappe.publish_realtime("update_user_permissions", user=self.user, after_commit=True) frappe.publish_realtime("update_user_permissions", user=self.user, after_commit=True)
def on_trash(self): def on_trash(self):
frappe.cache().hdel("user_permissions", self.user) frappe.cache.hdel("user_permissions", self.user)
frappe.publish_realtime("update_user_permissions", user=self.user, after_commit=True) frappe.publish_realtime("update_user_permissions", user=self.user, after_commit=True)
def validate_user_permission(self): def validate_user_permission(self):
@ -74,7 +74,7 @@ def get_user_permissions(user=None):
if not user or user in ("Administrator", "Guest"): if not user or user in ("Administrator", "Guest"):
return {} return {}
cached_user_permissions = frappe.cache().hget("user_permissions", user) cached_user_permissions = frappe.cache.hget("user_permissions", user)
if cached_user_permissions is not None: if cached_user_permissions is not None:
return cached_user_permissions return cached_user_permissions
@ -110,7 +110,7 @@ def get_user_permissions(user=None):
add_doc_to_perm(perm, doc, False) add_doc_to_perm(perm, doc, False)
out = frappe._dict(out) out = frappe._dict(out)
frappe.cache().hset("user_permissions", user, out) frappe.cache.hset("user_permissions", user, out)
except frappe.db.SQLError as e: except frappe.db.SQLError as e:
if frappe.db.is_table_missing(e): if frappe.db.is_table_missing(e):
# called from patch # called from patch

4
frappe/core/doctype/user_type/user_type.py
View file

@ -18,7 +18,7 @@ class UserType(Document):
super().clear_cache() super().clear_cache()
if not self.is_standard: if not self.is_standard:
frappe.cache().delete_value("non_standard_user_types") frappe.cache.delete_value("non_standard_user_types")
def on_update(self): def on_update(self):
if self.is_standard: if self.is_standard:
@ -290,7 +290,7 @@ def apply_permissions_for_non_standard_user_type(doc, method=None):
if not frappe.db.table_exists("User Type") or frappe.flags.in_migrate: if not frappe.db.table_exists("User Type") or frappe.flags.in_migrate:
return return
user_types = frappe.cache().get_value( user_types = frappe.cache.get_value(
"non_standard_user_types", "non_standard_user_types",
get_non_standard_user_types, get_non_standard_user_types,
) )

12
frappe/database/database.py
View file

@ -302,7 +302,7 @@ class Database:
"""Takes the query and logs it to various interfaces according to the settings.""" """Takes the query and logs it to various interfaces according to the settings."""
_query = None _query = None
if frappe.conf.allow_tests and frappe.cache().get_value("flag_print_sql"): if frappe.conf.allow_tests and frappe.cache.get_value("flag_print_sql"):
_query = _query or str(mogrified_query) _query = _query or str(mogrified_query)
print(_query) print(_query)
@ -419,7 +419,7 @@ class Database:
@staticmethod @staticmethod
def clear_db_table_cache(query): def clear_db_table_cache(query):
if query and is_query_type(query, ("drop", "create")): if query and is_query_type(query, ("drop", "create")):
frappe.cache().delete_key("db_tables") frappe.cache.delete_key("db_tables")
def get_description(self): def get_description(self):
"""Returns result metadata.""" """Returns result metadata."""
@ -1067,7 +1067,7 @@ class Database:
def count(self, dt, filters=None, debug=False, cache=False, distinct: bool = True): def count(self, dt, filters=None, debug=False, cache=False, distinct: bool = True):
"""Returns `COUNT(*)` for given DocType and filters.""" """Returns `COUNT(*)` for given DocType and filters."""
if cache and not filters: if cache and not filters:
cache_count = frappe.cache().get_value(f"doctype:count:{dt}") cache_count = frappe.cache.get_value(f"doctype:count:{dt}")
if cache_count is not None: if cache_count is not None:
return cache_count return cache_count
count = frappe.qb.get_query( count = frappe.qb.get_query(
@ -1078,7 +1078,7 @@ class Database:
validate_filters=True, validate_filters=True,
).run(debug=debug)[0][0] ).run(debug=debug)[0][0]
if not filters and cache: if not filters and cache:
frappe.cache().set_value(f"doctype:count:{dt}", count, expires_in_sec=86400) frappe.cache.set_value(f"doctype:count:{dt}", count, expires_in_sec=86400)
return count return count
@staticmethod @staticmethod
@ -1109,7 +1109,7 @@ class Database:
def get_db_table_columns(self, table) -> list[str]: def get_db_table_columns(self, table) -> list[str]:
"""Returns list of column names from given table.""" """Returns list of column names from given table."""
columns = frappe.cache().hget("table_columns", table) columns = frappe.cache.hget("table_columns", table)
if columns is None: if columns is None:
information_schema = frappe.qb.Schema("information_schema") information_schema = frappe.qb.Schema("information_schema")
@ -1121,7 +1121,7 @@ class Database:
) )
if columns: if columns:
frappe.cache().hset("table_columns", table, columns) frappe.cache.hset("table_columns", table, columns)
return columns return columns

4
frappe/database/mariadb/database.py
View file

@ -435,7 +435,7 @@ class MariaDBDatabase(MariaDBConnectionUtil, MariaDBExceptionUtil, Database):
to_query = not cached to_query = not cached
if cached: if cached:
tables = frappe.cache().get_value("db_tables") tables = frappe.cache.get_value("db_tables")
to_query = not tables to_query = not tables
if to_query: if to_query:
@ -447,7 +447,7 @@ class MariaDBDatabase(MariaDBConnectionUtil, MariaDBExceptionUtil, Database):
.where(information_schema.tables.table_schema != "information_schema") .where(information_schema.tables.table_schema != "information_schema")
.run(pluck=True) .run(pluck=True)
) )
frappe.cache().set_value("db_tables", tables) frappe.cache.set_value("db_tables", tables)
return tables return tables

2
frappe/database/schema.py
View file

@ -40,7 +40,7 @@ class DBTable:
if self.is_new(): if self.is_new():
self.create() self.create()
else: else:
frappe.cache().hdel("table_columns", self.table_name) frappe.cache.hdel("table_columns", self.table_name)
self.alter() self.alter()
def create(self): def create(self):

4
frappe/defaults.py
View file

@ -230,7 +230,7 @@ def clear_default(key=None, value=None, parent=None, name=None, parenttype=None)
def get_defaults_for(parent="__default"): def get_defaults_for(parent="__default"):
"""get all defaults""" """get all defaults"""
defaults = frappe.cache().hget("defaults", parent) defaults = frappe.cache.hget("defaults", parent)
if defaults is None: if defaults is None:
# sort descending because first default must get precedence # sort descending because first default must get precedence
@ -256,7 +256,7 @@ def get_defaults_for(parent="__default"):
elif d.defvalue is not None: elif d.defvalue is not None:
defaults[d.defkey] = d.defvalue defaults[d.defkey] = d.defvalue
frappe.cache().hset("defaults", parent, defaults) frappe.cache.hset("defaults", parent, defaults)
return defaults return defaults

8
frappe/deferred_insert.py
View file

@ -19,20 +19,20 @@ def deferred_insert(doctype: str, records: list[Union[dict, "Document"]] | str):
_records = records _records = records
try: try:
frappe.cache().rpush(f"{queue_prefix}{doctype}", _records) frappe.cache.rpush(f"{queue_prefix}{doctype}", _records)
except redis.exceptions.ConnectionError: except redis.exceptions.ConnectionError:
for record in records: for record in records:
insert_record(record, doctype) insert_record(record, doctype)
def save_to_db(): def save_to_db():
queue_keys = frappe.cache().get_keys(queue_prefix) queue_keys = frappe.cache.get_keys(queue_prefix)
for key in queue_keys: for key in queue_keys:
record_count = 0 record_count = 0
queue_key = get_key_name(key) queue_key = get_key_name(key)
doctype = get_doctype_name(key) doctype = get_doctype_name(key)
while frappe.cache().llen(queue_key) > 0 and record_count <= 500: while frappe.cache.llen(queue_key) > 0 and record_count <= 500:
records = frappe.cache().lpop(queue_key) records = frappe.cache.lpop(queue_key)
records = json.loads(records.decode("utf-8")) records = json.loads(records.decode("utf-8"))
if isinstance(records, dict): if isinstance(records, dict):
record_count += 1 record_count += 1

12
frappe/desk/desktop.py
View file

@ -62,10 +62,10 @@ class Workspace:
self.table_counts = get_table_with_counts() self.table_counts = get_table_with_counts()
self.restricted_doctypes = ( self.restricted_doctypes = (
frappe.cache().get_value("domain_restricted_doctypes") or build_domain_restriced_doctype_cache() frappe.cache.get_value("domain_restricted_doctypes") or build_domain_restriced_doctype_cache()
) )
self.restricted_pages = ( self.restricted_pages = (
frappe.cache().get_value("domain_restricted_pages") or build_domain_restriced_page_cache() frappe.cache.get_value("domain_restricted_pages") or build_domain_restriced_page_cache()
) )
def is_permitted(self): def is_permitted(self):
@ -88,16 +88,14 @@ class Workspace:
return True return True
def get_cached(self, cache_key, fallback_fn): def get_cached(self, cache_key, fallback_fn):
_cache = frappe.cache() value = frappe.cache.get_value(cache_key, user=frappe.session.user)
value = _cache.get_value(cache_key, user=frappe.session.user)
if value: if value:
return value return value
value = fallback_fn() value = fallback_fn()
# Expire every six hour # Expire every six hour
_cache.set_value(cache_key, value, frappe.session.user, 21600) frappe.cache.set_value(cache_key, value, frappe.session.user, 21600)
return value return value
def get_can_read_items(self): def get_can_read_items(self):
@ -469,7 +467,7 @@ def get_workspace_sidebar_items():
def get_table_with_counts(): def get_table_with_counts():
counts = frappe.cache().get_value("information_schema:counts") counts = frappe.cache.get_value("information_schema:counts")
if not counts: if not counts:
counts = build_table_count_cache() counts = build_table_count_cache()

2
frappe/desk/doctype/dashboard_chart/dashboard_chart.py
View file

@ -340,7 +340,7 @@ def get_charts_for_user(doctype, txt, searchfield, start, page_len, filters):
class DashboardChart(Document): class DashboardChart(Document):
def on_update(self): def on_update(self):
frappe.cache().delete_key(f"chart-data:{self.name}") frappe.cache.delete_key(f"chart-data:{self.name}")
if frappe.conf.developer_mode and self.is_standard: if frappe.conf.developer_mode and self.is_standard:
export_to_files(record_list=[["Dashboard Chart", self.name]], record_module=self.module) export_to_files(record_list=[["Dashboard Chart", self.name]], record_module=self.module)

10
frappe/desk/doctype/desktop_icon/desktop_icon.py
View file

@ -28,7 +28,7 @@ def get_desktop_icons(user=None):
if not user: if not user:
user = frappe.session.user user = frappe.session.user
user_icons = frappe.cache().hget("desktop_icons", user) user_icons = frappe.cache.hget("desktop_icons", user)
if not user_icons: if not user_icons:
fields = [ fields = [
@ -120,7 +120,7 @@ def get_desktop_icons(user=None):
if d.label: if d.label:
d.label = _(d.label) d.label = _(d.label)
frappe.cache().hset("desktop_icons", user, user_icons) frappe.cache.hset("desktop_icons", user, user_icons)
return user_icons return user_icons
@ -313,8 +313,8 @@ def get_all_icons():
def clear_desktop_icons_cache(user=None): def clear_desktop_icons_cache(user=None):
frappe.cache().hdel("desktop_icons", user or frappe.session.user) frappe.cache.hdel("desktop_icons", user or frappe.session.user)
frappe.cache().hdel("bootinfo", user or frappe.session.user) frappe.cache.hdel("bootinfo", user or frappe.session.user)
def get_user_copy(module_name, user=None): def get_user_copy(module_name, user=None):
@ -445,7 +445,7 @@ def get_module_icons(user=None):
if not user: if not user:
icons = frappe.get_all("Desktop Icon", fields="*", filters={"standard": 1}, order_by="idx") icons = frappe.get_all("Desktop Icon", fields="*", filters={"standard": 1}, order_by="idx")
else: else:
frappe.cache().hdel("desktop_icons", user) frappe.cache.hdel("desktop_icons", user)
icons = get_user_icons(user) icons = get_user_icons(user)
for icon in icons: for icon in icons:

8
frappe/desk/doctype/form_tour/form_tour.py
View file

@ -34,13 +34,13 @@ class FormTour(Document):
step.fieldtype = field_df.fieldtype step.fieldtype = field_df.fieldtype
def on_update(self): def on_update(self):
frappe.cache().delete_key("bootinfo") frappe.cache.delete_key("bootinfo")
if frappe.conf.developer_mode and self.is_standard: if frappe.conf.developer_mode and self.is_standard:
export_to_files([["Form Tour", self.name]], self.module) export_to_files([["Form Tour", self.name]], self.module)
def on_trash(self): def on_trash(self):
frappe.cache().delete_key("bootinfo") frappe.cache.delete_key("bootinfo")
@frappe.whitelist() @frappe.whitelist()
@ -51,7 +51,7 @@ def reset_tour(tour_name):
frappe.db.set_value( frappe.db.set_value(
"User", user, "onboarding_status", frappe.as_json(onboarding_status), update_modified=False "User", user, "onboarding_status", frappe.as_json(onboarding_status), update_modified=False
) )
frappe.cache().hdel("bootinfo", user) frappe.cache.hdel("bootinfo", user)
frappe.msgprint(_("Successfully reset onboarding status for all users."), alert=True) frappe.msgprint(_("Successfully reset onboarding status for all users."), alert=True)
@ -72,7 +72,7 @@ def update_user_status(value, step):
"User", frappe.session.user, "onboarding_status", value, update_modified=False "User", frappe.session.user, "onboarding_status", value, update_modified=False
) )
frappe.cache().hdel("bootinfo", frappe.session.user) frappe.cache.hdel("bootinfo", frappe.session.user)
def get_onboarding_ui_tours(): def get_onboarding_ui_tours():

4
frappe/desk/doctype/global_search_settings/global_search_settings.py
View file

@ -28,7 +28,7 @@ class GlobalSearchSettings(Document):
frappe.throw(_("Document Type {0} has been repeated.").format(repeated_dts)) frappe.throw(_("Document Type {0} has been repeated.").format(repeated_dts))
# reset cache # reset cache
frappe.cache().hdel("global_search", "search_priorities") frappe.cache.hdel("global_search", "search_priorities")
def get_doctypes_for_global_search(): def get_doctypes_for_global_search():
@ -36,7 +36,7 @@ def get_doctypes_for_global_search():
doctypes = frappe.get_all("Global Search DocType", fields=["document_type"], order_by="idx ASC") doctypes = frappe.get_all("Global Search DocType", fields=["document_type"], order_by="idx ASC")
return [d.document_type for d in doctypes] or [] return [d.document_type for d in doctypes] or []
return frappe.cache().hget("global_search", "search_priorities", get_from_db) return frappe.cache.hget("global_search", "search_priorities", get_from_db)
@frappe.whitelist() @frappe.whitelist()

2
frappe/desk/doctype/kanban_board/kanban_board.py
View file

@ -14,7 +14,7 @@ class KanbanBoard(Document):
def on_change(self): def on_change(self):
frappe.clear_cache(doctype=self.reference_doctype) frappe.clear_cache(doctype=self.reference_doctype)
frappe.cache().delete_keys("_user_settings") frappe.cache.delete_keys("_user_settings")
def before_insert(self): def before_insert(self):
for column in self.columns: for column in self.columns:

4
frappe/desk/form/linked_with.py
View file

@ -531,13 +531,13 @@ def get_linked_doctypes(doctype, without_ignore_user_permissions_enabled=False):
{"Address": {"fieldname": "customer"}..} {"Address": {"fieldname": "customer"}..}
""" """
if without_ignore_user_permissions_enabled: if without_ignore_user_permissions_enabled:
return frappe.cache().hget( return frappe.cache.hget(
"linked_doctypes_without_ignore_user_permissions_enabled", "linked_doctypes_without_ignore_user_permissions_enabled",
doctype, doctype,
lambda: _get_linked_doctypes(doctype, without_ignore_user_permissions_enabled), lambda: _get_linked_doctypes(doctype, without_ignore_user_permissions_enabled),
) )
else: else:
return frappe.cache().hget("linked_doctypes", doctype, lambda: _get_linked_doctypes(doctype)) return frappe.cache.hget("linked_doctypes", doctype, lambda: _get_linked_doctypes(doctype))
def _get_linked_doctypes(doctype, without_ignore_user_permissions_enabled=False): def _get_linked_doctypes(doctype, without_ignore_user_permissions_enabled=False):

4
frappe/desk/form/meta.py
View file

@ -37,10 +37,10 @@ ASSET_KEYS = (
def get_meta(doctype, cached=True): def get_meta(doctype, cached=True):
# don't cache for developer mode as js files, templates may be edited # don't cache for developer mode as js files, templates may be edited
if cached and not frappe.conf.developer_mode: if cached and not frappe.conf.developer_mode:
meta = frappe.cache().hget("doctype_form_meta", doctype) meta = frappe.cache.hget("doctype_form_meta", doctype)
if not meta: if not meta:
meta = FormMeta(doctype) meta = FormMeta(doctype)
frappe.cache().hset("doctype_form_meta", doctype, meta) frappe.cache.hset("doctype_form_meta", doctype, meta)
else: else:
meta = FormMeta(doctype) meta = FormMeta(doctype)

16
frappe/desk/notifications.py
View file

@ -34,13 +34,12 @@ def get_notifications():
return out return out
groups = list(config.get("for_doctype")) + list(config.get("for_module")) groups = list(config.get("for_doctype")) + list(config.get("for_module"))
cache = frappe.cache()
notification_count = {} notification_count = {}
notification_percent = {} notification_percent = {}
for name in groups: for name in groups:
count = cache.hget("notification_count:" + name, frappe.session.user) count = frappe.cache.hget("notification_count:" + name, frappe.session.user)
if count is not None: if count is not None:
notification_count[name] = count notification_count[name] = count
@ -83,7 +82,7 @@ def get_notifications_for_doctypes(config, notification_count):
else: else:
open_count_doctype[d] = result open_count_doctype[d] = result
frappe.cache().hset("notification_count:" + d, frappe.session.user, result) frappe.cache.hset("notification_count:" + d, frappe.session.user, result)
return open_count_doctype return open_count_doctype
@ -139,7 +138,6 @@ def get_notifications_for_targets(config, notification_percent):
def clear_notifications(user=None): def clear_notifications(user=None):
if frappe.flags.in_install: if frappe.flags.in_install:
return return
cache = frappe.cache()
config = get_notification_config() config = get_notification_config()
if not config: if not config:
@ -151,17 +149,17 @@ def clear_notifications(user=None):
for name in groups: for name in groups:
if user: if user:
cache.hdel("notification_count:" + name, user) frappe.cache.hdel("notification_count:" + name, user)
else: else:
cache.delete_key("notification_count:" + name) frappe.cache.delete_key("notification_count:" + name)
def clear_notification_config(user): def clear_notification_config(user):
frappe.cache().hdel("notification_config", user) frappe.cache.hdel("notification_config", user)
def delete_notification_count_for(doctype): def delete_notification_count_for(doctype):
frappe.cache().delete_key("notification_count:" + doctype) frappe.cache.delete_key("notification_count:" + doctype)
def clear_doctype_notifications(doc, method=None, *args, **kwargs): def clear_doctype_notifications(doc, method=None, *args, **kwargs):
@ -230,7 +228,7 @@ def get_notification_config():
config[key].update(nc.get(key, {})) config[key].update(nc.get(key, {}))
return config return config
return frappe.cache().hget("notification_config", user, _get) return frappe.cache.hget("notification_config", user, _get)
def get_filters_for(doctype): def get_filters_for(doctype):

4
frappe/desk/page/setup_wizard/setup_wizard.py
View file

@ -325,8 +325,8 @@ def load_country():
@frappe.whitelist() @frappe.whitelist()
def load_user_details(): def load_user_details():
return { return {
"full_name": frappe.cache().hget("full_name", "signup"), "full_name": frappe.cache.hget("full_name", "signup"),
"email": frappe.cache().hget("email", "signup"), "email": frappe.cache.hget("email", "signup"),
} }

4
frappe/desk/query_report.py
View file

@ -119,7 +119,7 @@ def generate_report_result(
"report_summary": report_summary, "report_summary": report_summary,
"skip_total_row": skip_total_row or 0, "skip_total_row": skip_total_row or 0,
"status": None, "status": None,
"execution_time": frappe.cache().hget("report_execution_time", report.name) or 0, "execution_time": frappe.cache.hget("report_execution_time", report.name) or 0,
} }
@ -170,7 +170,7 @@ def get_script(report_name):
return { return {
"script": render_include(script), "script": render_include(script),
"html_format": html_format, "html_format": html_format,
"execution_time": frappe.cache().hget("report_execution_time", report_name) or 0, "execution_time": frappe.cache.hget("report_execution_time", report_name) or 0,
} }

4
frappe/desk/search.py
View file

@ -311,8 +311,8 @@ def validate_and_sanitize_search_inputs(fn):
@frappe.whitelist() @frappe.whitelist()
def get_names_for_mentions(search_term): def get_names_for_mentions(search_term):
users_for_mentions = frappe.cache().get_value("users_for_mentions", get_users_for_mentions) users_for_mentions = frappe.cache.get_value("users_for_mentions", get_users_for_mentions)
user_groups = frappe.cache().get_value("user_groups", get_user_groups) user_groups = frappe.cache.get_value("user_groups", get_user_groups)
filtered_mentions = [] filtered_mentions = []
for mention_data in users_for_mentions + user_groups: for mention_data in users_for_mentions + user_groups:

6
frappe/email/__init__.py
View file

@ -96,7 +96,7 @@ def get_communication_doctype(doctype, txt, searchfield, start, page_len, filter
def get_cached_contacts(txt): def get_cached_contacts(txt):
contacts = frappe.cache().hget("contacts", frappe.session.user) or [] contacts = frappe.cache.hget("contacts", frappe.session.user) or []
if not contacts: if not contacts:
return return
@ -113,9 +113,9 @@ def get_cached_contacts(txt):
def update_contact_cache(contacts): def update_contact_cache(contacts):
cached_contacts = frappe.cache().hget("contacts", frappe.session.user) or [] cached_contacts = frappe.cache.hget("contacts", frappe.session.user) or []
uncached_contacts = [d for d in contacts if d not in cached_contacts] uncached_contacts = [d for d in contacts if d not in cached_contacts]
cached_contacts.extend(uncached_contacts) cached_contacts.extend(uncached_contacts)
frappe.cache().hset("contacts", frappe.session.user, cached_contacts) frappe.cache.hset("contacts", frappe.session.user, cached_contacts)

14
frappe/email/doctype/email_account/email_account.py
View file

@ -176,7 +176,7 @@ class EmailAccount(Document):
def get_incoming_server(self, in_receive=False, email_sync_rule="UNSEEN"): def get_incoming_server(self, in_receive=False, email_sync_rule="UNSEEN"):
"""Returns logged in POP3/IMAP connection object.""" """Returns logged in POP3/IMAP connection object."""
if frappe.cache().get_value("workers:no-internet") == True: if frappe.cache.get_value("workers:no-internet") == True:
return None return None
oauth_token = self.get_oauth_token() oauth_token = self.get_oauth_token()
@ -253,7 +253,7 @@ class EmailAccount(Document):
if self.no_failed > 2: if self.no_failed > 2:
self.handle_incoming_connect_error(description=description) self.handle_incoming_connect_error(description=description)
else: else:
frappe.cache().set_value("workers:no-internet", True) frappe.cache.set_value("workers:no-internet", True)
return None return None
else: else:
raise raise
@ -436,13 +436,13 @@ class EmailAccount(Document):
else: else:
self.set_failed_attempts_count(self.get_failed_attempts_count() + 1) self.set_failed_attempts_count(self.get_failed_attempts_count() + 1)
else: else:
frappe.cache().set_value("workers:no-internet", True) frappe.cache.set_value("workers:no-internet", True)
def set_failed_attempts_count(self, value): def set_failed_attempts_count(self, value):
frappe.cache().set(f"{self.name}:email-account-failed-attempts", value) frappe.cache.set(f"{self.name}:email-account-failed-attempts", value)
def get_failed_attempts_count(self): def get_failed_attempts_count(self):
return cint(frappe.cache().get(f"{self.name}:email-account-failed-attempts")) return cint(frappe.cache.get(f"{self.name}:email-account-failed-attempts"))
def receive(self): def receive(self):
"""Called by scheduler to receive emails from this EMail account using POP3/IMAP.""" """Called by scheduler to receive emails from this EMail account using POP3/IMAP."""
@ -766,9 +766,9 @@ def pull(now=False):
"""Will be called via scheduler, pull emails from all enabled Email accounts.""" """Will be called via scheduler, pull emails from all enabled Email accounts."""
from frappe.integrations.doctype.connected_app.connected_app import has_token from frappe.integrations.doctype.connected_app.connected_app import has_token
if frappe.cache().get_value("workers:no-internet") == True: if frappe.cache.get_value("workers:no-internet") == True:
if test_internet(): if test_internet():
frappe.cache().set_value("workers:no-internet", False) frappe.cache.set_value("workers:no-internet", False)
return return
doctype = frappe.qb.DocType("Email Account") doctype = frappe.qb.DocType("Email Account")

6
frappe/email/doctype/notification/notification.py
View file

@ -42,10 +42,10 @@ class Notification(Document):
self.validate_forbidden_types() self.validate_forbidden_types()
self.validate_condition() self.validate_condition()
self.validate_standard() self.validate_standard()
frappe.cache().hdel("notifications", self.document_type) frappe.cache.hdel("notifications", self.document_type)
def on_update(self): def on_update(self):
frappe.cache().hdel("notifications", self.document_type) frappe.cache.hdel("notifications", self.document_type)
path = export_module_json(self, self.is_standard, self.module) path = export_module_json(self, self.is_standard, self.module)
if path: if path:
# js # js
@ -378,7 +378,7 @@ def get_context(context):
self.message = frappe.utils.md_to_html(self.message) self.message = frappe.utils.md_to_html(self.message)
def on_trash(self): def on_trash(self):
frappe.cache().hdel("notifications", self.document_type) frappe.cache.hdel("notifications", self.document_type)
@frappe.whitelist() @frappe.whitelist()

4
frappe/integrations/doctype/google_calendar/google_calendar.py
View file

@ -119,7 +119,7 @@ def authorize_access(g_calendar, reauthorize=None):
) )
if not google_calendar.authorization_code or reauthorize: if not google_calendar.authorization_code or reauthorize:
frappe.cache().hset("google_calendar", "google_calendar", google_calendar.name) frappe.cache.hset("google_calendar", "google_calendar", google_calendar.name)
return get_authentication_url(client_id=google_settings.client_id, redirect_uri=redirect_uri) return get_authentication_url(client_id=google_settings.client_id, redirect_uri=redirect_uri)
else: else:
try: try:
@ -163,7 +163,7 @@ def google_callback(code=None):
""" """
Authorization code is sent to callback as per the API configuration Authorization code is sent to callback as per the API configuration
""" """
google_calendar = frappe.cache().hget("google_calendar", "google_calendar") google_calendar = frappe.cache.hget("google_calendar", "google_calendar")
frappe.db.set_value("Google Calendar", google_calendar, "authorization_code", code) frappe.db.set_value("Google Calendar", google_calendar, "authorization_code", code)
frappe.db.commit() frappe.db.commit()

4
frappe/integrations/doctype/webhook/__init__.py
View file

@ -20,7 +20,7 @@ def run_webhooks(doc, method):
# TODO: remove this hazardous unnecessary cache in flags # TODO: remove this hazardous unnecessary cache in flags
if frappe.flags.webhooks is None: if frappe.flags.webhooks is None:
# load webhooks from cache # load webhooks from cache
webhooks = frappe.cache().get_value("webhooks") webhooks = frappe.cache.get_value("webhooks")
if webhooks is None: if webhooks is None:
# query webhooks # query webhooks
webhooks_list = frappe.get_all( webhooks_list = frappe.get_all(
@ -33,7 +33,7 @@ def run_webhooks(doc, method):
webhooks = {} webhooks = {}
for w in webhooks_list: for w in webhooks_list:
webhooks.setdefault(w.webhook_doctype, []).append(w) webhooks.setdefault(w.webhook_doctype, []).append(w)
frappe.cache().set_value("webhooks", webhooks) frappe.cache.set_value("webhooks", webhooks)
frappe.flags.webhooks = webhooks frappe.flags.webhooks = webhooks

2
frappe/integrations/doctype/webhook/test_webhook.py
View file

@ -102,7 +102,7 @@ class TestWebhook(FrappeTestCase):
def test_webhook_trigger_with_enabled_webhooks(self): def test_webhook_trigger_with_enabled_webhooks(self):
"""Test webhook trigger for enabled webhooks""" """Test webhook trigger for enabled webhooks"""
frappe.cache().delete_value("webhooks") frappe.cache.delete_value("webhooks")
frappe.flags.webhooks = None frappe.flags.webhooks = None
# Insert the user to db # Insert the user to db

2
frappe/integrations/doctype/webhook/webhook.py
View file

@ -29,7 +29,7 @@ class Webhook(Document):
self.preview_document = None self.preview_document = None
def on_update(self): def on_update(self):
frappe.cache().delete_value("webhooks") frappe.cache.delete_value("webhooks")
def validate_docevent(self): def validate_docevent(self):
if self.webhook_doctype: if self.webhook_doctype:

4
frappe/model/document.py
View file

@ -959,9 +959,7 @@ class Document(BaseDocument):
filters={"enabled": 1, "document_type": self.doctype}, filters={"enabled": 1, "document_type": self.doctype},
) )
self.flags.notifications = frappe.cache().hget( self.flags.notifications = frappe.cache.hget("notifications", self.doctype, _get_notifications)
"notifications", self.doctype, _get_notifications
)
if not self.flags.notifications: if not self.flags.notifications:
return return

6
frappe/model/meta.py
View file

@ -59,11 +59,11 @@ def get_meta(doctype, cached=True) -> "Meta":
if not cached: if not cached:
return Meta(doctype) return Meta(doctype)
if meta := frappe.cache().hget("doctype_meta", doctype): if meta := frappe.cache.hget("doctype_meta", doctype):
return meta return meta
meta = Meta(doctype) meta = Meta(doctype)
frappe.cache().hset("doctype_meta", doctype, meta) frappe.cache.hset("doctype_meta", doctype, meta)
return meta return meta
@ -814,7 +814,7 @@ def trim_tables(doctype=None, dry_run=False, quiet=False):
def trim_table(doctype, dry_run=True): def trim_table(doctype, dry_run=True):
frappe.cache().hdel("table_columns", f"tab{doctype}") frappe.cache.hdel("table_columns", f"tab{doctype}")
ignore_fields = default_fields + optional_fields + child_table_fields ignore_fields = default_fields + optional_fields + child_table_fields
columns = frappe.db.get_table_columns(doctype) columns = frappe.db.get_table_columns(doctype)
fields = frappe.get_meta(doctype, cached=False).get_fieldnames_with_value() fields = frappe.get_meta(doctype, cached=False).get_fieldnames_with_value()

8
frappe/model/utils/link_count.py
View file

@ -23,7 +23,7 @@ def flush_local_link_count():
if not new_links: if not new_links:
return return
link_count = frappe.cache().get_value("_link_count") or {} link_count = frappe.cache.get_value("_link_count") or {}
for key, value in new_links.items(): for key, value in new_links.items():
if key in link_count: if key in link_count:
@ -31,13 +31,13 @@ def flush_local_link_count():
else: else:
link_count[key] = value link_count[key] = value
frappe.cache().set_value("_link_count", link_count) frappe.cache.set_value("_link_count", link_count)
new_links.clear() new_links.clear()
def update_link_count(): def update_link_count():
"""increment link count in the `idx` column for the given document""" """increment link count in the `idx` column for the given document"""
link_count = frappe.cache().get_value("_link_count") link_count = frappe.cache.get_value("_link_count")
if link_count: if link_count:
for (doctype, name), count in link_count.items(): for (doctype, name), count in link_count.items():
@ -50,4 +50,4 @@ def update_link_count():
if not frappe.db.is_table_missing(e): # table not found, single if not frappe.db.is_table_missing(e): # table not found, single
raise e raise e
# reset the count # reset the count
frappe.cache().delete_value("_link_count") frappe.cache.delete_value("_link_count")

8
frappe/model/utils/user_settings.py
View file

@ -11,7 +11,7 @@ filter_dict = {"doctype": 0, "docfield": 1, "operator": 2, "value": 3}
def get_user_settings(doctype, for_update=False): def get_user_settings(doctype, for_update=False):
user_settings = frappe.cache().hget("_user_settings", f"{doctype}::{frappe.session.user}") user_settings = frappe.cache.hget("_user_settings", f"{doctype}::{frappe.session.user}")
if user_settings is None: if user_settings is None:
user_settings = frappe.db.sql( user_settings = frappe.db.sql(
@ -41,12 +41,12 @@ def update_user_settings(doctype, user_settings, for_update=False):
current.update(user_settings) current.update(user_settings)
frappe.cache().hset("_user_settings", f"{doctype}::{frappe.session.user}", json.dumps(current)) frappe.cache.hset("_user_settings", f"{doctype}::{frappe.session.user}", json.dumps(current))
def sync_user_settings(): def sync_user_settings():
"""Sync from cache to database (called asynchronously via the browser)""" """Sync from cache to database (called asynchronously via the browser)"""
for key, data in frappe.cache().hgetall("_user_settings").items(): for key, data in frappe.cache.hgetall("_user_settings").items():
key = safe_decode(key) key = safe_decode(key)
doctype, user = key.split("::") # WTF? doctype, user = key.split("::") # WTF?
frappe.db.multisql( frappe.db.multisql(
@ -99,4 +99,4 @@ def update_user_settings_data(
) )
# clear that user settings from the redis cache # clear that user settings from the redis cache
frappe.cache().hset("_user_settings", f"{user_setting.doctype}::{user_setting.user}", None) frappe.cache.hset("_user_settings", f"{user_setting.doctype}::{user_setting.user}", None)

8
frappe/model/workflow.py
View file

@ -26,12 +26,12 @@ class WorkflowPermissionError(frappe.ValidationError):
def get_workflow_name(doctype): def get_workflow_name(doctype):
workflow_name = frappe.cache().hget("workflow", doctype) workflow_name = frappe.cache.hget("workflow", doctype)
if workflow_name is None: if workflow_name is None:
workflow_name = frappe.db.get_value( workflow_name = frappe.db.get_value(
"Workflow", {"document_type": doctype, "is_active": 1}, "name" "Workflow", {"document_type": doctype, "is_active": 1}, "name"
) )
frappe.cache().hset("workflow", doctype, workflow_name or "") frappe.cache.hset("workflow", doctype, workflow_name or "")
return workflow_name return workflow_name
@ -228,10 +228,10 @@ def send_email_alert(workflow_name):
def get_workflow_field_value(workflow_name, field): def get_workflow_field_value(workflow_name, field):
value = frappe.cache().hget("workflow_" + workflow_name, field) value = frappe.cache.hget("workflow_" + workflow_name, field)
if value is None: if value is None:
value = frappe.db.get_value("Workflow", workflow_name, field) value = frappe.db.get_value("Workflow", workflow_name, field)
frappe.cache().hset("workflow_" + workflow_name, field, value) frappe.cache.hset("workflow_" + workflow_name, field, value)
return value return value

2
frappe/modules/utils.py
View file

@ -214,7 +214,7 @@ def export_doc(doctype, name, module=None):
def get_doctype_module(doctype: str) -> str: def get_doctype_module(doctype: str) -> str:
"""Returns **Module Def** name of given doctype.""" """Returns **Module Def** name of given doctype."""
doctype_module_map = frappe.cache().get_value( doctype_module_map = frappe.cache.get_value(
"doctype_modules", "doctype_modules",
generator=lambda: dict(frappe.qb.from_("DocType").select("name", "module").run()), generator=lambda: dict(frappe.qb.from_("DocType").select("name", "module").run()),
) )

10
frappe/monitor.py
View file

@ -106,22 +106,22 @@ class Monitor:
traceback.print_exc() traceback.print_exc()
def store(self): def store(self):
if frappe.cache().llen(MONITOR_REDIS_KEY) > MONITOR_MAX_ENTRIES: if frappe.cache.llen(MONITOR_REDIS_KEY) > MONITOR_MAX_ENTRIES:
frappe.cache().ltrim(MONITOR_REDIS_KEY, 1, -1) frappe.cache.ltrim(MONITOR_REDIS_KEY, 1, -1)
serialized = json.dumps(self.data, sort_keys=True, default=str, separators=(",", ":")) serialized = json.dumps(self.data, sort_keys=True, default=str, separators=(",", ":"))
frappe.cache().rpush(MONITOR_REDIS_KEY, serialized) frappe.cache.rpush(MONITOR_REDIS_KEY, serialized)
def flush(): def flush():
try: try:
# Fetch all the logs without removing from cache # Fetch all the logs without removing from cache
logs = frappe.cache().lrange(MONITOR_REDIS_KEY, 0, -1) logs = frappe.cache.lrange(MONITOR_REDIS_KEY, 0, -1)
if logs: if logs:
logs = list(map(frappe.safe_decode, logs)) logs = list(map(frappe.safe_decode, logs))
with open(log_file(), "a", os.O_NONBLOCK) as f: with open(log_file(), "a", os.O_NONBLOCK) as f:
f.write("\n".join(logs)) f.write("\n".join(logs))
f.write("\n") f.write("\n")
# Remove fetched entries from cache # Remove fetched entries from cache
frappe.cache().ltrim(MONITOR_REDIS_KEY, len(logs) - 1, -1) frappe.cache.ltrim(MONITOR_REDIS_KEY, len(logs) - 1, -1)
except Exception: except Exception:
traceback.print_exc() traceback.print_exc()

2
frappe/permissions.py
View file

@ -433,7 +433,7 @@ def get_roles(user=None, with_standard=True):
) )
return roles + ["All", "Guest"] return roles + ["All", "Guest"]
roles = frappe.cache().hget("roles", user, get) roles = frappe.cache.hget("roles", user, get)
# filter standard if required # filter standard if required
if not with_standard: if not with_standard:

12
frappe/rate_limiter.py
View file

@ -38,8 +38,8 @@ class RateLimiter:
timestamp = int(frappe.utils.now_datetime().timestamp()) timestamp = int(frappe.utils.now_datetime().timestamp())
self.window_number, self.spent = divmod(timestamp, self.window) self.window_number, self.spent = divmod(timestamp, self.window)
self.key = frappe.cache().make_key(f"rate-limit-counter-{self.window_number}") self.key = frappe.cache.make_key(f"rate-limit-counter-{self.window_number}")
self.counter = cint(frappe.cache().get(self.key)) self.counter = cint(frappe.cache.get(self.key))
self.remaining = max(self.limit - self.counter, 0) self.remaining = max(self.limit - self.counter, 0)
self.reset = self.window - self.spent self.reset = self.window - self.spent
@ -59,7 +59,7 @@ class RateLimiter:
self.end = datetime.utcnow() self.end = datetime.utcnow()
self.duration = int((self.end - self.start).total_seconds() * 1000000) self.duration = int((self.end - self.start).total_seconds() * 1000000)
pipeline = frappe.cache().pipeline() pipeline = frappe.cache.pipeline()
pipeline.incrby(self.key, self.duration) pipeline.incrby(self.key, self.duration)
pipeline.expire(self.key, self.window) pipeline.expire(self.key, self.window)
pipeline.execute() pipeline.execute()
@ -137,11 +137,11 @@ def rate_limit(
cache_key = f"rl:{frappe.form_dict.cmd}:{identity}" cache_key = f"rl:{frappe.form_dict.cmd}:{identity}"
value = frappe.cache().get(cache_key) or 0 value = frappe.cache.get(cache_key) or 0
if not value: if not value:
frappe.cache().setex(cache_key, seconds, 0) frappe.cache.setex(cache_key, seconds, 0)
value = frappe.cache().incrby(cache_key, 1) value = frappe.cache.incrby(cache_key, 1)
if value > _limit: if value > _limit:
frappe.throw( frappe.throw(
_("You hit the rate limit because of too many requests. Please try after sometime.") _("You hit the rate limit because of too many requests. Please try after sometime.")

22
frappe/recorder.py
View file

@ -65,7 +65,7 @@ def get_current_stack_frames():
def record(force=False): def record(force=False):
if __debug__: if __debug__:
if frappe.cache().get_value(RECORDER_INTERCEPT_FLAG) or force: if frappe.cache.get_value(RECORDER_INTERCEPT_FLAG) or force:
frappe.local._recorder = Recorder() frappe.local._recorder = Recorder()
@ -109,7 +109,7 @@ class Recorder:
"duration": float(f"{(datetime.datetime.now() - self.time).total_seconds() * 1000:0.3f}"), "duration": float(f"{(datetime.datetime.now() - self.time).total_seconds() * 1000:0.3f}"),
"method": self.method, "method": self.method,
} }
frappe.cache().hset(RECORDER_REQUEST_SPARSE_HASH, self.uuid, request_data) frappe.cache.hset(RECORDER_REQUEST_SPARSE_HASH, self.uuid, request_data)
frappe.publish_realtime( frappe.publish_realtime(
event="recorder-dump-event", event="recorder-dump-event",
message=json.dumps(request_data, default=str), message=json.dumps(request_data, default=str),
@ -121,7 +121,7 @@ class Recorder:
request_data["calls"] = self.calls request_data["calls"] = self.calls
request_data["headers"] = self.headers request_data["headers"] = self.headers
request_data["form_dict"] = self.form_dict request_data["form_dict"] = self.form_dict
frappe.cache().hset(RECORDER_REQUEST_HASH, self.uuid, request_data) frappe.cache.hset(RECORDER_REQUEST_HASH, self.uuid, request_data)
def mark_duplicates(self): def mark_duplicates(self):
counts = Counter([call["query"] for call in self.calls]) counts = Counter([call["query"] for call in self.calls])
@ -162,21 +162,21 @@ def administrator_only(function):
@do_not_record @do_not_record
@administrator_only @administrator_only
def status(*args, **kwargs): def status(*args, **kwargs):
return bool(frappe.cache().get_value(RECORDER_INTERCEPT_FLAG)) return bool(frappe.cache.get_value(RECORDER_INTERCEPT_FLAG))
@frappe.whitelist() @frappe.whitelist()
@do_not_record @do_not_record
@administrator_only @administrator_only
def start(*args, **kwargs): def start(*args, **kwargs):
frappe.cache().set_value(RECORDER_INTERCEPT_FLAG, 1) frappe.cache.set_value(RECORDER_INTERCEPT_FLAG, 1)
@frappe.whitelist() @frappe.whitelist()
@do_not_record @do_not_record
@administrator_only @administrator_only
def stop(*args, **kwargs): def stop(*args, **kwargs):
frappe.cache().delete_value(RECORDER_INTERCEPT_FLAG) frappe.cache.delete_value(RECORDER_INTERCEPT_FLAG)
@frappe.whitelist() @frappe.whitelist()
@ -184,9 +184,9 @@ def stop(*args, **kwargs):
@administrator_only @administrator_only
def get(uuid=None, *args, **kwargs): def get(uuid=None, *args, **kwargs):
if uuid: if uuid:
result = frappe.cache().hget(RECORDER_REQUEST_HASH, uuid) result = frappe.cache.hget(RECORDER_REQUEST_HASH, uuid)
else: else:
result = list(frappe.cache().hgetall(RECORDER_REQUEST_SPARSE_HASH).values()) result = list(frappe.cache.hgetall(RECORDER_REQUEST_SPARSE_HASH).values())
return result return result
@ -194,15 +194,15 @@ def get(uuid=None, *args, **kwargs):
@do_not_record @do_not_record
@administrator_only @administrator_only
def export_data(*args, **kwargs): def export_data(*args, **kwargs):
return list(frappe.cache().hgetall(RECORDER_REQUEST_HASH).values()) return list(frappe.cache.hgetall(RECORDER_REQUEST_HASH).values())
@frappe.whitelist() @frappe.whitelist()
@do_not_record @do_not_record
@administrator_only @administrator_only
def delete(*args, **kwargs): def delete(*args, **kwargs):
frappe.cache().delete_value(RECORDER_REQUEST_SPARSE_HASH) frappe.cache.delete_value(RECORDER_REQUEST_SPARSE_HASH)
frappe.cache().delete_value(RECORDER_REQUEST_HASH) frappe.cache.delete_value(RECORDER_REQUEST_HASH)
def record_queries(func: Callable): def record_queries(func: Callable):

24
frappe/sessions.py
View file

@ -85,8 +85,8 @@ def delete_session(sid=None, user=None, reason="Session Expired"):
# we should just ignore it till database is back up again. # we should just ignore it till database is back up again.
return return
frappe.cache().hdel("session", sid) frappe.cache.hdel("session", sid)
frappe.cache().hdel("last_db_session_update", sid) frappe.cache.hdel("last_db_session_update", sid)
if sid and not user: if sid and not user:
table = DocType("Sessions") table = DocType("Sessions")
user_details = ( user_details = (
@ -139,17 +139,17 @@ def get():
bootinfo = None bootinfo = None
if not getattr(frappe.conf, "disable_session_cache", None): if not getattr(frappe.conf, "disable_session_cache", None):
# check if cache exists # check if cache exists
bootinfo = frappe.cache().hget("bootinfo", frappe.session.user) bootinfo = frappe.cache.hget("bootinfo", frappe.session.user)
if bootinfo: if bootinfo:
bootinfo["from_cache"] = 1 bootinfo["from_cache"] = 1
bootinfo["user"]["recent"] = json.dumps(frappe.cache().hget("user_recent", frappe.session.user)) bootinfo["user"]["recent"] = json.dumps(frappe.cache.hget("user_recent", frappe.session.user))
if not bootinfo: if not bootinfo:
# if not create it # if not create it
bootinfo = get_bootinfo() bootinfo = get_bootinfo()
frappe.cache().hset("bootinfo", frappe.session.user, bootinfo) frappe.cache.hset("bootinfo", frappe.session.user, bootinfo)
try: try:
frappe.cache().ping() frappe.cache.ping()
except redis.exceptions.ConnectionError: except redis.exceptions.ConnectionError:
message = _("Redis cache server not running. Please contact Administrator / Tech support") message = _("Redis cache server not running. Please contact Administrator / Tech support")
if "messages" in bootinfo: if "messages" in bootinfo:
@ -161,7 +161,7 @@ def get():
if frappe.local.request: if frappe.local.request:
bootinfo["change_log"] = get_change_log() bootinfo["change_log"] = get_change_log()
bootinfo["metadata_version"] = frappe.cache().get_value("metadata_version") bootinfo["metadata_version"] = frappe.cache.get_value("metadata_version")
if not bootinfo["metadata_version"]: if not bootinfo["metadata_version"]:
bootinfo["metadata_version"] = frappe.reset_metadata_version() bootinfo["metadata_version"] = frappe.reset_metadata_version()
@ -276,7 +276,7 @@ class Session:
) )
# also add to memcache # also add to memcache
frappe.cache().hset("session", self.data.sid, self.data) frappe.cache.hset("session", self.data.sid, self.data)
def resume(self): def resume(self):
"""non-login request: load a session""" """non-login request: load a session"""
@ -320,7 +320,7 @@ class Session:
return data return data
def get_session_data_from_cache(self): def get_session_data_from_cache(self):
data = frappe.cache().hget("session", self.sid) data = frappe.cache.hget("session", self.sid)
if data: if data:
data = frappe._dict(data) data = frappe._dict(data)
session_data = data.get("data", {}) session_data = data.get("data", {})
@ -377,7 +377,7 @@ class Session:
self.data["data"]["lang"] = str(frappe.lang) self.data["data"]["lang"] = str(frappe.lang)
# update session in db # update session in db
last_updated = frappe.cache().hget("last_db_session_update", self.sid) last_updated = frappe.cache.hget("last_db_session_update", self.sid)
time_diff = frappe.utils.time_diff_in_seconds(now, last_updated) if last_updated else None time_diff = frappe.utils.time_diff_in_seconds(now, last_updated) if last_updated else None
# database persistence is secondary, don't update it too often # database persistence is secondary, don't update it too often
@ -397,11 +397,11 @@ class Session:
) )
frappe.db.commit() frappe.db.commit()
frappe.cache().hset("last_db_session_update", self.sid, now) frappe.cache.hset("last_db_session_update", self.sid, now)
updated_in_db = True updated_in_db = True
frappe.cache().hset("session", self.sid, self.data) frappe.cache.hset("session", self.sid, self.data)
return updated_in_db return updated_in_db

5
frappe/social/doctype/energy_point_log/energy_point_log.py
View file

@ -38,7 +38,7 @@ class EnergyPointLog(Document):
"energy_point_alert", message=alert_dict, user=self.user, after_commit=True "energy_point_alert", message=alert_dict, user=self.user, after_commit=True
) )
frappe.cache().hdel("energy_points", self.user) frappe.cache.hdel("energy_points", self.user)
if self.type != "Review" and frappe.get_cached_value( if self.type != "Review" and frappe.get_cached_value(
"Notification Settings", self.user, "energy_points_system_notifications" "Notification Settings", self.user, "energy_points_system_notifications"
@ -222,9 +222,6 @@ def add_review_points(user, points):
@frappe.whitelist() @frappe.whitelist()
def get_energy_points(user): def get_energy_points(user):
# points = frappe.cache().hget('energy_points', user,
# lambda: get_user_energy_and_review_points(user))
# TODO: cache properly
points = get_user_energy_and_review_points(user) points = get_user_energy_and_review_points(user)
return frappe._dict(points.get(user, {})) return frappe._dict(points.get(user, {}))

4
frappe/social/doctype/energy_point_log/test_energy_point_log.py
View file

@ -26,13 +26,13 @@ class TestEnergyPointLog(FrappeTestCase):
settings.save() settings.save()
def setUp(self): def setUp(self):
frappe.cache().delete_value("energy_point_rule_map") frappe.cache.delete_value("energy_point_rule_map")
def tearDown(self): def tearDown(self):
frappe.set_user("Administrator") frappe.set_user("Administrator")
frappe.db.delete("Energy Point Log") frappe.db.delete("Energy Point Log")
frappe.db.delete("Energy Point Rule") frappe.db.delete("Energy Point Rule")
frappe.cache().delete_value("energy_point_rule_map") frappe.cache.delete_value("energy_point_rule_map")
def test_user_energy_point(self): def test_user_energy_point(self):
frappe.set_user("test@example.com") frappe.set_user("test@example.com")

2
frappe/tests/test_boot.py
View file

@ -65,7 +65,7 @@ class TestBootData(FrappeTestCase):
).insert(ignore_permissions=True) ).insert(ignore_permissions=True)
get_user_pages_or_reports("Report") get_user_pages_or_reports("Report")
allowed_reports = frappe.cache().get_value("has_role:Report", user=frappe.session.user) allowed_reports = frappe.cache.get_value("has_role:Report", user=frappe.session.user)
# Test user must not see admin user's report # Test user must not see admin user's report
self.assertNotIn("Test Admin Report", allowed_reports) self.assertNotIn("Test Admin Report", allowed_reports)

4
frappe/tests/test_hooks.py
View file

@ -26,7 +26,7 @@ class TestHooks(FrappeTestCase):
hooks.override_doctype_class = {"ToDo": ["frappe.tests.test_hooks.CustomToDo"]} hooks.override_doctype_class = {"ToDo": ["frappe.tests.test_hooks.CustomToDo"]}
# Clear cache # Clear cache
frappe.cache().delete_value("app_hooks") frappe.cache.delete_value("app_hooks")
clear_controller_cache("ToDo") clear_controller_cache("ToDo")
todo = frappe.get_doc(doctype="ToDo", description="asdf") todo = frappe.get_doc(doctype="ToDo", description="asdf")
@ -45,7 +45,7 @@ class TestHooks(FrappeTestCase):
hooks.has_permission["Address"] = address_has_permission_hook hooks.has_permission["Address"] = address_has_permission_hook
# Clear cache # Clear cache
frappe.cache().delete_value("app_hooks") frappe.cache.delete_value("app_hooks")
# Init User and Address # Init User and Address
username = "test@example.com" username = "test@example.com"

10
frappe/tests/test_monitor.py
View file

@ -12,7 +12,7 @@ from frappe.utils.response import build_response
class TestMonitor(FrappeTestCase): class TestMonitor(FrappeTestCase):
def setUp(self): def setUp(self):
frappe.conf.monitor = 1 frappe.conf.monitor = 1
frappe.cache().delete_value(MONITOR_REDIS_KEY) frappe.cache.delete_value(MONITOR_REDIS_KEY)
def test_enable_monitor(self): def test_enable_monitor(self):
set_request(method="GET", path="/api/method/frappe.ping") set_request(method="GET", path="/api/method/frappe.ping")
@ -21,7 +21,7 @@ class TestMonitor(FrappeTestCase):
frappe.monitor.start() frappe.monitor.start()
frappe.monitor.stop(response) frappe.monitor.stop(response)
logs = frappe.cache().lrange(MONITOR_REDIS_KEY, 0, -1) logs = frappe.cache.lrange(MONITOR_REDIS_KEY, 0, -1)
self.assertEqual(len(logs), 1) self.assertEqual(len(logs), 1)
log = frappe.parse_json(logs[0].decode()) log = frappe.parse_json(logs[0].decode())
@ -39,7 +39,7 @@ class TestMonitor(FrappeTestCase):
frappe.monitor.start() frappe.monitor.start()
frappe.monitor.stop(response=None) frappe.monitor.stop(response=None)
logs = frappe.cache().lrange(MONITOR_REDIS_KEY, 0, -1) logs = frappe.cache.lrange(MONITOR_REDIS_KEY, 0, -1)
self.assertEqual(len(logs), 1) self.assertEqual(len(logs), 1)
log = frappe.parse_json(logs[0].decode()) log = frappe.parse_json(logs[0].decode())
@ -52,7 +52,7 @@ class TestMonitor(FrappeTestCase):
frappe.local.site, "frappe.ping", None, None, {}, is_async=False frappe.local.site, "frappe.ping", None, None, {}, is_async=False
) )
logs = frappe.cache().lrange(MONITOR_REDIS_KEY, 0, -1) logs = frappe.cache.lrange(MONITOR_REDIS_KEY, 0, -1)
self.assertEqual(len(logs), 1) self.assertEqual(len(logs), 1)
log = frappe.parse_json(logs[0].decode()) log = frappe.parse_json(logs[0].decode())
self.assertEqual(log.transaction_type, "job") self.assertEqual(log.transaction_type, "job")
@ -79,4 +79,4 @@ class TestMonitor(FrappeTestCase):
def tearDown(self): def tearDown(self):
frappe.conf.monitor = 0 frappe.conf.monitor = 0
frappe.cache().delete_value(MONITOR_REDIS_KEY) frappe.cache.delete_value(MONITOR_REDIS_KEY)

18
frappe/tests/test_rate_limiter.py
View file

@ -20,7 +20,7 @@ class TestRateLimiter(FrappeTestCase):
self.assertTrue(hasattr(frappe.local, "rate_limiter")) self.assertTrue(hasattr(frappe.local, "rate_limiter"))
self.assertIsInstance(frappe.local.rate_limiter, RateLimiter) self.assertIsInstance(frappe.local.rate_limiter, RateLimiter)
frappe.cache().delete(frappe.local.rate_limiter.key) frappe.cache.delete(frappe.local.rate_limiter.key)
delattr(frappe.local, "rate_limiter") delattr(frappe.local, "rate_limiter")
def test_apply_without_limit(self): def test_apply_without_limit(self):
@ -53,8 +53,8 @@ class TestRateLimiter(FrappeTestCase):
self.assertEqual(int(headers["X-RateLimit-Limit"]), 10000) self.assertEqual(int(headers["X-RateLimit-Limit"]), 10000)
self.assertEqual(int(headers["X-RateLimit-Remaining"]), 0) self.assertEqual(int(headers["X-RateLimit-Remaining"]), 0)
frappe.cache().delete(limiter.key) frappe.cache.delete(limiter.key)
frappe.cache().delete(frappe.local.rate_limiter.key) frappe.cache.delete(frappe.local.rate_limiter.key)
delattr(frappe.local, "rate_limiter") delattr(frappe.local, "rate_limiter")
def test_respond_under_limit(self): def test_respond_under_limit(self):
@ -64,7 +64,7 @@ class TestRateLimiter(FrappeTestCase):
response = frappe.rate_limiter.respond() response = frappe.rate_limiter.respond()
self.assertEqual(response, None) self.assertEqual(response, None)
frappe.cache().delete(frappe.local.rate_limiter.key) frappe.cache.delete(frappe.local.rate_limiter.key)
delattr(frappe.local, "rate_limiter") delattr(frappe.local, "rate_limiter")
def test_headers_under_limit(self): def test_headers_under_limit(self):
@ -79,7 +79,7 @@ class TestRateLimiter(FrappeTestCase):
self.assertEqual(int(headers["X-RateLimit-Limit"]), 10000) self.assertEqual(int(headers["X-RateLimit-Limit"]), 10000)
self.assertEqual(int(headers["X-RateLimit-Remaining"]), 10000) self.assertEqual(int(headers["X-RateLimit-Remaining"]), 10000)
frappe.cache().delete(frappe.local.rate_limiter.key) frappe.cache.delete(frappe.local.rate_limiter.key)
delattr(frappe.local, "rate_limiter") delattr(frappe.local, "rate_limiter")
def test_reject_over_limit(self): def test_reject_over_limit(self):
@ -90,7 +90,7 @@ class TestRateLimiter(FrappeTestCase):
limiter = RateLimiter(0.01, 86400) limiter = RateLimiter(0.01, 86400)
self.assertRaises(frappe.TooManyRequestsError, limiter.apply) self.assertRaises(frappe.TooManyRequestsError, limiter.apply)
frappe.cache().delete(limiter.key) frappe.cache.delete(limiter.key)
def test_do_not_reject_under_limit(self): def test_do_not_reject_under_limit(self):
limiter = RateLimiter(0.01, 86400) limiter = RateLimiter(0.01, 86400)
@ -100,13 +100,13 @@ class TestRateLimiter(FrappeTestCase):
limiter = RateLimiter(0.02, 86400) limiter = RateLimiter(0.02, 86400)
self.assertEqual(limiter.apply(), None) self.assertEqual(limiter.apply(), None)
frappe.cache().delete(limiter.key) frappe.cache.delete(limiter.key)
def test_update_method(self): def test_update_method(self):
limiter = RateLimiter(0.01, 86400) limiter = RateLimiter(0.01, 86400)
time.sleep(0.01) time.sleep(0.01)
limiter.update() limiter.update()
self.assertEqual(limiter.duration, cint(frappe.cache().get(limiter.key))) self.assertEqual(limiter.duration, cint(frappe.cache.get(limiter.key)))
frappe.cache().delete(limiter.key) frappe.cache.delete(limiter.key)

2
frappe/tests/test_twofactor.py
View file

@ -61,7 +61,7 @@ class TestTwoFactor(FrappeTestCase):
self.assertTrue(verification_obj) self.assertTrue(verification_obj)
self.assertTrue(tmp_id) self.assertTrue(tmp_id)
for k in ["_usr", "_pwd", "_otp_secret"]: for k in ["_usr", "_pwd", "_otp_secret"]:
self.assertTrue(frappe.cache().get(f"{tmp_id}{k}"), f"{k} not available") self.assertTrue(frappe.cache.get(f"{tmp_id}{k}"), f"{k} not available")
def test_two_factor_is_enabled(self): def test_two_factor_is_enabled(self):
""" """

2
frappe/tests/test_webform.py
View file

@ -80,4 +80,4 @@ def set_webform_hook(key, value):
delattr(hooks, hook) delattr(hooks, hook)
setattr(hooks, key, value) setattr(hooks, key, value)
frappe.cache().delete_key("app_hooks") frappe.cache.delete_key("app_hooks")

4
frappe/tests/test_website.py
View file

@ -46,7 +46,7 @@ class TestWebsite(FrappeTestCase):
frappe.db.set_value("Portal Settings", None, "default_portal_home", "test-portal-home") frappe.db.set_value("Portal Settings", None, "default_portal_home", "test-portal-home")
frappe.set_user("test-user-for-home-page@example.com") frappe.set_user("test-user-for-home-page@example.com")
frappe.cache().hdel("home_page", frappe.session.user) frappe.cache.hdel("home_page", frappe.session.user)
self.assertEqual(get_home_page(), "test-portal-home") self.assertEqual(get_home_page(), "test-portal-home")
frappe.db.set_value("Portal Settings", None, "default_portal_home", "") frappe.db.set_value("Portal Settings", None, "default_portal_home", "")
@ -210,7 +210,7 @@ class TestWebsite(FrappeTestCase):
self.assertEqual(response.headers.get("Location"), "/courses/data") self.assertEqual(response.headers.get("Location"), "/courses/data")
delattr(frappe.hooks, "website_redirects") delattr(frappe.hooks, "website_redirects")
frappe.cache().delete_key("app_hooks") frappe.cache.delete_key("app_hooks")
def test_custom_page_renderer(self): def test_custom_page_renderer(self):
from frappe import get_hooks from frappe import get_hooks

28
frappe/translate.py
View file

@ -125,7 +125,7 @@ def get_parent_language(lang: str) -> str:
def get_user_lang(user: str = None) -> str: def get_user_lang(user: str = None) -> str:
"""Set frappe.local.lang from user preferences on session beginning or resumption""" """Set frappe.local.lang from user preferences on session beginning or resumption"""
user = user or frappe.session.user user = user or frappe.session.user
lang = frappe.cache().hget("lang", user) lang = frappe.cache.hget("lang", user)
if not lang: if not lang:
# User.language => Session Defaults => frappe.local.lang => 'en' # User.language => Session Defaults => frappe.local.lang => 'en'
@ -136,7 +136,7 @@ def get_user_lang(user: str = None) -> str:
or "en" or "en"
) )
frappe.cache().hset("lang", user, lang) frappe.cache.hset("lang", user, lang)
return lang return lang
@ -168,9 +168,8 @@ def get_dict(fortype: str, name: str | None = None) -> dict[str, str]:
:param name: name of the document for which assets are to be returned. :param name: name of the document for which assets are to be returned.
""" """
fortype = fortype.lower() fortype = fortype.lower()
cache = frappe.cache()
asset_key = fortype + ":" + (name or "-") asset_key = fortype + ":" + (name or "-")
translation_assets = cache.hget("translation_assets", frappe.local.lang) or {} translation_assets = frappe.cache.hget("translation_assets", frappe.local.lang) or {}
if asset_key not in translation_assets: if asset_key not in translation_assets:
messages = [] messages = []
@ -210,7 +209,7 @@ def get_dict(fortype: str, name: str | None = None) -> dict[str, str]:
# remove untranslated # remove untranslated
message_dict = {k: v for k, v in message_dict.items() if k != v} message_dict = {k: v for k, v in message_dict.items() if k != v}
translation_assets[asset_key] = message_dict translation_assets[asset_key] = message_dict
cache.hset("translation_assets", frappe.local.lang, translation_assets) frappe.cache.hset("translation_assets", frappe.local.lang, translation_assets)
translation_map: dict = translation_assets[asset_key] translation_map: dict = translation_assets[asset_key]
@ -292,7 +291,7 @@ def get_all_translations(lang: str) -> dict[str, str]:
return all_translations return all_translations
try: try:
return frappe.cache().hget(MERGED_TRANSLATION_KEY, lang, generator=_merge_translations) return frappe.cache.hget(MERGED_TRANSLATION_KEY, lang, generator=_merge_translations)
except Exception: except Exception:
# People mistakenly call translation function on global variables # People mistakenly call translation function on global variables
# where locals are not initalized, translations dont make much sense there # where locals are not initalized, translations dont make much sense there
@ -361,19 +360,18 @@ def get_user_translations(lang):
user_translations[key] = value user_translations[key] = value
return user_translations return user_translations
return frappe.cache().hget(USER_TRANSLATION_KEY, lang, generator=_read_from_db) return frappe.cache.hget(USER_TRANSLATION_KEY, lang, generator=_read_from_db)
def clear_cache(): def clear_cache():
"""Clear all translation assets from :meth:`frappe.cache`""" """Clear all translation assets from :meth:`frappe.cache`"""
cache = frappe.cache() frappe.cache.delete_key("langinfo")
cache.delete_key("langinfo")
# clear translations saved in boot cache # clear translations saved in boot cache
cache.delete_key("bootinfo") frappe.cache.delete_key("bootinfo")
cache.delete_key("translation_assets") frappe.cache.delete_key("translation_assets")
cache.delete_key(USER_TRANSLATION_KEY) frappe.cache.delete_key(USER_TRANSLATION_KEY)
cache.delete_key(MERGED_TRANSLATION_KEY) frappe.cache.delete_key(MERGED_TRANSLATION_KEY)
def get_messages_for_app(app, deduplicate=True): def get_messages_for_app(app, deduplicate=True):
@ -1273,9 +1271,9 @@ def get_all_languages(with_language_name: bool = False) -> list:
frappe.connect() frappe.connect()
if with_language_name: if with_language_name:
return frappe.cache().get_value("languages_with_name", get_all_language_with_name) return frappe.cache.get_value("languages_with_name", get_all_language_with_name)
else: else:
return frappe.cache().get_value("languages", get_language_codes) return frappe.cache.get_value("languages", get_language_codes)
@frappe.whitelist(allow_guest=True) @frappe.whitelist(allow_guest=True)

22
frappe/twofactor.py
View file

@ -74,8 +74,8 @@ def get_cached_user_pass():
user = pwd = None user = pwd = None
tmp_id = frappe.form_dict.get("tmp_id") tmp_id = frappe.form_dict.get("tmp_id")
if tmp_id: if tmp_id:
user = frappe.safe_decode(frappe.cache().get(tmp_id + "_usr")) user = frappe.safe_decode(frappe.cache.get(tmp_id + "_usr"))
pwd = frappe.safe_decode(frappe.cache().get(tmp_id + "_pwd")) pwd = frappe.safe_decode(frappe.cache.get(tmp_id + "_pwd"))
return (user, pwd) return (user, pwd)
@ -101,13 +101,13 @@ def cache_2fa_data(user, token, otp_secret, tmp_id):
# set increased expiry time for SMS and Email # set increased expiry time for SMS and Email
if verification_method in ["SMS", "Email"]: if verification_method in ["SMS", "Email"]:
expiry_time = frappe.flags.token_expiry or 300 expiry_time = frappe.flags.token_expiry or 300
frappe.cache().set(tmp_id + "_token", token) frappe.cache.set(tmp_id + "_token", token)
frappe.cache().expire(tmp_id + "_token", expiry_time) frappe.cache.expire(tmp_id + "_token", expiry_time)
else: else:
expiry_time = frappe.flags.otp_expiry or 180 expiry_time = frappe.flags.otp_expiry or 180
for k, v in {"_usr": user, "_pwd": pwd, "_otp_secret": otp_secret}.items(): for k, v in {"_usr": user, "_pwd": pwd, "_otp_secret": otp_secret}.items():
frappe.cache().set(f"{tmp_id}{k}", v) frappe.cache.set(f"{tmp_id}{k}", v)
frappe.cache().expire(f"{tmp_id}{k}", expiry_time) frappe.cache.expire(f"{tmp_id}{k}", expiry_time)
def two_factor_is_enabled_for_(user): def two_factor_is_enabled_for_(user):
@ -160,8 +160,8 @@ def confirm_otp_token(login_manager, otp=None, tmp_id=None):
return True return True
if not tmp_id: if not tmp_id:
tmp_id = frappe.form_dict.get("tmp_id") tmp_id = frappe.form_dict.get("tmp_id")
hotp_token = frappe.cache().get(tmp_id + "_token") hotp_token = frappe.cache.get(tmp_id + "_token")
otp_secret = frappe.cache().get(tmp_id + "_otp_secret") otp_secret = frappe.cache.get(tmp_id + "_otp_secret")
if not otp_secret: if not otp_secret:
raise ExpiredLoginException(_("Login session expired, refresh page to retry")) raise ExpiredLoginException(_("Login session expired, refresh page to retry"))
@ -170,7 +170,7 @@ def confirm_otp_token(login_manager, otp=None, tmp_id=None):
hotp = pyotp.HOTP(otp_secret) hotp = pyotp.HOTP(otp_secret)
if hotp_token: if hotp_token:
if hotp.verify(otp, int(hotp_token)): if hotp.verify(otp, int(hotp_token)):
frappe.cache().delete(tmp_id + "_token") frappe.cache.delete(tmp_id + "_token")
tracker.add_success_attempt() tracker.add_success_attempt()
return True return True
else: else:
@ -308,8 +308,8 @@ def get_link_for_qrcode(user, totp_uri):
key_user = f"{key}_user" key_user = f"{key}_user"
key_uri = f"{key}_uri" key_uri = f"{key}_uri"
lifespan = int(frappe.db.get_single_value("System Settings", "lifespan_qrcode_image")) or 240 lifespan = int(frappe.db.get_single_value("System Settings", "lifespan_qrcode_image")) or 240
frappe.cache().set_value(key_uri, totp_uri, expires_in_sec=lifespan) frappe.cache.set_value(key_uri, totp_uri, expires_in_sec=lifespan)
frappe.cache().set_value(key_user, user, expires_in_sec=lifespan) frappe.cache.set_value(key_user, user, expires_in_sec=lifespan)
return get_url(f"/qrcode?k={key}") return get_url(f"/qrcode?k={key}")

2
frappe/utils/__init__.py
View file

@ -970,7 +970,7 @@ def get_assets_json():
if not hasattr(frappe.local, "assets_json"): if not hasattr(frappe.local, "assets_json"):
if not frappe.conf.developer_mode: if not frappe.conf.developer_mode:
frappe.local.assets_json = frappe.cache().get_value( frappe.local.assets_json = frappe.cache.get_value(
"assets_json", "assets_json",
_get_assets, _get_assets,
shared=True, shared=True,

8
frappe/utils/caching.py
View file

@ -143,7 +143,7 @@ def redis_cache(ttl: int | None = 3600, user: str | bool | None = None) -> Calla
func_key = f"{func.__module__}.{func.__qualname__}" func_key = f"{func.__module__}.{func.__qualname__}"
def clear_cache(): def clear_cache():
frappe.cache().delete_keys(func_key) frappe.cache.delete_keys(func_key)
func.clear_cache = clear_cache func.clear_cache = clear_cache
func.ttl = ttl if not callable(ttl) else 3600 func.ttl = ttl if not callable(ttl) else 3600
@ -151,12 +151,12 @@ def redis_cache(ttl: int | None = 3600, user: str | bool | None = None) -> Calla
@wraps(func) @wraps(func)
def redis_cache_wrapper(*args, **kwargs): def redis_cache_wrapper(*args, **kwargs):
func_call_key = func_key + "::" + str(__generate_request_cache_key(args, kwargs)) func_call_key = func_key + "::" + str(__generate_request_cache_key(args, kwargs))
if frappe.cache().exists(func_call_key): if frappe.cache.exists(func_call_key):
return frappe.cache().get_value(func_call_key, user=user) return frappe.cache.get_value(func_call_key, user=user)
else: else:
val = func(*args, **kwargs) val = func(*args, **kwargs)
ttl = getattr(func, "ttl", 3600) ttl = getattr(func, "ttl", 3600)
frappe.cache().set_value(func_call_key, val, expires_in_sec=ttl, user=user) frappe.cache.set_value(func_call_key, val, expires_in_sec=ttl, user=user)
return val return val
return redis_cache_wrapper return redis_cache_wrapper

12
frappe/utils/change_log.py
View file

@ -267,19 +267,17 @@ def check_release_on_github(app: str):
def add_message_to_redis(update_json): def add_message_to_redis(update_json):
# "update-message" will store the update message string # "update-message" will store the update message string
# "update-user-set" will be a set of users # "update-user-set" will be a set of users
cache = frappe.cache() frappe.cache.set_value("update-info", json.dumps(update_json))
cache.set_value("update-info", json.dumps(update_json))
user_list = [x.name for x in frappe.get_all("User", filters={"enabled": True})] user_list = [x.name for x in frappe.get_all("User", filters={"enabled": True})]
system_managers = [user for user in user_list if "System Manager" in frappe.get_roles(user)] system_managers = [user for user in user_list if "System Manager" in frappe.get_roles(user)]
cache.sadd("update-user-set", *system_managers) frappe.cache.sadd("update-user-set", *system_managers)
@frappe.whitelist() @frappe.whitelist()
def show_update_popup(): def show_update_popup():
cache = frappe.cache()
user = frappe.session.user user = frappe.session.user
update_info = cache.get_value("update-info") update_info = frappe.cache.get_value("update-info")
if not update_info: if not update_info:
return return
@ -287,7 +285,7 @@ def show_update_popup():
# Check if user is int the set of users to send update message to # Check if user is int the set of users to send update message to
update_message = "" update_message = ""
if cache.sismember("update-user-set", user): if frappe.cache.sismember("update-user-set", user):
for update_type in updates: for update_type in updates:
release_links = "" release_links = ""
for app in updates[update_type]: for app in updates[update_type]:
@ -308,4 +306,4 @@ def show_update_popup():
if update_message: if update_message:
frappe.msgprint(update_message, title=_("New updates are available"), indicator="green") frappe.msgprint(update_message, title=_("New updates are available"), indicator="green")
cache.srem("update-user-set", user) frappe.cache.srem("update-user-set", user)

2
frappe/utils/dashboard.py
View file

@ -25,7 +25,7 @@ def cache_source(function):
if int(kwargs.get("refresh") or 0): if int(kwargs.get("refresh") or 0):
results = generate_and_cache_results(kwargs, function, cache_key, chart) results = generate_and_cache_results(kwargs, function, cache_key, chart)
else: else:
cached_results = frappe.cache().get_value(cache_key) cached_results = frappe.cache.get_value(cache_key)
if cached_results: if cached_results:
results = frappe.parse_json(frappe.safe_decode(cached_results)) results = frappe.parse_json(frappe.safe_decode(cached_results))
else: else:

2
frappe/utils/data.py
View file

@ -326,7 +326,7 @@ def get_system_timezone():
if frappe.local.flags.in_test: if frappe.local.flags.in_test:
return _get_system_timezone() return _get_system_timezone()
return frappe.cache().get_value("time_zone", _get_system_timezone) return frappe.cache.get_value("time_zone", _get_system_timezone)
def convert_utc_to_timezone(utc_timestamp, time_zone): def convert_utc_to_timezone(utc_timestamp, time_zone):

8
frappe/utils/global_search.py
View file

@ -61,7 +61,7 @@ def get_doctypes_with_global_search(with_child_tables=True):
return doctypes return doctypes
return frappe.cache().get_value("doctypes_with_global_search", _get) return frappe.cache.get_value("doctypes_with_global_search", _get)
def rebuild_for_doctype(doctype): def rebuild_for_doctype(doctype):
@ -371,17 +371,17 @@ def sync_global_search():
:param flags: :param flags:
:return: :return:
""" """
while frappe.cache().llen("global_search_queue") > 0: while frappe.cache.llen("global_search_queue") > 0:
# rpop to follow FIFO # rpop to follow FIFO
# Last one should override all previous contents of same document # Last one should override all previous contents of same document
value = json.loads(frappe.cache().rpop("global_search_queue").decode("utf-8")) value = json.loads(frappe.cache.rpop("global_search_queue").decode("utf-8"))
sync_value(value) sync_value(value)
def sync_value_in_queue(value): def sync_value_in_queue(value):
try: try:
# append to search queue if connected # append to search queue if connected
frappe.cache().lpush("global_search_queue", json.dumps(value)) frappe.cache.lpush("global_search_queue", json.dumps(value))
except redis.exceptions.ConnectionError: except redis.exceptions.ConnectionError:
# not connected, sync directly # not connected, sync directly
sync_value(value) sync_value(value)

2
frappe/utils/oauth.py
View file

@ -210,7 +210,7 @@ def login_oauth_user(
if frappe.utils.cint(generate_login_token): if frappe.utils.cint(generate_login_token):
login_token = frappe.generate_hash(length=32) login_token = frappe.generate_hash(length=32)
frappe.cache().set_value( frappe.cache.set_value(
f"login_token:{login_token}", frappe.local.session.sid, expires_in_sec=120 f"login_token:{login_token}", frappe.local.session.sid, expires_in_sec=120
) )

6
frappe/utils/password.py
View file

@ -128,9 +128,9 @@ def check_password(user, pwd, doctype="User", fieldname="password", delete_track
def delete_login_failed_cache(user): def delete_login_failed_cache(user):
frappe.cache().hdel("last_login_tried", user) frappe.cache.hdel("last_login_tried", user)
frappe.cache().hdel("login_failed_count", user) frappe.cache.hdel("login_failed_count", user)
frappe.cache().hdel("locked_account_time", user) frappe.cache.hdel("locked_account_time", user)
def update_password(user, pwd, doctype="User", fieldname="password", logout_all_sessions=False): def update_password(user, pwd, doctype="User", fieldname="password", logout_all_sessions=False):

4
frappe/utils/pdf.py
View file

@ -273,13 +273,13 @@ def toggle_visible_pdf(soup):
def get_wkhtmltopdf_version(): def get_wkhtmltopdf_version():
wkhtmltopdf_version = frappe.cache().hget("wkhtmltopdf_version", None) wkhtmltopdf_version = frappe.cache.hget("wkhtmltopdf_version", None)
if not wkhtmltopdf_version: if not wkhtmltopdf_version:
try: try:
res = subprocess.check_output(["wkhtmltopdf", "--version"]) res = subprocess.check_output(["wkhtmltopdf", "--version"])
wkhtmltopdf_version = res.decode("utf-8").split(" ")[1] wkhtmltopdf_version = res.decode("utf-8").split(" ")[1]
frappe.cache().hset("wkhtmltopdf_version", None, wkhtmltopdf_version) frappe.cache.hset("wkhtmltopdf_version", None, wkhtmltopdf_version)
except Exception: except Exception:
pass pass

2
frappe/utils/redis_wrapper.py
View file

@ -251,7 +251,7 @@ class RedisWrapper(redis.Redis):
def hdel_keys(self, name_starts_with, key): def hdel_keys(self, name_starts_with, key):
"""Delete hash names with wildcard `*` and key""" """Delete hash names with wildcard `*` and key"""
for name in frappe.cache().get_keys(name_starts_with): for name in self.get_keys(name_starts_with):
name = name.split("|", 1)[1] name = name.split("|", 1)[1]
self.hdel(name, key) self.hdel(name, key)

4
frappe/utils/user.py
View file

@ -59,7 +59,7 @@ class UserPermissions:
return user return user
if not frappe.flags.in_install_db and not frappe.flags.in_test: if not frappe.flags.in_install_db and not frappe.flags.in_test:
user_doc = frappe.cache().hget("user_doc", self.name, get_user_doc) user_doc = frappe.cache.hget("user_doc", self.name, get_user_doc)
if user_doc: if user_doc:
self.doc = frappe.get_doc(user_doc) self.doc = frappe.get_doc(user_doc)
@ -186,7 +186,7 @@ class UserPermissions:
filters={"property": "allow_import", "value": "1"}, filters={"property": "allow_import", "value": "1"},
) )
frappe.cache().hset("can_import", frappe.session.user, self.can_import) frappe.cache.hset("can_import", frappe.session.user, self.can_import)
def get_defaults(self): def get_defaults(self):
import frappe.defaults import frappe.defaults

6
frappe/website/doctype/help_article/help_article.py
View file

@ -93,7 +93,7 @@ def get_sidebar_items():
as_dict=True, as_dict=True,
) )
return frappe.cache().get_value("knowledge_base:category_sidebar", _get) return frappe.cache.get_value("knowledge_base:category_sidebar", _get)
def clear_cache(): def clear_cache():
@ -105,8 +105,8 @@ def clear_cache():
def clear_website_cache(path=None): def clear_website_cache(path=None):
frappe.cache().delete_value("knowledge_base:category_sidebar") frappe.cache.delete_value("knowledge_base:category_sidebar")
frappe.cache().delete_value("knowledge_base:faq") frappe.cache.delete_value("knowledge_base:faq")
@frappe.whitelist(allow_guest=True) @frappe.whitelist(allow_guest=True)

2
frappe/website/page_renderers/not_found_page.py
View file

@ -21,7 +21,7 @@ class NotFoundPage(TemplatePage):
def render(self): def render(self):
if self.can_cache_404(): if self.can_cache_404():
frappe.cache().hset("website_404", self.request_url, True) frappe.cache.hset("website_404", self.request_url, True)
return super().render() return super().render()
def can_cache_404(self): def can_cache_404(self):

8
frappe/website/path_resolver.py
View file

@ -29,7 +29,7 @@ class PathResolver:
request = frappe.local.request or request request = frappe.local.request or request
# check if the request url is in 404 list # check if the request url is in 404 list
if request.url and can_cache() and frappe.cache().hget("website_404", request.url): if request.url and can_cache() and frappe.cache.hget("website_404", request.url):
return self.path, NotFoundPage(self.path) return self.path, NotFoundPage(self.path)
try: try:
@ -110,7 +110,7 @@ def resolve_redirect(path, query_string=None):
if not redirects: if not redirects:
return return
redirect_to = frappe.cache().hget("website_redirects", path) redirect_to = frappe.cache.hget("website_redirects", path)
if redirect_to: if redirect_to:
frappe.flags.redirect_location = redirect_to frappe.flags.redirect_location = redirect_to
@ -130,7 +130,7 @@ def resolve_redirect(path, query_string=None):
if match: if match:
redirect_to = re.sub(pattern, rule["target"], path_to_match) redirect_to = re.sub(pattern, rule["target"], path_to_match)
frappe.flags.redirect_location = redirect_to frappe.flags.redirect_location = redirect_to
frappe.cache().hset("website_redirects", path_to_match, redirect_to) frappe.cache.hset("website_redirects", path_to_match, redirect_to)
raise frappe.Redirect raise frappe.Redirect
@ -177,4 +177,4 @@ def get_website_rules():
# dont cache in development # dont cache in development
return _get() return _get()
return frappe.cache().get_value("website_route_rules", _get) return frappe.cache.get_value("website_route_rules", _get)

4
frappe/website/router.py
View file

@ -100,7 +100,7 @@ def get_pages(app=None):
return pages return pages
return frappe.cache().get_value("website_pages", lambda: _build(app)) return frappe.cache.get_value("website_pages", lambda: _build(app))
def get_pages_from_path(start, app, app_path): def get_pages_from_path(start, app, app_path):
@ -310,7 +310,7 @@ def get_doctypes_with_web_view():
] ]
return doctypes return doctypes
return frappe.cache().get_value("doctypes_with_web_view", _get) return frappe.cache.get_value("doctypes_with_web_view", _get)
def get_start_folders(): def get_start_folders():

29
frappe/website/utils.py
View file

@ -23,15 +23,14 @@ CLEANUP_PATTERN_3 = re.compile(r"(-)\1+")
def delete_page_cache(path): def delete_page_cache(path):
cache = frappe.cache() frappe.cache.delete_value("full_index")
cache.delete_value("full_index")
groups = ("website_page", "page_context") groups = ("website_page", "page_context")
if path: if path:
for name in groups: for name in groups:
cache.hdel(name, path) frappe.cache.hdel(name, path)
else: else:
for name in groups: for name in groups:
cache.delete_key(name) frappe.cache.delete_key(name)
def find_first_image(html): def find_first_image(html):
@ -127,7 +126,7 @@ def get_home_page():
# dont return cached homepage in development # dont return cached homepage in development
return _get_home_page() return _get_home_page()
return frappe.cache().hget("home_page", frappe.session.user, _get_home_page) return frappe.cache.hget("home_page", frappe.session.user, _get_home_page)
def get_home_page_via_hooks(): def get_home_page_via_hooks():
@ -296,7 +295,7 @@ def get_full_index(route=None, app=None):
return children_map return children_map
children_map = frappe.cache().get_value("website_full_index", _build) children_map = frappe.cache.get_value("website_full_index", _build)
frappe.local.flags.children_map = children_map frappe.local.flags.children_map = children_map
@ -363,13 +362,13 @@ def clear_cache(path=None):
from frappe.website.router import clear_routing_cache from frappe.website.router import clear_routing_cache
for key in ("website_generator_routes", "website_pages", "website_full_index", "sitemap_routes"): for key in ("website_generator_routes", "website_pages", "website_full_index", "sitemap_routes"):
frappe.cache().delete_value(key) frappe.cache.delete_value(key)
clear_routing_cache() clear_routing_cache()
frappe.cache().delete_value("website_404") frappe.cache.delete_value("website_404")
if path: if path:
frappe.cache().hdel("website_redirects", path) frappe.cache.hdel("website_redirects", path)
delete_page_cache(path) delete_page_cache(path)
else: else:
clear_sitemap() clear_sitemap()
@ -383,7 +382,7 @@ def clear_cache(path=None):
"page_context", "page_context",
"website_page", "website_page",
): ):
frappe.cache().delete_value(key) frappe.cache.delete_value(key)
for method in frappe.get_hooks("website_clear_cache"): for method in frappe.get_hooks("website_clear_cache"):
frappe.get_attr(method)(path) frappe.get_attr(method)(path)
@ -439,7 +438,7 @@ def get_sidebar_items(parent_sidebar, basepath=None):
def get_portal_sidebar_items(): def get_portal_sidebar_items():
sidebar_items = frappe.cache().hget("portal_menu_items", frappe.session.user) sidebar_items = frappe.cache.hget("portal_menu_items", frappe.session.user)
if sidebar_items is None: if sidebar_items is None:
sidebar_items = [] sidebar_items = []
roles = frappe.get_roles() roles = frappe.get_roles()
@ -462,7 +461,7 @@ def get_portal_sidebar_items():
i["enabled"] = 1 i["enabled"] = 1
add_items(sidebar_items, items_via_hooks) add_items(sidebar_items, items_via_hooks)
frappe.cache().hset("portal_menu_items", frappe.session.user, sidebar_items) frappe.cache.hset("portal_menu_items", frappe.session.user, sidebar_items)
return sidebar_items return sidebar_items
@ -507,7 +506,7 @@ def cache_html(func):
def cache_html_decorator(*args, **kwargs): def cache_html_decorator(*args, **kwargs):
if can_cache(): if can_cache():
html = None html = None
page_cache = frappe.cache().hget("website_page", args[0].path) page_cache = frappe.cache.hget("website_page", args[0].path)
if page_cache and frappe.local.lang in page_cache: if page_cache and frappe.local.lang in page_cache:
html = page_cache[frappe.local.lang] html = page_cache[frappe.local.lang]
if html: if html:
@ -516,9 +515,9 @@ def cache_html(func):
html = func(*args, **kwargs) html = func(*args, **kwargs)
context = args[0].context context = args[0].context
if can_cache(context.no_cache): if can_cache(context.no_cache):
page_cache = frappe.cache().hget("website_page", args[0].path) or {} page_cache = frappe.cache.hget("website_page", args[0].path) or {}
page_cache[frappe.local.lang] = html page_cache[frappe.local.lang] = html
frappe.cache().hset("website_page", args[0].path, page_cache) frappe.cache.hset("website_page", args[0].path, page_cache)
return html return html

4
frappe/workflow/doctype/workflow/test_workflow.py
View file

@ -33,7 +33,7 @@ class TestWorkflow(FrappeTestCase):
"postgres": 'ALTER TABLE "tabWorkflow Action" ADD COLUMN "user" varchar(140)', "postgres": 'ALTER TABLE "tabWorkflow Action" ADD COLUMN "user" varchar(140)',
} }
) )
frappe.cache().delete_value("table_columns") frappe.cache.delete_value("table_columns")
def tearDown(self): def tearDown(self):
frappe.delete_doc("Workflow", "Test ToDo") frappe.delete_doc("Workflow", "Test ToDo")
@ -49,7 +49,7 @@ class TestWorkflow(FrappeTestCase):
"postgres": 'ALTER TABLE "tabWorkflow Action" DROP COLUMN "user"', "postgres": 'ALTER TABLE "tabWorkflow Action" DROP COLUMN "user"',
} }
) )
frappe.cache().delete_value("table_columns") frappe.cache.delete_value("table_columns")
def test_default_condition(self): def test_default_condition(self):
"""test default condition is set""" """test default condition is set"""

2
frappe/workflow/doctype/workflow/workflow.py
View file

@ -17,7 +17,7 @@ class Workflow(Document):
def on_update(self): def on_update(self):
self.update_doc_status() self.update_doc_status()
frappe.clear_cache(doctype=self.document_type) frappe.clear_cache(doctype=self.document_type)
frappe.cache().delete_key("workflow_" + self.name) # clear cache created in model/workflow.py frappe.cache.delete_key("workflow_" + self.name) # clear cache created in model/workflow.py
def create_custom_field_for_workflow_state(self): def create_custom_field_for_workflow_state(self):
frappe.clear_cache(doctype=self.document_type) frappe.clear_cache(doctype=self.document_type)

8
frappe/www/login.py
View file

@ -104,7 +104,7 @@ def get_context(context):
@frappe.whitelist(allow_guest=True) @frappe.whitelist(allow_guest=True)
def login_via_token(login_token: str): def login_via_token(login_token: str):
sid = frappe.cache().get_value(f"login_token:{login_token}", expires=True) sid = frappe.cache.get_value(f"login_token:{login_token}", expires=True)
if not sid: if not sid:
frappe.respond_as_web_page(_("Invalid Request"), _("Invalid Login Token"), http_status_code=417) frappe.respond_as_web_page(_("Invalid Request"), _("Invalid Login Token"), http_status_code=417)
return return
@ -150,7 +150,7 @@ def _generate_temporary_login_link(email: str, expiry: int):
_("User with email address {0} does not exist").format(email), frappe.DoesNotExistError _("User with email address {0} does not exist").format(email), frappe.DoesNotExistError
) )
key = frappe.generate_hash() key = frappe.generate_hash()
frappe.cache().set_value(f"one_time_login_key:{key}", email, expires_in_sec=expiry * 60) frappe.cache.set_value(f"one_time_login_key:{key}", email, expires_in_sec=expiry * 60)
return get_url(f"/api/method/frappe.www.login.login_via_key?key={key}") return get_url(f"/api/method/frappe.www.login.login_via_key?key={key}")
@ -159,10 +159,10 @@ def _generate_temporary_login_link(email: str, expiry: int):
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def login_via_key(key: str): def login_via_key(key: str):
cache_key = f"one_time_login_key:{key}" cache_key = f"one_time_login_key:{key}"
email = frappe.cache().get_value(cache_key) email = frappe.cache.get_value(cache_key)
if email: if email:
frappe.cache().delete_value(cache_key) frappe.cache.delete_value(cache_key)
frappe.local.login_manager.login_as(email) frappe.local.login_manager.login_as(email)

2
frappe/www/message.py
View file

@ -20,7 +20,7 @@ def get_context(context):
elif frappe.local.form_dict.id: elif frappe.local.form_dict.id:
message_id = frappe.local.form_dict.id message_id = frappe.local.form_dict.id
key = f"message_id:{message_id}" key = f"message_id:{message_id}"
message = frappe.cache().get_value(key, expires=True) message = frappe.cache.get_value(key, expires=True)
if message: if message:
message_context.update(message.get("context", {})) message_context.update(message.get("context", {}))
if message.get("http_status_code"): if message.get("http_status_code"):

4
frappe/www/qrcode.py
View file

@ -29,8 +29,8 @@ def get_query_key():
def get_user_svg_from_cache(): def get_user_svg_from_cache():
"""Get User and SVG code from cache.""" """Get User and SVG code from cache."""
key = get_query_key() key = get_query_key()
totp_uri = frappe.cache().get_value(f"{key}_uri") totp_uri = frappe.cache.get_value(f"{key}_uri")
user = frappe.cache().get_value(f"{key}_user") user = frappe.cache.get_value(f"{key}_user")
if not totp_uri or not user: if not totp_uri or not user:
frappe.throw(_("Page has expired!"), frappe.PermissionError) frappe.throw(_("Page has expired!"), frappe.PermissionError)
if not frappe.db.exists("User", user): if not frappe.db.exists("User", user):

2
frappe/www/sitemap.py
View file

@ -69,4 +69,4 @@ def get_public_pages_from_doctypes():
return routes return routes
return frappe.cache().get_value("sitemap_routes", get_sitemap_routes) return frappe.cache.get_value("sitemap_routes", get_sitemap_routes)