From e4a2b8db38691ac78018fd51fe0e037afbd14d87 Mon Sep 17 00:00:00 2001 From: Ankush Menat Date: Mon, 20 Jan 2025 18:35:02 +0530 Subject: [PATCH] refactor: trim init.py (#29866) * refactor: Trim `__init__.py` We strayed from the goal here: https://github.com/frappe/frappe/pull/29181 So making up for it. * chore!: Delete unused get_version Not used anywhere * refactor: move few more functions to relevant place * asd --- frappe/__init__.py | 144 +--------------------------------------- frappe/cache_manager.py | 50 ++++++++++++++ frappe/sessions.py | 4 +- frappe/utils/data.py | 34 ++++++++++ 4 files changed, 89 insertions(+), 143 deletions(-) diff --git a/frappe/__init__.py b/frappe/__init__.py index 54279608e9..6d80613648 100644 --- a/frappe/__init__.py +++ b/frappe/__init__.py @@ -45,7 +45,7 @@ from frappe.query_builder.utils import ( patch_query_execute, ) from frappe.utils.caching import request_cache -from frappe.utils.data import cint, cstr, sbool +from frappe.utils.data import bold, cint, cstr, safe_decode, safe_encode, sbool # Local application imports from .exceptions import * @@ -964,49 +964,6 @@ def get_domain_data(module): raise -def clear_cache(user: str | None = None, doctype: str | None = None): - """Clear **User**, **DocType** or global cache. - - :param user: If user is given, only user cache is cleared. - :param doctype: If doctype is given, only DocType cache is cleared.""" - import frappe.cache_manager - import frappe.utils.caching - from frappe.website.router import clear_routing_cache - - if doctype: - frappe.cache_manager.clear_doctype_cache(doctype) - reset_metadata_version() - elif user: - frappe.cache_manager.clear_user_cache(user) - else: # everything - # Delete ALL keys associated with this site. - keys_to_delete = set(frappe.cache.get_keys("")) - for key in frappe.get_hooks("persistent_cache_keys"): - keys_to_delete.difference_update(frappe.cache.get_keys(key)) - frappe.cache.delete_value(list(keys_to_delete), make_keys=False) - - reset_metadata_version() - local.cache = {} - local.new_doc_templates = {} - - for fn in get_hooks("clear_cache"): - get_attr(fn)() - - if (not doctype and not user) or doctype == "DocType": - frappe.utils.caching._SITE_CACHE.clear() - frappe.client_cache.clear_cache() - - local.role_permissions = {} - if hasattr(local, "request_cache"): - local.request_cache.clear() - if hasattr(local, "system_settings"): - del local.system_settings - if hasattr(local, "website_settings"): - del local.website_settings - - clear_routing_cache() - - def only_has_select_perm(doctype, user=None, ignore_permissions=False): if ignore_permissions: return False @@ -1136,13 +1093,6 @@ def generate_hash(txt: str | None = None, length: int = 56) -> str: return secrets.token_hex(math.ceil(length / 2))[:length] -def reset_metadata_version(): - """Reset `metadata_version` (Client (Javascript) build ID) hash.""" - v = generate_hash() - client_cache.set_value("metadata_version", v) - return v - - def new_doc( doctype: str, *, @@ -2343,11 +2293,6 @@ def get_desk_link(doctype, name): return html.format(doctype=doctype, name=name, doctype_local=_(doctype), title_local=_(title)) -def bold(text: str | int | float) -> str: - """Return `text` wrapped in `` tags.""" - return f"{text}" - - def safe_eval(code, eval_globals=None, eval_locals=None): """A safer `eval`""" @@ -2373,96 +2318,11 @@ def get_active_domains(): return get_active_domains() -def get_version(doctype, name, limit=None, head=False, raise_err=True): - """ - Return a list of version information for the given DocType. - - Note: Applicable only if DocType has changes tracked. - - Example - >>> frappe.get_version("User", "foobar@gmail.com") - >>> - [ - { - "version": [version.data], # Refer Version DocType get_diff method and data attribute - "user": "admin@gmail.com", # User that created this version - "creation": # Creation timestamp of that object. - } - ] - """ - meta = get_meta(doctype) - if meta.track_changes: - names = get_all( - "Version", - filters={ - "ref_doctype": doctype, - "docname": name, - "order_by": "creation" if head else None, - "limit": limit, - }, - as_list=1, - ) - - from frappe.utils import dictify, safe_json_loads, squashify - - versions = [] - - for name in names: - name = squashify(name) - doc = get_doc("Version", name) - - data = doc.data - data = safe_json_loads(data) - data = dictify(dict(version=data, user=doc.owner, creation=doc.creation)) - - versions.append(data) - - return versions - else: - if raise_err: - raise ValueError(_("{0} has no versions tracked.").format(doctype)) - - @whitelist(allow_guest=True) def ping(): return "pong" -def safe_encode(param, encoding="utf-8"): - try: - param = param.encode(encoding) - except Exception: - pass - return param - - -def safe_decode(param, encoding="utf-8", fallback_map: dict | None = None): - """ - Method to safely decode data into a string - - :param param: The data to be decoded - :param encoding: The encoding to decode into - :param fallback_map: A fallback map to reference in case of a LookupError - :return: - """ - try: - param = param.decode(encoding) - except LookupError: - try: - param = param.decode((fallback_map or {}).get(encoding, "utf-8")) - except Exception: - pass - except Exception: - pass - return param - - -def parse_json(val): - from frappe.utils import parse_json - - return parse_json(val) - - def mock(type, size=1, locale="en"): import faker @@ -2499,10 +2359,12 @@ def validate_and_sanitize_search_inputs(fn): import frappe._optimizations +from frappe.cache_manager import clear_cache, reset_metadata_version # Backward compatibility from frappe.config import get_common_site_config, get_site_config from frappe.core.doctype.system_settings.system_settings import get_system_settings +from frappe.utils import parse_json from frappe.utils.error import log_error frappe._optimizations.optimize_all() diff --git a/frappe/cache_manager.py b/frappe/cache_manager.py index 202f766ae1..aca0bdcc2e 100644 --- a/frappe/cache_manager.py +++ b/frappe/cache_manager.py @@ -243,3 +243,53 @@ def build_domain_restricted_page_cache(*args, **kwargs): frappe.cache.set_value("domain_restricted_pages", pages) return pages + + +def clear_cache(user: str | None = None, doctype: str | None = None): + """Clear **User**, **DocType** or global cache. + + :param user: If user is given, only user cache is cleared. + :param doctype: If doctype is given, only DocType cache is cleared.""" + import frappe.cache_manager + import frappe.utils.caching + from frappe.website.router import clear_routing_cache + + if doctype: + frappe.cache_manager.clear_doctype_cache(doctype) + reset_metadata_version() + elif user: + frappe.cache_manager.clear_user_cache(user) + else: # everything + # Delete ALL keys associated with this site. + keys_to_delete = set(frappe.cache.get_keys("")) + for key in frappe.get_hooks("persistent_cache_keys"): + keys_to_delete.difference_update(frappe.cache.get_keys(key)) + frappe.cache.delete_value(list(keys_to_delete), make_keys=False) + + reset_metadata_version() + frappe.local.cache = {} + frappe.local.new_doc_templates = {} + + for fn in frappe.get_hooks("clear_cache"): + frappe.get_attr(fn)() + + if (not doctype and not user) or doctype == "DocType": + frappe.utils.caching._SITE_CACHE.clear() + frappe.client_cache.clear_cache() + + frappe.local.role_permissions = {} + if hasattr(frappe.local, "request_cache"): + frappe.local.request_cache.clear() + if hasattr(frappe.local, "system_settings"): + del frappe.local.system_settings + if hasattr(frappe.local, "website_settings"): + del frappe.local.website_settings + + clear_routing_cache() + + +def reset_metadata_version(): + """Reset `metadata_version` (Client (Javascript) build ID) hash.""" + v = frappe.generate_hash() + frappe.client_cache.set_value("metadata_version", v) + return v diff --git a/frappe/sessions.py b/frappe/sessions.py index 8e807a382f..6329b1320d 100644 --- a/frappe/sessions.py +++ b/frappe/sessions.py @@ -19,7 +19,7 @@ import frappe.translate import frappe.utils from frappe import _ from frappe.apps import get_apps, get_default_path, is_desk_apps -from frappe.cache_manager import clear_user_cache +from frappe.cache_manager import clear_user_cache, reset_metadata_version from frappe.query_builder import Order from frappe.utils import cint, cstr, get_assets_json from frappe.utils.change_log import has_app_update_notifications @@ -157,7 +157,7 @@ def get(): bootinfo["metadata_version"] = frappe.client_cache.get_value("metadata_version") if not bootinfo["metadata_version"]: - bootinfo["metadata_version"] = frappe.reset_metadata_version() + bootinfo["metadata_version"] = reset_metadata_version() bootinfo.notes = get_unseen_notes() bootinfo.assets_json = get_assets_json() diff --git a/frappe/utils/data.py b/frappe/utils/data.py index f777c679a8..44cdc8fb45 100644 --- a/frappe/utils/data.py +++ b/frappe/utils/data.py @@ -2599,6 +2599,40 @@ def map_trackers(url_trackers: dict, create: bool = False): return frappe_trackers +def bold(text: str | int | float) -> str: + """Return `text` wrapped in `` tags.""" + return f"{text}" + + +def safe_encode(param, encoding="utf-8"): + try: + param = param.encode(encoding) + except Exception: + pass + return param + + +def safe_decode(param, encoding="utf-8", fallback_map: dict | None = None): + """ + Method to safely decode data into a string + + :param param: The data to be decoded + :param encoding: The encoding to decode into + :param fallback_map: A fallback map to reference in case of a LookupError + :return: + """ + try: + param = param.decode(encoding) + except LookupError: + try: + param = param.decode((fallback_map or {}).get(encoding, "utf-8")) + except Exception: + pass + except Exception: + pass + return param + + # This is used in test to count memory overhead of default imports. def _get_rss_memory_usage(): import psutil