Merge branch 'staging' into v5.x

bench/app.py

@@ -12,11 +12,13 @@ from collections import OrderedDict
 from datetime import date
 from functools import lru_cache
 from pathlib import Path
+from typing import Optional
 from urllib.parse import urlparse
 
 # imports - third party imports
 import click
 import git
+import semantic_version as sv
 
 # imports - module imports
 import bench
@@ -170,7 +172,7 @@ class App(AppMeta):
 		branch: str = None,
 		bench: "Bench" = None,
 		soft_link: bool = False,
-		cache_key = None,
+		cache_key=None,
 		*args,
 		**kwargs,
 	):
@@ -179,6 +181,7 @@ class App(AppMeta):
 		self.required_by = None
 		self.local_resolution = []
 		self.cache_key = cache_key
+		self.pyproject = None
 		super().__init__(name, branch, *args, **kwargs)
 
 	@step(title="Fetching App {repo}", success="App {repo} Fetched")
@@ -233,11 +236,13 @@ class App(AppMeta):
 		resolved=False,
 		restart_bench=True,
 		ignore_resolution=False,
-		using_cached=False
+		using_cached=False,
 	):
 		import bench.cli
 		from bench.utils.app import get_app_name
 
+		self.validate_app_dependencies()
+
 		verbose = bench.cli.verbose or verbose
 		app_name = get_app_name(self.bench.name, self.app_name)
 		if not resolved and self.app_name != "frappe" and not ignore_resolution:
@@ -292,6 +297,27 @@ class App(AppMeta):
 			required=self.local_resolution,
 		)
 
+	def get_pyproject(self) -> Optional[dict]:
+		from bench.utils.app import get_pyproject
+
+		if self.pyproject:
+			return self.pyproject
+
+		apps_path = os.path.join(os.path.abspath(self.bench.name), "apps")
+		pyproject_path = os.path.join(apps_path, self.app_name, "pyproject.toml")
+		self.pyproject = get_pyproject(pyproject_path)
+		return self.pyproject
+
+	def validate_app_dependencies(self) -> None:
+		pyproject = self.get_pyproject() or {}
+		deps: Optional[dict] = (
+			pyproject.get("tool", {}).get("bench", {}).get("frappe-dependencies")
+		)
+		if not deps:
+			return
+
+		for dep, version in deps.items():
+			validate_dependency(self, dep, version)
 
 	"""
 	Get App Cache
@@ -387,9 +413,107 @@ class App(AppMeta):
 
 	def prune_app_directory(self):
 		app_path = self.get_app_path()
+		if can_frappe_use_cached(self):
 			remove_unused_node_modules(app_path)
 
 
+def can_frappe_use_cached(app: App) -> bool:
+	min_frappe = get_required_frappe_version(app)
+	if not min_frappe:
+		return False
+
+	try:
+		return sv.Version(min_frappe) in sv.SimpleSpec(">=15.12.0")
+	except ValueError:
+		# Passed value is not a version string, it's an expression
+		pass
+
+	try:
+		"""
+		15.12.0 is the first version to support USING_CACHED,
+		but there is no way to check the last version without
+		support. So it's not possible to have a ">" filter.
+
+		Hence this excludes the first supported version.
+		"""
+		return sv.Version("15.12.0") not in sv.SimpleSpec(min_frappe)
+	except ValueError:
+		click.secho(f"Invalid value found for frappe version '{min_frappe}'", fg="yellow")
+		# Invalid expression
+		return False
+
+
+def validate_dependency(app: App, dep: str, req_version: str) -> None:
+	dep_path = Path(app.bench.name) / "apps" / dep
+	if not dep_path.is_dir():
+		click.secho(
+			f"Required frappe-dependency '{dep}' not found. "
+			f"Aborting '{app.name}' installation. "
+			f"Please install '{dep}' first and retry",
+			fg="red",
+		)
+		sys.exit(1)
+
+	dep_version = get_dep_version(dep, dep_path)
+	if not dep_version:
+		return
+
+	if sv.Version(dep_version) not in sv.SimpleSpec(req_version):
+		click.secho(
+			f"Installed frappe-dependency '{dep}' version '{dep_version}' "
+			f"does not satisfy required version '{req_version}'. "
+			f"App '{app.name}' might not work as expected",
+			fg="yellow",
+		)
+
+
+def get_dep_version(dep: str, dep_path: Path) -> Optional[str]:
+	from bench.utils.app import get_pyproject
+
+	dep_pp = get_pyproject(str(dep_path / "pyproject.toml"))
+	version = dep_pp.get("project", {}).get("version")
+	if version:
+		return version
+
+	dinit_path = dep_path / dep / "__init__.py"
+	if not dinit_path.is_file():
+		return None
+
+	with dinit_path.open("r", encoding="utf-8") as dinit:
+		for line in dinit:
+			if not line.startswith("__version__ =") and not line.startswith("VERSION ="):
+				continue
+
+			version = line.split("=")[1].strip().strip("\"'")
+			if version:
+				return version
+			else:
+				break
+
+	return None
+
+
+def get_required_frappe_version(app: App) -> Optional[str]:
+	pyproject = app.get_pyproject() or {}
+
+	# Reference: https://github.com/frappe/bench/issues/1524
+	req_frappe = (
+		pyproject.get("tool", {})
+		.get("bench", {})
+		.get("frappe-dependencies", {})
+		.get("frappe")
+	)
+
+	if not req_frappe:
+		click.secho(
+			"Required frappe version not set in pyproject.toml, "
+			"please refer: https://github.com/frappe/bench/issues/1524",
+			fg="yellow",
+		)
+
+	return req_frappe
+
+
 def remove_unused_node_modules(app_path: Path) -> None:
 	"""
 	Erring a bit the side of caution; since there is no explicit way
@@ -503,7 +627,9 @@ def get_app(
 	from bench.utils.app import check_existing_dir
 
 	bench = Bench(bench_path)
-	app = App(git_url, branch=branch, bench=bench, soft_link=soft_link, cache_key=cache_key)
+	app = App(
+		git_url, branch=branch, bench=bench, soft_link=soft_link, cache_key=cache_key
+	)
 	git_url = app.url
 	repo_name = app.repo
 	branch = app.tag
@@ -562,7 +688,12 @@ def get_app(
 		return
 
 	if app.get_cached():
-		app.install(verbose=verbose, skip_assets=skip_assets, restart_bench=restart_bench, using_cached=True)
+		app.install(
+			verbose=verbose,
+			skip_assets=skip_assets,
+			restart_bench=restart_bench,
+			using_cached=True,
+		)
 		return
 
 	dir_already_exists, cloned_path = check_existing_dir(bench_path, repo_name)
@@ -593,7 +724,6 @@ def get_app(
 	app.set_cache(compress_artifacts)
 
 
-
 def install_resolved_deps(
 	bench,
 	resolution,
@@ -602,6 +732,7 @@ def install_resolved_deps(
 	verbose=False,
 ):
 	from bench.utils.app import check_existing_dir
+
 	if "frappe" in resolution:
 		# Terminal dependency
 		del resolution["frappe"]

bench/utils/app.py

@@ -4,7 +4,7 @@ import pathlib
 import re
 import sys
 import subprocess
-from typing import List
+from typing import List, Optional
 from functools import lru_cache
 
 # imports - module imports
@@ -230,18 +230,13 @@ def get_app_name(bench_path: str, folder_name: str) -> str:
 	app_name = None
 	apps_path = os.path.join(os.path.abspath(bench_path), "apps")
 
-	pyproject_path = os.path.join(apps_path, folder_name, "pyproject.toml")
 	config_py_path = os.path.join(apps_path, folder_name, "setup.cfg")
 	setup_py_path = os.path.join(apps_path, folder_name, "setup.py")
 	
-	if os.path.exists(pyproject_path):
-		try:
-			from tomli import load
-		except ImportError:
-			from tomllib import load
-
-		with open(pyproject_path, "rb") as f:
-			app_name = load(f).get("project", {}).get("name")
+	pyproject_path = os.path.join(apps_path, folder_name, "pyproject.toml")
+	pyproject = get_pyproject(pyproject_path)
+	if pyproject:
+		app_name = pyproject.get("project", {}).get("name")
 
 	if not app_name and os.path.exists(config_py_path):
 		from setuptools.config import read_configuration
@@ -261,6 +256,19 @@ def get_app_name(bench_path: str, folder_name: str) -> str:
 	return folder_name
 
 
+def get_pyproject(pyproject_path: str) -> Optional[dict]:
+	if not os.path.exists(pyproject_path):
+		return None
+
+	try:
+		from tomli import load
+	except ImportError:
+		from tomllib import load
+
+	with open(pyproject_path, "rb") as f:
+		return load(f)
+
+
 def check_existing_dir(bench_path, repo_name):
 	cloned_path = os.path.join(bench_path, "apps", repo_name)
 	dir_already_exists = os.path.isdir(cloned_path)