fix: restrict Party Type/Party to Receivable/Payable accounts in Journal Entry

Journal Entry validation only checked party details when an account was
of type Receivable/Payable, but never restricted setting a Party Type or
Party against accounts of other types. This regressed v14 behavior where
party info could only be captured for Receivable/Payable accounts.

Add a branch to validate_party() that throws when a Party Type or Party
is set on an account that is not Receivable/Payable, with a clear message.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.github/POSTGRES_COMPATIBILITY.md

@@ -1,220 +0,0 @@
-# PostgreSQL compatibility — review guide
-
-ERPNext targets **both MariaDB and PostgreSQL from a single codebase**. The full server
-test suite passes on both, but the PostgreSQL CI job is **label-gated** (it does not run on
-every PR), so until it is required this guide is the always-on guard. Greptile loads it as
-review context (`.greptile/config.json`).
-
-When reviewing a PR, flag any **new or changed query** (raw `frappe.db.sql`, `frappe.qb`,
-`frappe.get_all/get_list/get_value`, report SQL) that would **error on PostgreSQL** or
-**return different results on the two engines**.
-
-## The one rule that governs everything
-
-**MariaDB behaviour must not change; PostgreSQL is brought into line with MariaDB — never the
-reverse.** A "fix" that changes the value, row count, or ordering MariaDB produced is a
-regression, even if the new behaviour looks more correct. The only accepted MariaDB-output
-change is replacing a genuinely *undefined/arbitrary* result with a deterministic one (row
-count preserved) — and that should be called out explicitly.
-
-There are two failure modes to watch for:
-1. **Hard breaks** — PostgreSQL raises an exception; MariaDB is green. Easy to catch in CI,
-   but the gated job may not run.
-2. **Silent divergences** — both engines succeed but return *different* results. CI on one
-   engine stays green; the bug only shows on a PostgreSQL site. These are the dangerous ones.
-
----
-
-## 1. Hard breaks — would error on PostgreSQL
-
-Flag a changed query that uses any of these:
-
-- **Loose `GROUP BY`** — selecting/ordering a column that is neither in `GROUP BY` nor wrapped
-  in an aggregate. MariaDB tolerates it; PostgreSQL errors (`must appear in the GROUP BY
-  clause or be used in an aggregate function`). This **also covers an aggregate (`Sum`/`Count`/…)
-  selected alongside bare columns with NO `.groupby()` at all** — MariaDB silently collapses
-  every row into one arbitrary-valued row (often a *wrong-output* bug there too), PostgreSQL
-  errors. Fix: add the bare column to `GROUP BY` **if it is functionally dependent on the group
-  key**, otherwise wrap it in `Max()`/`Min()`. **See §3 — the row-count trap — before suggesting
-  "add it to GROUP BY".**
-- **MySQL-only functions** — `TIMESTAMP(date,time)`, `TIMEDIFF`, `STR_TO_DATE`, `DATE_FORMAT`,
-  `DATE_ADD/SUB`, `GROUP_CONCAT`, `PERIOD_DIFF`, SQL `IF(cond,a,b)`. Use the portable
-  `frappe.query_builder.functions` equivalents (`CombineDatetime`, `DateDiff`, `Case`,
-  `GroupConcat`, …) or a precomputed column (e.g. `posting_datetime`).
-- **`UPDATE … JOIN`** — not valid on PostgreSQL. Rewrite as `UPDATE … WHERE name IN (subquery)`.
-- **`HAVING` referencing a `SELECT` alias** — PostgreSQL rejects output-column aliases in
-  `HAVING` (regardless of whether the query has a `GROUP BY`; MariaDB allows them). Repeat the
-  underlying expression in `HAVING`, or move a non-aggregate predicate into `WHERE`.
-- **`SELECT DISTINCT … ORDER BY <expr not in the select list>`** — add the expr to the select
-  **only if it is single-valued per distinct row**; otherwise it grows the `DISTINCT` key and the
-  MariaDB row count (see §3) — drop the SQL `ORDER BY` and sort in Python instead.
-- **Single-quoted column alias** `AS 'x'` — PostgreSQL reads `'x'` as a string literal. Use an
-  unquoted (or double-quoted) alias.
-- **`varchar | varchar`** (bitwise OR misused as a coalesce) — errors on PostgreSQL. Use
-  `Coalesce(...)`.
-- **Capital-cased identifiers** used as column/field names in `get_value(dt, dn, "Status")`,
-  `get_all(dt, fields=["Account"])`, and similar — PostgreSQL quotes the identifier and matches
-  it case-sensitively; a stored column named `status`/`account` won't match `"Status"`/`"Account"`
-  (`column "Account" does not exist`). Use the exact stored (lower-case) fieldname.
-- **Boolean passed where an integer column is expected** — `frappe.db.set_value(dt, dn,
-  check_field, True)`, `doc.db_set(field, False)`, or `frappe.qb.update(dt).set(check_field, True)`
-  emit `SET col = true`, which PostgreSQL rejects on a `smallint`/`Check` column
-  (`column is of type smallint but expression is of type boolean`). Pass `1`/`0`.
-- **`.like()`/`.ilike()` (or raw `LIKE`) on a NON-text column** — `idx`, `docstatus`, a date, etc.
-  frappe maps `.like()` → `ILIKE`, and PostgreSQL has no `bigint ILIKE text` operator (`operator
-  does not exist: bigint ~~* unknown`). Cast the column to text first — **`Cast_(col, "varchar")`**,
-  not `Cast(col, "char")` (see below). MariaDB coerces the int implicitly, so the cast is a no-op there.
-- **`CAST(… AS CHAR)` / `Cast(x, "char")`** — on PostgreSQL bare `CHAR` is `character(1)`, so
-  `CAST(12 AS CHAR)` → `'1'` (silently truncates multi-digit values); MariaDB gives the full string.
-  Use `VARCHAR` / `Cast_(x, "varchar")`.
-- **`.rlike()` / raw `RLIKE`** — frappe rewrites `REGEXP` → `~*` on PostgreSQL but does **not**
-  translate `RLIKE` (no such PostgreSQL operator). Use `.regexp()` (or `.like()` for a simple prefix).
-- **`IfNull`/`Coalesce` of a typed column with a different-typed literal** — `IfNull(asset.disposal_date, 0)`
-  renders `COALESCE("disposal_date", 0)`, coalescing a **DATE** with an **integer**. PostgreSQL requires
-  `COALESCE` args to share a type (`DatatypeMismatch: COALESCE types date and integer cannot be matched`);
-  MariaDB's `IFNULL` is permissive. The common shape is `IfNull(date_col, 0) != 0 / == 0` as a presence test —
-  replace with `date_col.isnotnull()` / `date_col.isnull()` (identical, and valid on both). Otherwise coalesce
-  to a **same-type** default (`Coalesce(date_col, '1900-01-01')`, `Coalesce(text_col, '')`).
-- **Division by a possibly-zero divisor** — `Sum(a) / Sum(b)`, `x / col`, etc. where the
-  divisor can be `0`/empty. MariaDB returns `NULL` for division by zero; PostgreSQL raises
-  `division by zero` and aborts the query. Wrap the divisor in `NullIf(divisor, 0)` — that
-  yields `NULL` on both engines, matching MariaDB's value. (Only the *literal* `/ 0` is a parse
-  constant; the trap is a divisor that is an aggregate or column the data can drive to zero.)
-
----
-
-## 2. Silent divergences — succeeds on both, returns different results
-
-These don't error, so a one-engine CI stays green. Flag them:
-
-- **Case sensitivity on text equality** — `==`, `.isin()`, `Strpos`/`Locate` on free-text
-  columns are case-**sensitive** on PostgreSQL but case-**insensitive** under MariaDB's default
-  collation. `Lower()` both sides. *(Not `.like()`/`["like", …]` — those already render as
-  `ILIKE` on PostgreSQL; see §4.)*
-- **Case sensitivity in a doc-`name` lookup** — lower-casing a value then using it as a
-  document name in `get_value`/`get_doc`/`exists` misses on PostgreSQL (names are
-  case-sensitive). Keep original case for the identifier; lower-case only comparison operands.
-- **Empty string vs NULL** — PostgreSQL stores a blank link/data field as `NULL` on some paths
-  while MariaDB keeps `''`; `Concat`/`Concat_ws` then diverge. Prefer the stored full value, or
-  `Coalesce(col, '')` per argument.
-- **NULL ordering** — MariaDB sorts `NULL` first, PostgreSQL sorts it last. For
-  `ORDER BY … LIMIT 1`/`[0]` on a nullable column, guard with `Coalesce`/`isnotnull()`.
-- **`ORDER BY … LIMIT 1` with no unique tiebreaker** — when rows tie on the ordered column the
-  two engines may pick different rows. Add a `creation`/`name` tiebreaker **only if it does not
-  change MariaDB's current pick** (see §4).
-- **Integer division** — `int / int` truncates on PostgreSQL but is decimal on MariaDB, e.g.
-  `COUNT(...) / COUNT(...) * 100` → `0`, or `manufacturing_time_in_mins / 1440` flooring a
-  lead-time to whole days. Force float: multiply by `100.0`, or make a literal a float
-  (`/ 1440` → `/ 1440.0`), or cast an operand. (Only SQL-level `/` on integer **columns/literals**
-  — Python `/` is already float.)
-- **`DISTINCT` list ordering** — `frappe.get_all(distinct=True, order_by=…)` /
-  `SELECT DISTINCT … ORDER BY`: frappe's `db_query` **silently drops `ORDER BY` for distinct
-  queries on PostgreSQL**, so the result is unordered there. Sort in Python instead — and use
-  `key=str.casefold`, because bare `sorted()` is case-sensitive (ASCII) while MariaDB's
-  collation is case-insensitive, so a plain sort reorders MariaDB's output.
-- **Engine-specific function rewrites** — e.g. a PostgreSQL `regexp_replace` branch
-  reimplementing MariaDB's `CAST(SUBSTRING_INDEX(name,' ',-1) AS UNSIGNED)` (leading digits of
-  the last whitespace token). Verify the rewrite matches MariaDB on edge cases (`"X - 3a"→3`,
-  `"X - 1.5"→1`) by diffing both engines on literal rows.
-- **`UnixTimestamp(date)` / date→epoch** is timezone-dependent (midnight in the DB session TZ),
-  so a strict `epoch <= now` bound is flaky on PostgreSQL.
-
----
-
-## 3. The row-count trap — `GROUP BY` **and** `DISTINCT` (the single most important rule)
-
-When making a loose `GROUP BY` PostgreSQL-valid, **do not add a non-functionally-dependent
-column to the `GROUP BY` just to satisfy PostgreSQL** — that turns one group row into N and
-**changes the MariaDB row count** (a regression). The classic traps are adding the **child/row
-primary key** or an **editable per-row field**. Instead **`Max()`/`Min()`-wrap** the offending
-column: the row count is preserved and the value goes from arbitrary (MariaDB's old loose pick)
-to deterministic.
-
-**Judge functional dependence by the source table, not the column name:**
-- A column from a **master joined on the group key** (`t3.x` where `t1.key = t3.name`) is FD →
-  safe to keep in `GROUP BY`.
-- A descriptive field on the **transaction** table (`t1.supplier_name`, `t1.territory`,
-  `t1.item_name` — fetched/editable, can differ across historical rows for the same key) is
-  **not** FD even though it looks master-derived → `Max()`-wrap it.
-
-Conversely, do **not** suggest changing a `Max()`/`Min()`-wrapped column to `Sum()` (or vice
-versa) to make a number "more correct" — that changes the MariaDB value. The wrap reproduces
-MariaDB's prior one-value-per-group output; a different aggregate is a product change, out of
-scope for a portability fix.
-
-**The same trap applies to `SELECT DISTINCT`.** To satisfy PostgreSQL's "an `ORDER BY` expr must
-appear in the select list under `DISTINCT`" rule, **do not blindly add the ordered column to the
-select** — if it is not single-valued per existing distinct row, the `DISTINCT` key grows and
-MariaDB returns **more rows** (a regression), exactly as adding a non-FD column to `GROUP BY` does.
-Add it only when it is functionally dependent on the existing select columns; otherwise drop the
-SQL `ORDER BY` and **sort in Python** (`key=str.casefold`, per §2) so the distinct row set is
-unchanged.
-
----
-
-## 4. False positives — do NOT flag these
-
-These are auto-handled by the framework and are **not** breaks:
-
-- **`.like()` / `["like", …]`** already renders as `ILIKE` on PostgreSQL — not a
-  case-sensitivity bug. *(Exception: `.like()` on a **non-text** column — `idx`, `docstatus` —
-  is a hard break, `bigint ILIKE`; see §1.)*
-- **Raw `ifnull(...)`** inside `frappe.db.sql()` is rewritten to `coalesce(...)` on all engines.
-- **Backticks**, **`LOCATE`**, **`REGEXP`** / **`.regexp()`** in raw SQL are auto-translated on
-  PostgreSQL (`REGEXP` → `~*`). **But `RLIKE` / `.rlike()` is NOT translated** — that one is a
-  hard break (see §1).
-- **An `ORDER BY … LIMIT 1` tie where the two engines already agree**, or where adding a
-  tiebreaker would *change* MariaDB's current pick — leave it; "fixing" it would either change
-  MariaDB or has no observable effect.
-
----
-
-## 5. Transaction / runtime (not query-shape, still PostgreSQL-only)
-
-- **Catch-and-continue inserts** — on PostgreSQL a failed `insert()` aborts the **whole
-  transaction**, so code that swallows a duplicate and keeps going dies on the next statement
-  with `InFailedSqlTransaction` (frappe dropped its blanket per-statement savepoint in
-  frappe#40075). Such a handler must wrap the fallible insert in `frappe.db.savepoint(name)` +
-  `rollback(save_point=name)` — unless it re-`throw`s with no DB call before the throw, or the
-  insert uses `ignore_if_duplicate=True` / `autoname="hash"` (→ `ON CONFLICT DO NOTHING`).
-- **Recover the txn with a *scoped* savepoint, not a full `frappe.db.rollback()`, if any prior work
-  must survive.** A full rollback un-poisons the txn but also discards every row the handler committed
-  *before* the failure — which MariaDB kept (it has no statement-abort), so it's a **silent MariaDB
-  regression**. **"The background job / whitelist entrypoint owns the txn" does NOT make a full rollback
-  safe** if it did multiple inserts in a loop first — it drops the partial results MariaDB retained. A
-  full rollback is safe only when it (a) immediately re-`throw`s/`raise`s (MariaDB rolls back anyway),
-  (b) has nothing successful before it (a single op), or (c) the batch is genuinely meant to be
-  **atomic** (a partial result is an invalid state → rollback + mark *Failed* is correct). Otherwise use
-  a **per-iteration / per-record savepoint** — and keep the function's success/`None` return contract:
-  do **not** return the doc when the savepoint was rolled back.
-
----
-
-## 6. Refactors and raw-SQL→ORM conversions are not automatically 1:1
-
-A commit labeled a **refactor** or a **raw-`frappe.db.sql` → `frappe.qb`/ORM conversion** is meant
-to preserve behaviour — but it easily doesn't, and the change passes the static checker and a
-one-engine green run. **Diff the `WHERE`/predicate, the `JOIN`/`ON` conditions, and the resulting
-row set — not just the `SELECT` shape.** A conversion that silently widens or narrows the filter
-changes the rows touched on **both** engines and is a regression hiding under a "refactor" label.
-
-Real example: an `UPDATE` whose bound was `posting_datetime > X` gained an
-`OR (posting_datetime == X AND creation > args.creation)` branch during a "`sql` → `qb` refactor",
-widening the rows updated on both engines. Even when such a change is a deliberate bug-fix it must
-be called out and tested — it is **not** the no-op the refactor label implies. Confirm the
-converted query touches exactly the same rows with the same values MariaDB produced before.
-
----
-
-## How to review
-
-For every changed query: does it (a) use a construct from §1 (would error on PostgreSQL),
-(b) match a divergence in §2/§3 (different result across engines), or (c) change the row set under
-a refactor/conversion label (§6)? If so, comment with the
-portable fix and confirm it leaves **MariaDB output unchanged**. Skip the §4 false positives.
-Prefer a comment that names the rule (e.g. "loose GROUP BY — Max()-wrap, don't add to GROUP BY:
-splits the row count") so the fix is unambiguous.
-
-The static pre-commit checker (`.github/helper/postgres_compat.py`) catches the *mechanical*
-§1 breaks; the **semantic** §2/§3 divergences and the §6 refactor/conversion row-set changes are
-exactly what a reviewer (and this guide) must cover, because no static check can see them.

.github/helper/hydrate.sh

@@ -1,72 +0,0 @@
-#!/bin/bash
-#
-# Hydrate a test shard from the setup job's artifact.
-#
-# The bench (apps, venv, node_modules, sites) is already on disk at ~/frappe-bench — the
-# workflow untar'd it from the artifact the setup job built. So there is NO bench init, no
-# asset build, and no reinstall here: just bring the DB up on the baked datadir and start redis
-# so tests can run. The whole point is that the expensive work happened ONCE in the setup job.
-#
-set -e
-
-ci_user="${ERPNEXT_CI_USER:-frappe}"
-db_host="${DB_HOST:-127.0.0.1}"
-
-# Re-exec as the ci user (uid 1001) so bench/cache ownership matches the artifact, same as
-# install.sh. The workflow untar'd as root with -p, so the files are already owned by ci.
-if [ "$(id -u)" = "0" ] && [ "${SKIP_SYSTEM_SETUP:-0}" = "1" ] && [ "$ci_user" != "root" ]; then
-    exec su -m "$ci_user" -s /bin/bash -c \
-        "ERPNEXT_CI_USER='$ci_user' DB_HOST='$db_host' DB='${DB:-}' bash '$0'"
-fi
-
-cd ~/frappe-bench
-
-# Start the DB on the datadir baked into the artifact. It's already populated (the setup job
-# reinstalled into this very datadir), so there is NO restore — the server comes up on the
-# existing files. This is what replaces the per-shard SQL replay.
-bash ~/frappe-bench/start-db.sh
-
-# Bring up redis (lightmode unit tests need cache + queue). In the self-hosted container we use the
-# full `bench start` (web/workers too, like install.sh). On the bare GitHub Postgres shard
-# `bench start` (honcho) lagged — it blocks the redis procs behind web/worker procs the lightmode
-# suite never uses, so the wait below burned its full timeout (~4m). There, start the two redis
-# instances directly: fast and deterministic.
-if [ "${DB:-mariadb}" = "postgres" ]; then
-    # Start redis directly as daemons — reliable and persists across steps. Do NOT route it through
-    # `bench start`: honcho tears the whole process group down if any one Procfile proc dies on the
-    # bare shard, which took redis with it (redis @ 13000 refused in Run Tests). Keeping redis
-    # independent is what makes it survive. The web server (for PDF tests) is NOT started here — a
-    # backgrounded server doesn't survive into the next step; it's started inside the Run Tests step.
-    for conf in redis_cache redis_queue; do
-        [ -f ~/frappe-bench/config/$conf.conf ] && redis-server ~/frappe-bench/config/$conf.conf --daemonize yes
-    done
-else
-    bench start >> ~/frappe-bench/bench_start.log 2>&1 &
-fi
-
-# Wait for redis, failing fast instead of silently burning minutes if it never comes up.
-cfg=~/frappe-bench/sites/common_site_config.json
-if [ -f "$cfg" ]; then
-    ports=$(python - "$cfg" <<'PY'
-import json, re, sys
-try:
-    cfg = json.load(open(sys.argv[1]))
-except Exception:
-    sys.exit(0)
-for key in ("redis_cache", "redis_queue"):
-    m = re.search(r":(\d+)", str(cfg.get(key, "")))
-    if m:
-        print(m.group(1))
-PY
-)
-    for port in $ports; do
-        up=0
-        for _ in $(seq 1 60); do
-            if (exec 3<>"/dev/tcp/127.0.0.1/$port") 2>/dev/null; then exec 3>&- 3<&-; up=1; break; fi
-            sleep 1
-        done
-        [ "$up" = "1" ] || { echo "redis did not come up on port $port"; exit 1; }
-    done
-fi
-
-echo "Hydrated: DB up on baked datadir, redis up — ready for tests."

.github/helper/install.sh

@@ -7,106 +7,21 @@ cd ~ || exit
 githubbranch=${GITHUB_BASE_REF:-${GITHUB_REF##*/}}
 frappeuser=${FRAPPE_USER:-"frappe"}
 frappecommitish=${FRAPPE_BRANCH:-$githubbranch}
-db_host=${DB_HOST:-"127.0.0.1"}
-db_user_host=${DB_USER_HOST:-"localhost"}
-wkhtmltox_deb=${WKHTMLTOX_DEB:-"/tmp/wkhtmltox.deb"}
-bench_cache_dir=${BENCH_CACHE_DIR:-}
-
-run_as_ci_user_if_needed() {
-    if [ "$(id -u)" != "0" ] || [ "${SKIP_SYSTEM_SETUP:-0}" != "1" ] || [ "${ERPNEXT_CI_NON_ROOT:-0}" = "1" ]; then
-        return
-    fi
-
-    local missing_packages=()
-    if ! command -v pkg-config >/dev/null 2>&1; then
-        missing_packages+=("pkg-config")
-    fi
-    if ! command -v mariadb_config >/dev/null 2>&1 && ! command -v mysql_config >/dev/null 2>&1; then
-        missing_packages+=("libmariadb-dev")
-    fi
-    if ! command -v crontab >/dev/null 2>&1; then
-        missing_packages+=("cron")
-    fi
-
-    if [ "${#missing_packages[@]}" -gt 0 ]; then
-        apt-get update
-        apt-get install -y --no-install-recommends "${missing_packages[@]}"
-    fi
-
-    local ci_user="${ERPNEXT_CI_USER:-frappe}"
-
-    if ! id "$ci_user" >/dev/null 2>&1; then
-        useradd --home-dir "$HOME" --no-create-home --shell /bin/bash "$ci_user"
-    fi
-
-    rm -rf ~/frappe ~/frappe-bench
-
-    local ci_dirs=(
-        "$HOME"
-        "$GITHUB_WORKSPACE"
-        "$HOME/.cache"
-        "${PIP_CACHE_DIR:-$HOME/.cache/pip}"
-        "${npm_config_cache:-$HOME/.npm}"
-        "${YARN_CACHE_FOLDER:-$HOME/.cache/yarn}"
-        "$HOME/.yarn"
-        "${UV_CACHE_DIR:-$HOME/.cache/uv}"
-        "$(dirname "$wkhtmltox_deb")"
-    )
-    if [ -n "$bench_cache_dir" ]; then
-        ci_dirs+=("$bench_cache_dir")
-    fi
-
-    # Create + own (non-recursively) the home/cache/workspace dirs before dropping to
-    # the ci user. We deliberately do NOT wipe the yarn/uv caches here so a persistent
-    # cache (mounted volume or baked image layer) stays warm across runs.
-    mkdir -p "${ci_dirs[@]}" "$HOME/.yarn"
-    chown "$ci_user:$ci_user" "${ci_dirs[@]}" "$HOME/.yarn"
-
-    export ERPNEXT_CI_NON_ROOT=1
-    exec su -m "$ci_user" -s /bin/bash -c "cd '$HOME' && bash '$GITHUB_WORKSPACE/.github/helper/install.sh'"
-}
-
-run_as_ci_user_if_needed
-
-run_ci_step() {
-    local label=$1
-    shift
-
-    echo "::group::${label}"
-    date -u
-    local exit_code=0
-    timeout --foreground "${CI_INSTALL_STEP_TIMEOUT:-1800}" "$@" || exit_code=$?
-    date -u
-    echo "::endgroup::"
-    return "$exit_code"
-}
-
-if [ -n "${GITHUB_WORKSPACE:-}" ]; then
-    git config --global --add safe.directory "$GITHUB_WORKSPACE" || true
-    git config --global --add safe.directory "$GITHUB_WORKSPACE/.git" || true
-fi
-
-rm -rf ~/frappe ~/frappe-bench
 
 # ---------------------------------------------------------------------------
 # Phase 1 — parallelise the three slow, independent setup steps:
 #   a) system packages   b) frappe-bench pip install   c) frappe git fetch
 # ---------------------------------------------------------------------------
 
-if [ "${SKIP_SYSTEM_SETUP:-0}" != "1" ]; then
-    sudo apt-get update
+sudo apt update
 
-    # apt remove/install must run sequentially but can overlap with pip and git.
-    sudo apt-get remove -y mysql-server mysql-client
-    sudo apt-get install -y libcups2-dev redis-server mariadb-client libmariadb-dev &
-    apt_pid=$!
+# apt remove/install must run sequentially but can overlap with pip and git.
+sudo apt remove mysql-server mysql-client
+sudo apt install libcups2-dev redis-server mariadb-client libmariadb-dev &
+apt_pid=$!
 
-    pip install frappe-bench &
-    pip_pid=$!
-else
-    apt_pid=
-    pip_pid=
-fi
+pip install frappe-bench &
+pip_pid=$!
 
 mkdir frappe
 (
@@ -117,243 +32,76 @@ mkdir frappe
 ) &
 clone_pid=$!
 
-if [ -n "$apt_pid" ]; then wait $apt_pid; fi
-if [ -n "$pip_pid" ]; then wait $pip_pid; fi
+wait $apt_pid
+wait $pip_pid
 wait $clone_pid
 
 pushd frappe
 git checkout FETCH_HEAD
 popd
-frappe_sha=$(git -C frappe rev-parse HEAD)
-
-get_bench_cache_archive() {
-    if [ -z "$bench_cache_dir" ]; then
-        return
-    fi
-
-    mkdir -p "$bench_cache_dir"
-
-    # Keyed on tool versions only (NOT the frappe SHA): any recent base bench works, because
-    # restore_warm_bench fast-forwards it to the exact live develop SHA. This is what lets a
-    # constantly-moving develop still hit the cache.
-    local cache_key
-    cache_key=$(
-        {
-            uname -m
-            python --version
-            node --version
-            bench --version
-        } | sha256sum | awk '{print $1}'
-    )
-
-    echo "${bench_cache_dir}/frappe-bench-base-${cache_key}.tar.zst"
-}
-
-restore_warm_bench() {
-    bench_cache_archive=$(get_bench_cache_archive)
-    [ -n "$bench_cache_archive" ] && [ -f "$bench_cache_archive" ] || return 1
-
-    echo "Restoring base bench from ${bench_cache_archive}"
-    tar --use-compress-program=unzstd -xf "$bench_cache_archive" -C ~ || return 1
-    [ -d ~/frappe-bench/apps/frappe/.git ] || return 1
-    mkdir -p ~/frappe-bench/sites ~/frappe-bench/logs
-    [ -f ~/frappe-bench/sites/apps.txt ] || printf "frappe\n" > ~/frappe-bench/sites/apps.txt
-    [ -f ~/frappe-bench/sites/common_site_config.json ] || printf "{}\n" > ~/frappe-bench/sites/common_site_config.json
-
-    # Fast-forward the restored frappe to the EXACT live develop SHA fetched in phase 1, then
-    # rebuild only what changed. The editable install means the venv tracks the new code with
-    # no reinstall. Any failure returns non-zero so the caller falls back to a full bench init.
-    if ! (
-        cd ~/frappe-bench/apps/frappe || exit 1
-        # Phase 1 already fetched ~/frappe to the exact live develop SHA. Fetch that commit
-        # straight from it (bench init names the remote 'upstream', not 'origin', and points
-        # it at this local clone — so a plain `git fetch origin` does not work).
-        git fetch --no-tags "$HOME/frappe" HEAD || exit 1
-        git checkout --force FETCH_HEAD || exit 1
-    ); then
-        echo "Fast-forward to ${frappe_sha} failed; falling back to full init"
-        rm -rf ~/frappe-bench
-        return 1
-    fi
-
-    # Pick up any frappe dependency changes since the base was built (cached → fast if none),
-    # so a develop commit that bumped requirements doesn't leave a stale venv.
-    if ! ~/frappe-bench/env/bin/python -m pip install -q -e ~/frappe-bench/apps/frappe; then
-        echo "frappe dependency refresh failed; falling back to full init"
-        rm -rf ~/frappe-bench
-        return 1
-    fi
-
-    ( cd ~/frappe-bench && CI=Yes bench build --app frappe ) || { rm -rf ~/frappe-bench; return 1; }
-    return 0
-}
-
-save_warm_bench() {
-    if [ -z "${bench_cache_archive:-}" ] || [ -f "$bench_cache_archive" ]; then
-        return
-    fi
-
-    if [ -n "$bench_cache_dir" ] && [ ! -w "$bench_cache_dir" ]; then
-        echo "Skipping warm bench save because ${bench_cache_dir} is not writable"
-        return
-    fi
-
-    local tmp_archive
-    tmp_archive="${bench_cache_archive}.${$}.tmp"
-
-    echo "Saving warm bench to ${bench_cache_archive}"
-    # Keep sites/common_site_config.json (the redis ports live there — dropping it makes the
-    # restore path fall back to a default redis port that bench start never bound, so reinstall
-    # fails with "redis ... connection refused"). Only the rebuildable sites/assets is excluded;
-    # restore_warm_bench runs `bench build` to regenerate it.
-    tar \
-        --use-compress-program="zstd -T0 -3" \
-        --exclude="frappe-bench/logs" \
-        --exclude="frappe-bench/sites/assets" \
-        -cf "$tmp_archive" \
-        -C ~ frappe-bench
-    mv "$tmp_archive" "$bench_cache_archive"
-}
 
 # ---------------------------------------------------------------------------
 # Phase 2 — bench init and site setup
 # ---------------------------------------------------------------------------
 
-install_whktml() {
-    # Re-use the .deb if the wkhtmltopdf cache step already restored it.
-    if [ ! -f "$wkhtmltox_deb" ]; then
-        wget -O "$wkhtmltox_deb" https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
-    fi
-    sudo apt-get install -y "$wkhtmltox_deb"
-}
-if [ "${SKIP_WKHTMLTOX_SETUP:-0}" != "1" ]; then
-    install_whktml &
-    wkpid=$!
-else
-    wkpid=
-fi
+bench init --skip-assets --frappe-path ~/frappe --python "$(which python)" frappe-bench
 
-if ! restore_warm_bench; then
-    bench init --skip-assets --frappe-path ~/frappe --python "$(which python)" frappe-bench
-
-    cd ~/frappe-bench || exit
-
-    sed -i 's/watch:/# watch:/g' Procfile
-    sed -i 's/schedule:/# schedule:/g' Procfile
-    sed -i 's/socketio:/# socketio:/g' Procfile
-    sed -i 's/redis_socketio:/# redis_socketio:/g' Procfile
-
-    CI=Yes bench build --app frappe
-    save_warm_bench
-fi
-
-if [ -n "$wkpid" ]; then wait $wkpid; fi
-
-mkdir -p ~/frappe-bench/sites/test_site
+mkdir ~/frappe-bench/sites/test_site
 
 if [ "$DB" == "mariadb" ];then
     cp -r "${GITHUB_WORKSPACE}/.github/helper/site_config_mariadb.json" ~/frappe-bench/sites/test_site/site_config.json
-    if [ "$db_host" != "127.0.0.1" ]; then
-        sed -i "s/\"db_host\": \"127.0.0.1\"/\"db_host\": \"${db_host}\"/" ~/frappe-bench/sites/test_site/site_config.json
-    fi
 else
     cp -r "${GITHUB_WORKSPACE}/.github/helper/site_config_postgres.json" ~/frappe-bench/sites/test_site/site_config.json
 fi
 
 
 if [ "$DB" == "mariadb" ];then
-    for _ in {1..60}; do
-        if mariadb-admin ping --host "$db_host" --port 3306 -u root -proot --silent; then
-            break
-        fi
-        sleep 1
-    done
-    mariadb-admin ping --host "$db_host" --port 3306 -u root -proot --silent
+    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL character_set_server = 'utf8mb4'"
+    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL collation_server = 'utf8mb4_unicode_ci'"
 
-    mariadb --host "$db_host" --port 3306 -u root -proot -e "SET GLOBAL character_set_server = 'utf8mb4'"
-    mariadb --host "$db_host" --port 3306 -u root -proot -e "SET GLOBAL collation_server = 'utf8mb4_unicode_ci'"
-
-    # Throwaway-DB durability tuning at runtime. (innodb_doublewrite is read-only on MariaDB
-    # 10.6, so it can't be disabled here — would need a server startup flag.)
-    mariadb --host "$db_host" --port 3306 -u root -proot \
+    # Belt-and-suspenders: also set performance variables at runtime in case
+    # MARIADB_EXTRA_FLAGS was not honoured by the container image.
+    mariadb --host 127.0.0.1 --port 3306 -u root -proot \
         -e "SET GLOBAL innodb_flush_log_at_trx_commit=0; SET GLOBAL sync_binlog=0;"
 
-    # Opt-in DDL speedup: a shared tablespace avoids a create+fsync per DocType table during
-    # reinstall — a big win under disk contention. But ROW_FORMAT=DYNAMIC must be accepted in
-    # the system tablespace on this MariaDB. Enable with CI_INNODB_SHARED_TABLESPACE=1; if
-    # reinstall then errors on table creation, unset it (off by default — zero risk).
-    if [ "${CI_INNODB_SHARED_TABLESPACE:-0}" = "1" ]; then
-        mariadb --host "$db_host" --port 3306 -u root -proot -e "SET GLOBAL innodb_file_per_table=0;"
-    fi
+    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE USER 'test_frappe'@'localhost' IDENTIFIED BY 'test_frappe'"
+    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE DATABASE test_frappe"
+    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "GRANT ALL PRIVILEGES ON \`test_frappe\`.* TO 'test_frappe'@'localhost'"
 
-    mariadb --host "$db_host" --port 3306 -u root -proot -e "CREATE USER 'test_frappe'@'${db_user_host}' IDENTIFIED BY 'test_frappe'"
-    mariadb --host "$db_host" --port 3306 -u root -proot -e "CREATE DATABASE test_frappe"
-    mariadb --host "$db_host" --port 3306 -u root -proot -e "GRANT ALL PRIVILEGES ON \`test_frappe\`.* TO 'test_frappe'@'${db_user_host}'"
-
-    mariadb --host "$db_host" --port 3306 -u root -proot -e "FLUSH PRIVILEGES"
+    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "FLUSH PRIVILEGES"
 fi
 
 if [ "$DB" == "postgres" ];then
     echo "travis" | psql -h 127.0.0.1 -p 5432 -c "CREATE DATABASE test_frappe" -U postgres;
     echo "travis" | psql -h 127.0.0.1 -p 5432 -c "CREATE USER test_frappe WITH PASSWORD 'test_frappe'" -U postgres;
-
-    # Durability-off for speed (no fsync/synchronous_commit/full_page_writes) is applied by
-    # start-db.sh's postgres `-o` flags on every start — setup job AND each test shard — so it is
-    # NOT repeated here. The postgres workflow runs in-runner via start-db.sh, not a service
-    # container.
 fi
 
+
+install_whktml() {
+    # Re-use the .deb if the wkhtmltopdf cache step already restored it.
+    if [ ! -f /tmp/wkhtmltox.deb ]; then
+        wget -O /tmp/wkhtmltox.deb https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
+    fi
+    sudo apt install /tmp/wkhtmltox.deb
+}
+install_whktml &
+wkpid=$!
+
+
 cd ~/frappe-bench || exit
 
-run_ci_step "Get payments app" bench get-app payments --branch develop
+sed -i 's/watch:/# watch:/g' Procfile
+sed -i 's/schedule:/# schedule:/g' Procfile
+sed -i 's/socketio:/# socketio:/g' Procfile
+sed -i 's/redis_socketio:/# redis_socketio:/g' Procfile
 
-# Opt-in: skip building erpnext's frontend assets. Server tests don't need them, but PDF
-# tests (print formats) do — they pass only if the PDF renderer ignores missing assets.
-# Enable with CI_SKIP_ERPNEXT_ASSETS=1 to test; if PDF tests fail, unset it.
-erpnext_get_app_args=()
-if [ "${CI_SKIP_ERPNEXT_ASSETS:-0}" = "1" ]; then erpnext_get_app_args=(--skip-assets); fi
-run_ci_step "Get erpnext app" bench get-app erpnext "${GITHUB_WORKSPACE}" "${erpnext_get_app_args[@]}"
+bench get-app payments --branch develop
+bench get-app erpnext "${GITHUB_WORKSPACE}"
 
-if [ "$TYPE" == "server" ]; then run_ci_step "Setup dev requirements" bench setup requirements --dev; fi
+if [ "$TYPE" == "server" ]; then bench setup requirements --dev; fi
 
-bench start >> ~/frappe-bench/bench_start.log 2>&1 &
+wait $wkpid
 
-# Under heavy concurrency, gunicorn's startup can delay redis coming up. reinstall and the
-# tests need redis, so wait for it (best-effort, bounded) instead of racing — contention
-# then slows the job rather than failing it.
-wait_for_redis() {
-    local cfg=~/frappe-bench/sites/common_site_config.json
-    [ -f "$cfg" ] || return 0
-    local ports port
-    ports=$(python - "$cfg" <<'PY'
-import json, re, sys
-try:
-    cfg = json.load(open(sys.argv[1]))
-except Exception:
-    sys.exit(0)
-for key in ("redis_cache", "redis_queue"):
-    match = re.search(r":(\d+)", str(cfg.get(key, "")))
-    if match:
-        print(match.group(1))
-PY
-)
-    for port in $ports; do
-        local up=0
-        for _ in $(seq 1 120); do
-            if (exec 3<>"/dev/tcp/127.0.0.1/$port") 2>/dev/null; then
-                exec 3>&- 3<&-; up=1
-                break
-            fi
-            sleep 1
-        done
-        # Fail clearly instead of letting reinstall die later on a vague socket-connection error
-        # when redis never bound.
-        [ "$up" = "1" ] || { echo "redis did not come up on port $port"; return 1; }
-    done
-}
-wait_for_redis
-
-# Site setup: build the schema (~1000 DocTypes) into the DB. This is the single-threaded-Python
-# bottleneck, but the fan-out amortises it — it runs once here in the setup job, and the test
-# shards start the DB on the baked datadir instead of repeating the reinstall.
-run_ci_step "Reinstall test site" bench --site test_site reinstall --yes
+bench start &>> ~/frappe-bench/bench_start.log &
+CI=Yes bench build --app frappe &
+bench --site test_site reinstall --yes

.github/helper/postgres_compat.py

@@ -1,241 +0,0 @@
-#!/usr/bin/env python3
-"""Static guard against MySQL-only SQL that breaks on PostgreSQL.
-
-The Postgres test job is label-gated, so it does not run on every PR. This pre-commit
-hook is the always-on first line of defence: it flags the *mechanical* Postgres breaks
-that static analysis can catch reliably with a low false-positive rate.
-
-It deliberately does NOT try to catch the *semantic* divergences (loose GROUP BY,
-case-sensitive ==/IN, NULL ordering, ORDER BY ... LIMIT 1 tiebreakers, integer-division
-intent, division by a possibly-zero divisor, savepoint discipline) — those genuinely need
-the test suite or a human/Greptile reviewer. Run the full suite on a Postgres site for those.
-
-Escape hatch: put `# pg-ok` anywhere on the offending statement's line span (e.g. on a
-`SHOW INDEX` query that lives inside an `if frappe.db.db_type == "mariadb":` branch).
-
-Usage: postgres_compat.py <file.py> [<file.py> ...]   (pre-commit passes staged files)
-"""
-
-from __future__ import annotations
-
-import ast
-import re
-import sys
-
-IGNORE = "pg-ok"
-
-# Strings are only scanned for the patterns below when they have real SQL *structure*
-# (not just an English word like "select" or "from"), to keep false positives near zero.
-SQL_HINT = re.compile(
-	r"\bselect\b[\s\S]{0,800}\bfrom\b"        # SELECT ... FROM
-	r"|\bupdate\b[\s\S]{0,400}\bset\b"         # UPDATE ... SET
-	r"|\bdelete\s+from\b"
-	r"|\binsert\s+into\b"
-	r"|\bshow\s+(?:index|tables|columns)\b"
-	r"|\bfrom\s+[\"'`]?tab",                   # FROM `tabDocType`
-	re.I,
-)
-
-# MySQL-only constructs with NO frappe auto-translation. (frappe.db.sql already rewrites
-# ifnull->coalesce on all engines and backtick/locate/REGEXP on Postgres, and .like()
-# renders ILIKE — so those are NOT listed here; flagging them would be false positives.)
-SQL_PATTERNS: list[tuple[re.Pattern, str]] = [
-	(re.compile(r"\btimestamp\s*\(\s*[^,()]+,", re.I),
-	 "timestamp(date, time) is MySQL-only -> use CombineDatetime() or a precomputed datetime column"),
-	(re.compile(r"\btimediff\s*\(", re.I),
-	 "timediff() is MySQL-only -> compute the delta in Python"),
-	(re.compile(r"\bstr_to_date\s*\(", re.I),
-	 "str_to_date() is MySQL-only -> parse in Python and pass a real date"),
-	(re.compile(r"\bdate_format\s*\(", re.I),
-	 "date_format() is MySQL-only -> filter on a date range instead"),
-	(re.compile(r"\bdate_(add|sub)\s*\(", re.I),
-	 "date_add()/date_sub() are MySQL-only -> use Python date math or interval arithmetic"),
-	(re.compile(r"\bgroup_concat\s*\(", re.I),
-	 "group_concat() is MySQL-only -> use GroupConcat (string_agg) or aggregate in Python"),
-	(re.compile(r"\bperiod_diff\s*\(", re.I),
-	 "period_diff() is MySQL-only -> compute in Python"),
-	(re.compile(r"\bshow\s+index\b", re.I),
-	 "SHOW INDEX is MySQL-only -> use frappe.db.has_index() / get_column_index()"),
-	(re.compile(r"\bshow\s+(tables|columns)\b", re.I),
-	 "SHOW TABLES/COLUMNS is MySQL-only -> use frappe.db.get_tables()/table_columns / information-schema helpers"),
-	(re.compile(r"\bas\s+'[^']+'", re.I),
-	 "single-quoted column alias breaks on Postgres -> use a bare or double-quoted alias"),
-	(re.compile(r"\bif\s*\(", re.I),
-	 "SQL IF() is MySQL-only -> use CASE WHEN ... THEN ... ELSE ... END (frappe.qb.Case())"),
-	(re.compile(r"\brlike\b", re.I),
-	 "RLIKE is MySQL-only -> frappe rewrites REGEXP->~* on Postgres but NOT RLIKE; use REGEXP / .regexp() / ~"),
-	(re.compile(r"\bcast\s*\(.+?\bas\s+char\b", re.I | re.S),  # .+? spans nested parens, e.g. CAST(ABS(x) AS CHAR)
-	 "CAST(... AS CHAR) is character(1) on Postgres and truncates -> CAST AS VARCHAR (frappe Cast_(x, 'varchar'))"),
-]
-
-# UPDATE ... JOIN: both keywords in the same SQL string.
-UPDATE_JOIN = (re.compile(r"\bupdate\b", re.I), re.compile(r"\bjoin\b", re.I))
-
-MYSQL_RESULT_KEYS = {"Column_name", "Key_name", "Seq_in_index", "Non_unique", "Index_type"}
-
-SET_BOOL_FUNCS = {"set_value", "db_set"}
-
-# query-builder cast helpers: pypika Cast / frappe Cast_. A "char" target type is character(1)
-# on Postgres (truncates); "varchar" is the full-length cast.
-CAST_FUNCS = {"Cast", "Cast_"}
-
-# frappe.get_all / get_list: frappe's db_query SILENTLY drops ORDER BY for `distinct` queries on
-# Postgres (the ORDER BY column must appear in the SELECT-DISTINCT list), so `distinct=True` together
-# with a literal `order_by` is a no-op on PG and the result comes back unordered.
-DISTINCT_ORDER_FUNCS = {"get_all", "get_list"}
-
-
-def _docstring_ids(tree: ast.AST) -> set[int]:
-	"""ids of Constant nodes that are docstrings (so prose describing the rules isn't flagged)."""
-	ids: set[int] = set()
-	for node in ast.walk(tree):
-		if isinstance(node, (ast.Module, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-			body = getattr(node, "body", None)
-			if body and isinstance(body[0], ast.Expr) and isinstance(body[0].value, ast.Constant) and isinstance(body[0].value.value, str):
-				ids.add(id(body[0].value))
-	return ids
-
-
-class Visitor(ast.NodeVisitor):
-	def __init__(self, lines: list[str], docstrings: set[int]):
-		self.lines = lines
-		self.docstrings = docstrings
-		self.violations: list[tuple[int, str]] = []
-
-	def _ignored(self, node: ast.AST) -> bool:
-		start = getattr(node, "lineno", 1)
-		end = getattr(node, "end_lineno", start) or start
-		# honour `# pg-ok` anywhere on the node's line span, the line just above (the enclosing
-		# call, e.g. `frappe.db.sql(  # pg-ok`), or the line just below (a multi-line call's `)  # pg-ok`).
-		lo = max(0, start - 2)
-		return any(IGNORE in self.lines[i] for i in range(lo, min(end + 1, len(self.lines))))
-
-	def _flag(self, node: ast.AST, msg: str) -> None:
-		if not self._ignored(node):
-			self.violations.append((getattr(node, "lineno", 1), msg))
-
-	def _scan_sql(self, text: str, node: ast.AST) -> None:
-		if not SQL_HINT.search(text):
-			return
-		for pattern, msg in SQL_PATTERNS:
-			if pattern.search(text):
-				self._flag(node, msg)
-		if UPDATE_JOIN[0].search(text) and UPDATE_JOIN[1].search(text):
-			self._flag(node, "UPDATE ... JOIN is MySQL-only -> use a correlated subquery (WHERE ... IN/EXISTS)")
-
-	def visit_Constant(self, node: ast.Constant) -> None:
-		# plain string literals, incl. `"...".format()` and `"..." % (...)` templates
-		if isinstance(node.value, str) and id(node) not in self.docstrings:
-			self._scan_sql(node.value, node)
-		self.generic_visit(node)
-
-	def visit_JoinedStr(self, node: ast.JoinedStr) -> None:
-		# f-string: scan its STATIC text (interpolated values become a placeholder) so MySQL-isms
-		# in dynamic SQL are caught, without flagging safe interpolation of identifiers.
-		text = "".join(
-			v.value if isinstance(v, ast.Constant) and isinstance(v.value, str) else " ? "
-			for v in node.values
-		)
-		self._scan_sql(text, node)
-		# don't recurse: child literal chunks would otherwise be re-scanned individually
-
-	def visit_Call(self, node: ast.Call) -> None:
-		fn = node.func
-		name = fn.attr if isinstance(fn, ast.Attribute) else (fn.id if isinstance(fn, ast.Name) else "")
-
-		# row.get("Column_name") — MySQL SHOW INDEX result key
-		if name == "get" and node.args and isinstance(node.args[0], ast.Constant) and node.args[0].value in MYSQL_RESULT_KEYS:
-			self._flag(node, f'"{node.args[0].value}" is a MySQL SHOW INDEX result key -> use frappe.db.has_index()/get_column_index()')
-
-		# set_value(..., True) / db_set("field", True) on a Check (int) column.
-		# Only the field *value* arg carries bool->smallint risk — NOT trailing flags like
-		# update_modified. db_set(field, value, update_modified, ...) -> value at args[1] (or a dict
-		# at args[0]); set_value(dt, dn, field, value, ...) -> value at args[3] (or a dict at args[2]).
-		if name in SET_BOOL_FUNCS:
-			value_idx, dict_idx = (1, 0) if name == "db_set" else (3, 2)
-			dict_arg = (
-				node.args[dict_idx]
-				if len(node.args) > dict_idx and isinstance(node.args[dict_idx], ast.Dict)
-				else None
-			)
-			if dict_arg is not None:
-				for v in dict_arg.values:
-					if isinstance(v, ast.Constant) and isinstance(v.value, bool):
-						self._flag(node, f"{name}(...) sets an int/Check column with a bool in a dict -> pass 1/0 (Postgres rejects bool->smallint)")
-			elif len(node.args) > value_idx:
-				a = node.args[value_idx]
-				if isinstance(a, ast.Constant) and isinstance(a.value, bool):
-					self._flag(node, f"{name}(..., {a.value}) sets an int/Check column with a bool -> pass 1/0 (Postgres rejects bool->smallint)")
-
-		# frappe.get_all/get_list(..., distinct=True, order_by="<col>") -> ORDER BY is silently dropped
-		# for distinct queries on Postgres, so the result is unordered there. Sort in python instead
-		# (e.g. sorted(frappe.get_all(..., distinct=True), key=str.casefold)). An empty order_by="" (the
-		# explicit "suppress the injected default" idiom) and a dynamic/variable order_by are not flagged.
-		if name in DISTINCT_ORDER_FUNCS:
-			has_distinct = any(
-				kw.arg == "distinct" and isinstance(kw.value, ast.Constant) and kw.value.value
-				for kw in node.keywords
-			)
-			order_kw = next((kw for kw in node.keywords if kw.arg == "order_by"), None)
-			has_literal_order = (
-				order_kw is not None
-				and isinstance(order_kw.value, ast.Constant)
-				and isinstance(order_kw.value.value, str)
-				and order_kw.value.value.strip()
-			)
-			if has_distinct and has_literal_order:
-				self._flag(node, f"{name}(distinct=True, order_by=...) -> frappe drops ORDER BY for distinct queries on Postgres; sort in python instead, e.g. sorted(..., key=str.casefold)")
-
-		# query-builder .rlike(...): pypika emits the MySQL-only RLIKE operator, which frappe does
-		# NOT translate for Postgres (it rewrites only REGEXP -> ~*).
-		if name == "rlike":
-			self._flag(node, ".rlike() emits MySQL-only RLIKE (not translated on Postgres) -> use .regexp() (rewritten to ~*) or .like()")
-
-		# Cast(col, "char") / Cast_(col, "char"): on Postgres a bare CHAR is character(1) and truncates
-		# (e.g. CAST(12 AS CHAR) -> '1'); use "varchar" for a full-length string cast.
-		if name in CAST_FUNCS:
-			for arg in (*node.args, *(kw.value for kw in node.keywords)):
-				if isinstance(arg, ast.Constant) and isinstance(arg.value, str) and arg.value.strip().lower() == "char":
-					self._flag(node, f"{name}(..., 'char') is character(1) on Postgres and truncates -> use 'varchar'")
-
-		self.generic_visit(node)
-
-	def visit_Subscript(self, node: ast.Subscript) -> None:
-		key = node.slice
-		if isinstance(key, ast.Constant) and key.value in MYSQL_RESULT_KEYS:
-			self._flag(node, f'"{key.value}" is a MySQL SHOW INDEX result key -> use frappe.db.has_index()/get_column_index()')
-		self.generic_visit(node)
-
-
-def check_file(path: str) -> list[str]:
-	try:
-		# nosemgrep: frappe-semgrep-rules.rules.security.frappe-security-file-traversal -- dev-only lint tool; `path` is a source file supplied by pre-commit, not user input
-		src = open(path, encoding="utf-8").read()
-	except (OSError, UnicodeDecodeError):
-		return []
-	try:
-		tree = ast.parse(src, filename=path)
-	except SyntaxError:
-		return []  # check-ast hook reports real syntax errors
-	v = Visitor(src.splitlines(), _docstring_ids(tree))
-	v.visit(tree)
-	return [f"{path}:{line}: [pg-compat] {msg}" for line, msg in sorted(set(v.violations))]
-
-
-def main(argv: list[str]) -> int:
-	out: list[str] = []
-	for path in argv:
-		if path.endswith(".py"):
-			out.extend(check_file(path))
-	if out:
-		print("\n".join(out))
-		print(
-			f"\n{len(out)} PostgreSQL-incompatibility issue(s). Fix them, or add `# pg-ok` to a "
-			"line that is intentionally MariaDB-only (e.g. inside an `if frappe.db.db_type == 'mariadb':` branch)."
-		)
-		return 1
-	return 0
-
-
-if __name__ == "__main__":
-	raise SystemExit(main(sys.argv[1:]))

.github/helper/site_config_postgres.json

@@ -13,6 +13,6 @@
  "root_login": "postgres",
  "root_password": "travis",
  "host_name": "http://test_site:8000",
- "install_apps": ["payments", "erpnext"],
+ "install_apps": ["erpnext"],
  "throttle_user_limit": 100
 }

.github/helper/start-db.sh

@@ -1,79 +0,0 @@
-#!/bin/bash
-#
-# Run MariaDB INSIDE the runner container, on a datadir we control. Because the datadir can be
-# packaged into the bench artifact, test shards start an already-loaded server instead of
-# replaying a SQL dump (the ~60s hydrate restore). Each shard gets its own copy → isolation kept.
-#
-# CI_DB_DATADIR picks the path:
-#   - setup job:  /home/ci/db-data  (OUTSIDE the bench, so install.sh's `rm -rf ~/frappe-bench`
-#                 doesn't wipe it; it's moved into the bench just before packaging)
-#   - test shard: ~/frappe-bench/mariadb-data  (where the artifact untar'd it)
-#
-# Idempotent: inits a fresh datadir if absent (setup), else starts on the existing one (shards).
-#
-set -e
-
-ci_user="${ERPNEXT_CI_USER:-frappe}"
-
-# Re-exec as the ci user so mariadbd and the datadir are owned consistently (root mariadbd is
-# refused anyway). Mirrors install.sh's user switch.
-if [ "$(id -u)" = "0" ] && [ "${SKIP_SYSTEM_SETUP:-0}" = "1" ] && [ "$ci_user" != "root" ]; then
-    exec su -m "$ci_user" -s /bin/bash -c \
-        "ERPNEXT_CI_USER='$ci_user' CI_DB_DATADIR='${CI_DB_DATADIR:-}' DB='${DB:-}' bash '$0'"
-fi
-
-# --- PostgreSQL (GitHub-hosted CI): run in-runner on a PGDATA so it bakes into the artifact,
-# same idea as the mariadb datadir. Trust auth (throwaway CI) skips password setup; durability
-# off for speed. Postgres is preinstalled on ubuntu-latest under /usr/lib/postgresql/<ver>/bin.
-if [ "${DB:-mariadb}" = "postgres" ]; then
-    PG_BIN=$(ls -d /usr/lib/postgresql/*/bin 2>/dev/null | sort -V | tail -1)
-    [ -n "$PG_BIN" ] && export PATH="$PG_BIN:$PATH"
-    PGDATA="${CI_DB_DATADIR:-$HOME/frappe-bench/pgdata}"
-    if [ ! -d "$PGDATA/base" ]; then
-        initdb -D "$PGDATA" -U postgres --auth-local=trust --auth-host=trust >/dev/null
-        echo "host all all 127.0.0.1/32 trust" >> "$PGDATA/pg_hba.conf"
-    fi
-    pg_ctl -D "$PGDATA" -w -o "-p 5432 -c listen_addresses=127.0.0.1 -c unix_socket_directories=$PGDATA -c fsync=off -c synchronous_commit=off -c full_page_writes=off" start
-    echo "PostgreSQL up in-runner (pgdata=$PGDATA)"
-    exit 0
-fi
-
-# --- MariaDB ---
-DATADIR="${CI_DB_DATADIR:-$HOME/frappe-bench/mariadb-data}"
-SOCK="$DATADIR/mysqld.sock"
-fresh=0
-
-if [ ! -d "$DATADIR/mysql" ]; then
-    mkdir -p "$DATADIR"
-    mariadb-install-db --no-defaults --datadir="$DATADIR" \
-        --auth-root-authentication-method=normal --skip-test-db >/dev/null 2>&1
-    fresh=1
-fi
-
-# Throwaway-CI durability off; bind TCP 127.0.0.1:3306 so bench/install.sh connect as usual.
-mariadbd --no-defaults --datadir="$DATADIR" --socket="$SOCK" --pid-file="$DATADIR/mysqld.pid" \
-    --port=3306 --bind-address=127.0.0.1 \
-    --innodb-flush-log-at-trx-commit=0 --sync-binlog=0 --skip-log-bin \
-    > "$HOME/mariadb.log" 2>&1 &
-
-up=0
-for _ in $(seq 1 60); do
-    if mariadb-admin --socket="$SOCK" ping --silent 2>/dev/null; then up=1; break; fi
-    sleep 1
-done
-# Fail loudly instead of letting the loop fall through (exit 0 of the last `sleep`) into SQL that
-# would error with a vague socket-connection failure.
-[ "$up" = "1" ] || { echo "mariadbd did not come up on $SOCK"; cat "$HOME/mariadb.log" 2>/dev/null; exit 1; }
-
-if [ "$fresh" = "1" ]; then
-    # A fresh datadir has only a password-less root@localhost. Give it the password install.sh
-    # uses, plus a TCP-reachable root@127.0.0.1, so the rest of install.sh works unchanged.
-    mariadb --no-defaults --socket="$SOCK" -u root <<'SQL'
-ALTER USER 'root'@'localhost' IDENTIFIED BY 'root';
-CREATE USER IF NOT EXISTS 'root'@'127.0.0.1' IDENTIFIED BY 'root';
-GRANT ALL PRIVILEGES ON *.* TO 'root'@'127.0.0.1' WITH GRANT OPTION;
-FLUSH PRIVILEGES;
-SQL
-fi
-
-echo "MariaDB up in-container (datadir=$DATADIR, fresh=$fresh)"

.github/workflows/linters.yml

@@ -21,7 +21,7 @@ jobs:
           cache: pip
 
       - name: Install and Run Pre-commit
-        uses: pre-commit/action@v3.0.1
+        uses: pre-commit/action@v3.0.0
 
   semgrep:
     name: semgrep

.github/workflows/patch.yml

@@ -65,22 +65,6 @@ jobs:
       - name: Add to Hosts
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
-      # The v14 baseline backup is a fixed published file — cache it instead of re-downloading
-      # it from the GitHub release every run.
-      - name: Cache erpnext v14 backup
-        id: cache-v14
-        uses: actions/cache@v4
-        with:
-          path: ~/erpnext-v14.sql.gz
-          key: erpnext-v14-sql-gz
-
-      - name: Download erpnext v14 backup
-        if: steps.cache-v14.outputs.cache-hit != 'true'
-        run: |
-          curl -fSL --retry 5 --retry-all-errors --retry-delay 5 \
-            -o ~/erpnext-v14.sql.gz \
-            https://github.com/frappe/erpnext/releases/download/v14-baseline/erpnext-v14.sql.gz
-
       - name: Cache pip
         uses: actions/cache@v4
         with:
@@ -129,20 +113,12 @@ jobs:
           jq 'del(.install_apps)' ~/frappe-bench/sites/test_site/site_config.json > tmp.json
           mv tmp.json ~/frappe-bench/sites/test_site/site_config.json
 
-          bench --site test_site --force restore ~/erpnext-v14.sql.gz
+          wget https://frappe.io/files/erpnext-v14.sql.gz
+          bench --site test_site --force restore ~/frappe-bench/erpnext-v14.sql.gz
 
           git -C "apps/frappe" remote set-url upstream https://github.com/frappe/frappe.git
           git -C "apps/erpnext" remote set-url upstream https://github.com/frappe/erpnext.git
 
-          # Start every bench process except the background workers. If workers run during a
-          # migrate, they pick up the orphan-link cleanup jobs it enqueues and race its schema
-          # changes, which fails with MySQL 1412 "Table definition has changed". Redis and the
-          # other services stay up; the queued jobs simply wait and are harmless here.
-          function start_bench_without_workers() {
-            local procs
-            procs=$(awk -F: '/^[a-z_]+:/ && $1 !~ /worker/ {print $1}' ~/frappe-bench/Procfile)
-            honcho start -f ~/frappe-bench/Procfile $procs &>> ~/frappe-bench/bench_start.log &
-          }
 
           function update_to_version() {
             version=$1
@@ -158,11 +134,10 @@ jobs:
 
             # Resetup env and install apps
             pgrep honcho | xargs kill
-            sleep 10
             rm -rf ~/frappe-bench/env
             bench -v setup env --python python$2
             bench pip install -e ./apps/erpnext
-            start_bench_without_workers
+            bench start &>> ~/frappe-bench/bench_start.log &
 
             bench --site test_site migrate
           }
@@ -179,7 +154,7 @@ jobs:
           rm -rf ~/frappe-bench/env
           bench -v setup env
           bench pip install -e ./apps/erpnext
-          start_bench_without_workers
+          bench start &>> ~/frappe-bench/bench_start.log &
 
           bench --site test_site migrate
 

.github/workflows/review-translation-changes.yaml

@@ -22,4 +22,4 @@ jobs:
       pull-requests: write
 
     steps:
-      - uses: alyf-de/po-review-action@v1.1.0
+      - uses: alyf-de/po-review-action@v1.0.0

.github/workflows/server-tests-mariadb.yml

@@ -31,49 +31,51 @@ on:
 
 permissions:
   contents: read
-  packages: read
 
 concurrency:
   group: server-mariadb-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
   cancel-in-progress: true
 
-# Shared across both jobs. Both run in the SAME CI image so the bench lives at the identical
-# path (/home/ci/frappe-bench) on the setup runner and the test shards — that's what makes the
-# packaged Python venv portable between them.
-env:
-  TZ: 'Asia/Kolkata'
-  DEBIAN_FRONTEND: noninteractive
-  NODE_ENV: "production"
-  WITH_COVERAGE: ${{ github.event_name != 'pull_request' }}
-  ERPNEXT_CI_USER: ci
-  PIP_CACHE_DIR: /home/ci/.cache/pip
-  npm_config_cache: /home/ci/.cache/npm
-  YARN_CACHE_FOLDER: /home/ci/.cache/yarn
-  UV_CACHE_DIR: /home/ci/.cache/uv
-
 jobs:
-  # Build the bench (clone + pip + yarn + assets) and reinstall test_site ONCE, on a free
-  # GitHub-hosted runner, then publish the whole bench (with a DB dump baked in) as an artifact.
-  # The expensive, non-parallelisable work happens here exactly once instead of on every shard.
-  setup:
-    name: Build & reinstall (setup)
-    # Dedicated scale set (fat cpu request) so the build+reinstall runs at full speed, uncontended
-    # by the many thin test shards. Same CI image + /home/ci path + 127.0.0.1 DB as the shards,
-    # so the packaged bench (and its venv) transplants cleanly.
-    runs-on: erpnext-arc-setup
-    timeout-minutes: 40
-    container:
-      image: ghcr.io/frappe/erpnext-ci-mariadb:py3.14-node24
-      credentials:
-        username: ${{ secrets.GHCR_USERNAME || github.actor }}
-        password: ${{ secrets.GHCR_TOKEN || github.token }}
-    defaults:
-      run:
-        shell: bash
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    env:
+      TZ: 'Asia/Kolkata'
+      NODE_ENV: "production"
+      WITH_COVERAGE: ${{ github.event_name != 'pull_request' }}
+
+    strategy:
+      fail-fast: false
+
+      matrix:
+        container: [1, 2, 3, 4]
+
+    name: Python Unit Tests
+
+    services:
+      mysql:
+        image: mariadb:10.6
+        env:
+          TZ: 'Asia/Kolkata'
+          MARIADB_ROOT_PASSWORD: 'root'
+          # Disable durability guarantees that are unnecessary in a throwaway CI container.
+          # innodb_flush_log_at_trx_commit=0 avoids an fsync on every commit (biggest win).
+          # sync_binlog=0 skips binary-log syncs; innodb_doublewrite=0 skips the doublewrite buffer.
+          MARIADB_EXTRA_FLAGS: --innodb-flush-log-at-trx-commit=0 --sync-binlog=0 --innodb-doublewrite=0
+        ports:
+          - 3306:3306
+        options: --health-cmd="mariadb-admin ping" --health-interval=5s --health-timeout=2s --health-retries=3
+
     steps:
       - name: Clone
         uses: actions/checkout@v6
 
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.14'
+
       - name: Check for valid Python & Merge Conflicts
         run: |
           python -m compileall -fq "${GITHUB_WORKSPACE}"
@@ -82,17 +84,53 @@ jobs:
               exit 1
           fi
 
+      - name: Setup Node
+        uses: actions/setup-node@v6
+        with:
+          node-version: 24
+          check-latest: true
+
       - name: Add to Hosts
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
-      # MariaDB runs in-container on a datadir OUTSIDE the bench, because install.sh's next step
-      # does `rm -rf ~/frappe-bench`. After the reinstall, the datadir is moved into the bench so
-      # it ships in the artifact — test shards then start an already-loaded server (no restore).
-      - name: Start DB
-        run: bash ${GITHUB_WORKSPACE}/.github/helper/start-db.sh
+      - name: Cache pip
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-pip-
+            ${{ runner.os }}-
+
+      - name: Cache node modules
+        uses: actions/cache@v4
         env:
-          SKIP_SYSTEM_SETUP: "1"
-          CI_DB_DATADIR: /home/ci/db-data
+          cache-name: cache-node-modules
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ env.cache-name }}-
+            ${{ runner.os }}-build-
+            ${{ runner.os }}-
+
+      - name: Get yarn cache directory path
+        id: yarn-cache-dir-path
+        run: echo "dir=$(yarn cache dir)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        id: yarn-cache
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+
+      - name: Cache wkhtmltopdf
+        uses: actions/cache@v4
+        with:
+          path: /tmp/wkhtmltox.deb
+          key: wkhtmltox-0.12.6.1-2-jammy-amd64
 
       - name: Install
         run: bash ${GITHUB_WORKSPACE}/.github/helper/install.sh
@@ -101,88 +139,9 @@ jobs:
           TYPE: server
           FRAPPE_USER: ${{ github.event.inputs.user }}
           FRAPPE_BRANCH: ${{ github.event.client_payload.sha || github.event.inputs.branch }}
-          DB_HOST: 127.0.0.1
-          DB_USER_HOST: '%'
-          WKHTMLTOX_DEB: /tmp/wkhtmltox.deb
-          SKIP_SYSTEM_SETUP: "1"
-          SKIP_WKHTMLTOX_SETUP: "1"
-
-      - name: Warm up test data
-        run: |
-          su -m "${ERPNEXT_CI_USER:-frappe}" -s /bin/bash <<'EOF'
-          cd ~/frappe-bench/
-          bench --site test_site run-tests --lightmode --module erpnext.tests.bootstrap_test_data
-          EOF
-
-      # Clean shutdown (consistent InnoDB datadir), then stage it inside the bench for packaging.
-      - name: Stop DB and stage datadir
-        run: |
-          mariadb-admin -h 127.0.0.1 -P 3306 -u root -proot shutdown || true
-          for _ in $(seq 1 30); do [ -f /home/ci/db-data/mysqld.pid ] || break; sleep 1; done
-          # Don't bake a dirty datadir — fail if mariadbd didn't finish stopping, rather than ship
-          # an inconsistent datadir the shards would have to crash-recover.
-          [ -f /home/ci/db-data/mysqld.pid ] && { echo "mariadbd did not shut down cleanly"; exit 1; }
-          mv /home/ci/db-data /home/ci/frappe-bench/mariadb-data
-
-      # Package the whole bench (apps, venv, node_modules, sites, the DB dump, and hydrate.sh)
-      # into one artifact for the test shards to consume.
-      # Single-node hand-off: stage the bench on a node-local hostPath instead of round-tripping
-      # through GitHub artifact storage (~60s/shard). Setup and shards share the same disk, so
-      # the shards just untar it locally. NOTE: this assumes one node — a shard on a different
-      # node could not read this path (then you'd need GitHub artifacts or an NFS/RWX volume).
-      - name: Stage bench on node (hostPath)
-        run: |
-          cp "${GITHUB_WORKSPACE}/.github/helper/hydrate.sh" /home/ci/frappe-bench/hydrate.sh
-          cp "${GITHUB_WORKSPACE}/.github/helper/start-db.sh" /home/ci/frappe-bench/start-db.sh
-          mkdir -p /opt/ci-bench-staging
-          # self-clean: drop bench tars from runs older than 2h
-          find /opt/ci-bench-staging -maxdepth 1 -name '*.tar.gz' -mmin +120 -delete 2>/dev/null || true
-          # Exclude .git/node_modules; the mariadb-data datadir IS included (the pre-loaded DB).
-          tar czpf "/opt/ci-bench-staging/${GITHUB_RUN_ID}.tar.gz" -C /home/ci \
-            --exclude='.git' --exclude='node_modules' frappe-bench
-          ls -lh "/opt/ci-bench-staging/${GITHUB_RUN_ID}.tar.gz"
-
-  # Fan-out: each shard downloads the bench, untars it, starts MariaDB on the baked datadir, and
-  # runs its slice of the suite. No clone, no build, no reinstall, no DB dump restore on the shards.
-  test:
-    name: Python Unit Tests
-    needs: setup
-    runs-on: erpnext-arc
-    timeout-minutes: 60
-    container:
-      image: ghcr.io/frappe/erpnext-ci-mariadb:py3.14-node24
-      credentials:
-        username: ${{ secrets.GHCR_USERNAME || github.actor }}
-        password: ${{ secrets.GHCR_TOKEN || github.token }}
-    defaults:
-      run:
-        shell: bash
-
-    strategy:
-      fail-fast: false
-      matrix:
-        container: [1, 2, 3, 4]
-
-    steps:
-      - name: Add to Hosts
-        run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
-
-      # Read the bench straight from the node-local hostPath the setup job staged it on — no
-      # GitHub download. -p preserves the ci (uid 1001) ownership so bench runs as ci cleanly.
-      - name: Untar bench from node (hostPath)
-        run: |
-          tar xzpf "/opt/ci-bench-staging/${GITHUB_RUN_ID}.tar.gz" -C /home/ci
-          ls -ld /home/ci/frappe-bench
-
-      - name: Hydrate (start DB on baked datadir + bench start)
-        run: bash /home/ci/frappe-bench/hydrate.sh
-        env:
-          DB_HOST: 127.0.0.1
-          SKIP_SYSTEM_SETUP: "1"
 
       - name: Run Tests
         run: |
-          su -m "${ERPNEXT_CI_USER:-frappe}" -s /bin/bash <<'EOF'
           cd ~/frappe-bench/
           coverage_flag=""
           if [ "$WITH_COVERAGE" = "true" ]; then coverage_flag="--with-coverage"; fi
@@ -190,10 +149,10 @@ jobs:
             --total-builds ${{ strategy.job-total }} \
             --build-number ${{ matrix.container }} \
             $coverage_flag
-          EOF
         env:
           TYPE: server
 
+
       - name: Show bench output
         if: ${{ always() }}
         run: cat ~/frappe-bench/bench_start.log || true
@@ -203,11 +162,11 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: coverage-${{ matrix.container }}
-          path: /home/ci/frappe-bench/sites/coverage.xml
+          path: /home/runner/frappe-bench/sites/coverage.xml
 
   coverage:
     name: Coverage Wrap Up
-    needs: [test]
+    needs: test
     if: ${{ github.event_name != 'pull_request' }}
     runs-on: ubuntu-latest
     steps:

.github/workflows/server-tests-postgres.yml

@@ -1,12 +1,7 @@
 name: Server (Postgres)
 
 on:
-  schedule:
-    # 03:00 AM IST daily (21:30 UTC the previous day)
-    - cron: "30 21 * * *"
   pull_request:
-    # 'labeled' so adding the 'postgres' label to an already-open PR re-triggers the run.
-    types: [opened, reopened, synchronize, labeled]
     paths-ignore:
       - '**.js'
       - '**.md'
@@ -14,7 +9,7 @@ on:
       - 'crowdin.yml'
       - '.coderabbit.yml'
       - '.mergify.yml'
-  workflow_dispatch:
+    types: [opened, labelled, synchronize, reopened]
 
 concurrency:
   group: server-postgres-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
@@ -23,31 +18,41 @@ concurrency:
 permissions:
   contents: read
 
-# Postgres CI stays on GitHub-hosted (free, full-speed VM per shard) but follows the same fan-out
-# we built for MariaDB: build the bench + reinstall ONCE in the setup job, bake the PostgreSQL
-# PGDATA into the artifact, and have 4 test shards start Postgres on that datadir — no per-shard
-# clone/build/reinstall/restore. Python is pinned so the venv transplants between VMs.
-env:
-  TZ: 'Asia/Kolkata'
-  NODE_ENV: "production"
-  PYTHON_VERSION: '3.14'
-
 jobs:
-  setup:
-    name: Build & reinstall (setup)
+  test:
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'postgres') }}
     runs-on: ubuntu-latest
-    # Runs on the daily schedule (and workflow_dispatch). On PRs it runs ONLY when the PR carries
-    # the 'postgres' label — the test job needs setup, so it's skipped too when this is.
-    if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'postgres')
-    timeout-minutes: 40
+    timeout-minutes: 60
+
+    strategy:
+      fail-fast: false
+      matrix:
+       container: [1]
+
+    name: Python Unit Tests
+
+    services:
+      postgres:
+        image: postgres:13.3
+        env:
+          POSTGRES_PASSWORD: travis
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+
     steps:
+
       - name: Clone
         uses: actions/checkout@v6
 
       - name: Setup Python
         uses: actions/setup-python@v6
         with:
-          python-version: ${{ env.PYTHON_VERSION }}
+          python-version: '3.14'
 
       - name: Check for valid Python & Merge Conflicts
         run: |
@@ -66,133 +71,48 @@ jobs:
       - name: Add to Hosts
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
-      - name: Cache deps (uv/pip/npm/yarn)
+      - name: Cache pip
         uses: actions/cache@v4
         with:
-          path: |
-            ~/.cache/uv
-            ~/.cache/pip
-            ~/.npm
-            ~/.cache/yarn
-          key: ${{ runner.os }}-deps-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml', '**/yarn.lock') }}
-          restore-keys: ${{ runner.os }}-deps-
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-pip-
+            ${{ runner.os }}-
 
-      # Warm-bench cache (the big one): install.sh saves the built base bench — frappe + env +
-      # node_modules + assets — here as frappe-bench-base-*.tar.zst. Later runs restore it and only
-      # fast-forward to the live develop SHA + rebuild the delta, so the bench BUILD is near-free and
-      # only the test_site reinstall (per-run DB, uncacheable) stays slow — matching the self-hosted
-      # box. The first run after a deps change populates it; every run after that is fast.
-      - name: Cache warm bench (base build)
+      - name: Cache node modules
         uses: actions/cache@v4
-        with:
-          path: ~/bench-cache
-          key: ${{ runner.os }}-warmbench-v2-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml', '**/yarn.lock') }}
-          restore-keys: ${{ runner.os }}-warmbench-v2-
-
-      # Postgres runs in-runner on a PGDATA OUTSIDE the bench (install.sh wipes ~/frappe-bench);
-      # after the reinstall it's moved into the bench so it ships in the artifact.
-      - name: Start DB
-        run: bash ${GITHUB_WORKSPACE}/.github/helper/start-db.sh
         env:
-          DB: postgres
-          CI_DB_DATADIR: /home/runner/pgdata
+          cache-name: cache-node-modules
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ env.cache-name }}-
+            ${{ runner.os }}-build-
+            ${{ runner.os }}-
+
+      - name: Get yarn cache directory path
+        id: yarn-cache-dir-path
+        run: echo "dir=$(yarn cache dir)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        id: yarn-cache
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
 
       - name: Install
         run: bash ${GITHUB_WORKSPACE}/.github/helper/install.sh
         env:
           DB: postgres
           TYPE: server
-          FRAPPE_BRANCH: develop
-          BENCH_CACHE_DIR: /home/runner/bench-cache
-
-      - name: Warm up test data
-        run: |
-          cd ~/frappe-bench/
-          bench --site test_site run-tests --lightmode --module erpnext.tests.bootstrap_test_data
-
-      - name: Stop DB and stage datadir
-        run: |
-          PG_BIN=$(ls -d /usr/lib/postgresql/*/bin | sort -V | tail -1)
-          # Clean shutdown so the baked datadir is consistent. Do NOT swallow a failed stop with
-          # `|| true`: moving and tarring a still-running cluster ships a torn datadir the shards
-          # cannot crash-recover (full_page_writes is off). Fail the job instead — mirrors the
-          # MariaDB sister's "don't bake a dirty datadir" guard.
-          "$PG_BIN/pg_ctl" -D /home/runner/pgdata -m fast -w stop
-          mv /home/runner/pgdata /home/runner/frappe-bench/pgdata
-
-      - name: Package bench for test shards
-        run: |
-          cp "${GITHUB_WORKSPACE}/.github/helper/hydrate.sh" /home/runner/frappe-bench/hydrate.sh
-          cp "${GITHUB_WORKSPACE}/.github/helper/start-db.sh" /home/runner/frappe-bench/start-db.sh
-          tar czpf "${GITHUB_WORKSPACE}/bench.tar.gz" -C /home/runner \
-            --exclude='.git' --exclude='node_modules' frappe-bench
-          ls -lh "${GITHUB_WORKSPACE}/bench.tar.gz"
-
-      - name: Upload bench artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: bench-pg
-          path: bench.tar.gz
-          retention-days: 1
-          compression-level: 0
-
-  test:
-    name: Python Unit Tests
-    needs: setup
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    strategy:
-      fail-fast: false
-      matrix:
-        container: [1, 2, 3, 4]
-    steps:
-      - name: Download bench artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: bench-pg
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-
-      - name: Add to Hosts
-        run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
-
-      # The bench CLI (frappe-bench) and redis are global/system tools — not in the bench tarball.
-      # The setup runner got them via install.sh; the MariaDB shards get them from the arc5 image.
-      # GitHub-hosted PG shards install them here (cheap vs the build+reinstall that setup did once).
-      - name: Install shard runtime (bench CLI + redis + wkhtmltopdf)
-        run: |
-          pip install frappe-bench
-          command -v redis-server >/dev/null || { sudo apt-get update -qq && sudo apt-get install -y -qq redis-server; }
-          # wkhtmltopdf (patched-qt build) for print-format / PDF tests — same .deb install.sh uses.
-          if ! command -v wkhtmltopdf >/dev/null; then
-            wget -qO /tmp/wkhtmltox.deb https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
-            sudo apt-get install -y -qq /tmp/wkhtmltox.deb
-          fi
-
-      - name: Untar bench
-        run: |
-          tar xzpf "${GITHUB_WORKSPACE}/bench.tar.gz" -C /home/runner
-          ls -ld /home/runner/frappe-bench
-
-      - name: Hydrate (start Postgres on the baked datadir)
-        run: bash /home/runner/frappe-bench/hydrate.sh
-        env:
-          DB: postgres
-          DB_HOST: 127.0.0.1
 
       - name: Run Tests
-        run: |
-          cd ~/frappe-bench/
-          # print-format / PDF tests are engine-independent (they exercise wkhtmltopdf rendering,
-          # not postgres SQL — the MariaDB CI already covers them). They only fetch the static asset
-          # bundles from http://test_site:8000/assets/..., so a plain static file server over sites/
-          # satisfies wkhtmltopdf without the frappe web server (which never bound on a bare runner).
-          ( cd ~/frappe-bench/sites && nohup python3 -m http.server 8000 --bind 127.0.0.1 > ~/frappe-bench/web.log 2>&1 & )
-          for _ in $(seq 1 15); do (exec 3<>/dev/tcp/127.0.0.1/8000) 2>/dev/null && { exec 3>&- 3<&-; break; }; sleep 1; done
-          bench --site test_site run-parallel-tests --lightmode --app erpnext \
-            --total-builds ${{ strategy.job-total }} --build-number ${{ matrix.container }}
+        run: cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --app erpnext --use-orchestrator
         env:
           TYPE: server
+          CI_BUILD_ID: ${{ github.run_id }}
+          ORCHESTRATOR_URL: http://test-orchestrator.frappe.io

.pre-commit-config.yaml

@@ -48,6 +48,7 @@ repos:
                 cypress/.*|
                 .*node_modules.*|
                 .*boilerplate.*|
+                erpnext/public/js/controllers/.*|
                 erpnext/templates/pages/order.js|
                 erpnext/templates/includes/.*
             )$
@@ -65,18 +66,6 @@ repos:
       - id: ruff-format
         name: "Run ruff formatter"
 
-  - repo: local
-    hooks:
-      - id: postgres-compat
-        name: "PostgreSQL compatibility (static check)"
-        description: "Flags MySQL-only SQL that breaks on Postgres; the label-gated PG test job is the backstop for semantic divergences."
-        entry: .github/helper/postgres_compat.py
-        language: script
-        files: ^erpnext/.*\.py$
-        # patches/ are historical, version-gated migrations (skipped on fresh Postgres installs);
-        # out of scope for the always-on gate.
-        exclude: ^erpnext/patches/
-
 ci:
     autoupdate_schedule: weekly
     skip: []

banking/package.json

@@ -14,52 +14,52 @@
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
-    "@tailwindcss/vite": "^4.3.2",
+    "@tailwindcss/vite": "^4.3.0",
     "@tanstack/react-table": "^8.21.3",
     "@tanstack/react-virtual": "^3.13.24",
-    "@vitejs/plugin-react": "^6.0.3",
+    "@vitejs/plugin-react": "^6.0.1",
     "chrono-node": "^2.9.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "dayjs": "^1.11.20",
-    "frappe-react-sdk": "^1.17.0",
+    "frappe-react-sdk": "^1.15.0",
     "fuse.js": "^7.3.0",
-    "jotai": "^2.20.1",
-    "jotai-family": "^1.0.2",
+    "jotai": "^2.20.0",
+    "jotai-family": "^1.0.1",
     "lodash.isplainobject": "^4.0.6",
     "lucide-react": "^1.14.0",
-    "radix-ui": "^1.6.1",
-    "react": "^19.2.7",
+    "radix-ui": "^1.4.3",
+    "react": "^19.2.6",
     "react-currency-input-field": "^4.0.5",
     "react-day-picker": "9.14.0",
-    "react-dom": "^19.2.7",
+    "react-dom": "^19.2.6",
     "react-dropzone": "^15.0.0",
     "react-hook-form": "^7.75.0",
     "react-hotkeys-hook": "^5.3.2",
     "react-markdown": "^10.1.0",
-    "react-router": "^8.1.0",
+    "react-router": "^7.15.0",
+    "react-router-dom": "^7.15.0",
     "rehype-raw": "^7.0.0",
     "remark-gfm": "^4.0.1",
-    "safe-expr-eval": "^1.0.4",
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "^4.3.0",
     "tw-animate-css": "^1.4.0",
     "usehooks-ts": "^3.1.1",
-    "vite": "^8.0.16"
+    "vite": "^8.0.11"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.4",
+    "@eslint/js": "^9.39.1",
     "@types/node": "^25.3.0",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "eslint": "^9.39.1",
     "eslint-plugin-react-hooks": "^7.1.1",
-    "eslint-plugin-react-refresh": "^0.5.3",
+    "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.62.1"
+    "typescript-eslint": "^8.48.0"
   }
 }

banking/src/App.tsx

@@ -1,5 +1,5 @@
 import { lazy, useEffect } from 'react'
-import { BrowserRouter, Navigate, Route, Routes } from 'react-router'
+import { BrowserRouter, Navigate, Route, Routes } from 'react-router-dom'
 import { FrappeProvider } from 'frappe-react-sdk'
 import { Toaster } from '@/components/ui/sonner'
 import BankReconciliation from '@/pages/BankReconciliation'

banking/src/components/features/BankReconciliation/BankBalance.tsx

@@ -250,7 +250,7 @@ const ClosingBalanceForm = ({ defaultBalance, date, bankAccount, onClose }: { de
                     {_("Enter the closing balance you see in your bank statement for {0} as of the {1}", [bankAccount?.account_name ?? bankAccount?.name ?? '', formatDate(date, 'Do MMM YYYY')])}
                 </DialogDescription>
             </DialogHeader>
-            {error && <div className="py-2"><ErrorBanner error={error} /></div>}
+            {error && <ErrorBanner error={error} />}
             <div className="py-4">
                 <CurrencyFormField
                     name="balance"

banking/src/components/features/BankReconciliation/BankClearanceSummary.tsx

@@ -2,6 +2,7 @@ import { useAtomValue } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, SelectedBank, selectedBankAccountAtom } from "./bankRecAtoms"
 import { useCurrentCompany } from "@/hooks/useCurrentCompany"
+import { Paragraph } from "@/components/ui/typography"
 import type { ColumnDef } from "@tanstack/react-table"
 import { useCallback, useMemo, useState } from "react"
 import { useFrappeGetCall, useFrappePostCall, useSWRConfig } from "frappe-react-sdk"
@@ -25,7 +26,6 @@ import { Form } from "@/components/ui/form"
 import { useForm } from "react-hook-form"
 import { DateField } from "@/components/ui/form-elements"
 import { Empty, EmptyMedia, EmptyHeader, EmptyTitle, EmptyDescription } from "@/components/ui/empty"
-import MarkdownRenderer from "@/components/ui/markdown"
 
 const BankClearanceSummary = () => {
     const bankAccount = useAtomValue(selectedBankAccountAtom)
@@ -203,14 +203,14 @@ const BankClearanceSummaryView = () => {
         [accountCurrency, bankAccount, companyID, mutate, onCopy],
     )
 
-    const content = _("Below is a list of all accounting entries posted against the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
-
     return <div className="space-y-4 py-2">
 
         <div>
-            <span className="text-p-sm">
-                <MarkdownRenderer content={content} />
-            </span>
+            <Paragraph className="text-sm">
+                <span dangerouslySetInnerHTML={{
+                    __html: _("Below is a list of all accounting entries posted against the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
+                }} />
+            </Paragraph>
         </div>
 
         {error && <ErrorBanner error={error} />}

banking/src/components/features/BankReconciliation/BankEntryModalContent.tsx

@@ -18,7 +18,6 @@ import { useMultiFileUploadProgress } from "@/hooks/useMultiFileUploadProgress"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
 import { Checkbox } from "@/components/ui/checkbox"
 import { ArrowDownRight, ArrowUpRight, Plus, Trash2 } from "lucide-react"
-import { evaluateAmountFormula } from "@/lib/amountFormula"
 import { flt, formatCurrency } from "@/lib/numbers"
 import { cn } from "@/lib/utils"
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
@@ -216,13 +215,38 @@ const BankEntryForm = ({ selectedTransaction }: { selectedTransaction: Unreconci
                         })
                     } else {
 
-                        const transactionAmount = selectedTransaction.unallocated_amount ?? 0
+                        /**
+                         * The debit and credit amounts can also be expressions - like "transaction_amount * 0.5"
+                         * So we need to compute the value of the expression
+                         * We can use the eval function to do this. But we need to expose certain variables to the expression.
+                         * One of them is transaction_amount which is the unallocated amount of the selected transaction
+                         * @param expression - The expression to compute
+                         * @returns The computed value
+                         */
+                        const computeExpression = (expression: string) => {
+
+                            const script = `
+                                const transaction_amount = ${selectedTransaction.unallocated_amount ?? 0}
+                                ${expression};
+                            `
+
+                            let value = 0;
+
+                            try {
+                                value = window.eval(script);
+                            } catch (error: unknown) {
+                                console.error(error);
+                                value = 0;
+                            }
+
+                            return value;
+                        }
                         if (!acc?.debit && !acc?.credit) {
                             hasTotallyEmptyRowEarlier = true;
                         }
 
-                        const computedDebit = acc?.debit ? flt(evaluateAmountFormula(acc.debit, transactionAmount), 2) : 0
-                        const computedCredit = acc?.credit ? flt(evaluateAmountFormula(acc.credit, transactionAmount), 2) : 0
+                        const computedDebit = acc?.debit ? flt(computeExpression(acc.debit), 2) : 0
+                        const computedCredit = acc?.credit ? flt(computeExpression(acc.credit), 2) : 0
 
                         totalDebits = flt(totalDebits + computedDebit, 2)
                         totalCredits = flt(totalCredits + computedCredit, 2)

banking/src/components/features/BankReconciliation/BankReconciliationStatement.tsx

@@ -2,6 +2,7 @@ import { useAtomValue } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, selectedBankAccountAtom } from "./bankRecAtoms"
 import { useCurrentCompany } from "@/hooks/useCurrentCompany"
+import { Paragraph } from "@/components/ui/typography"
 import { useCallback, useMemo } from "react"
 import type { ColumnDef } from "@tanstack/react-table"
 import { useFrappeGetCall } from "frappe-react-sdk"
@@ -18,7 +19,6 @@ import _ from "@/lib/translate"
 import { toast } from "sonner"
 import { useCopyToClipboard } from "usehooks-ts"
 import { Empty, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle } from "@/components/ui/empty"
-import MarkdownRenderer from "@/components/ui/markdown"
 
 const BankReconciliationStatement = () => {
     const bankAccount = useAtomValue(selectedBankAccountAtom)
@@ -189,14 +189,14 @@ const BankReconciliationStatementView = () => {
         return data.message.result.filter((row: BankClearanceSummaryEntry) => Boolean(row.payment_entry))
     }, [data])
 
-    const content = _("Below is a list of all entries posted against the bank account {0} which have not been cleared till {1}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formatDate(dates.toDate)}</strong>`])
-
     return <div className="space-y-4 py-2">
 
         <div>
-            <span className="text-p-sm">
-                <MarkdownRenderer content={content} />
-            </span>
+            <Paragraph className="text-sm">
+                <span dangerouslySetInnerHTML={{
+                    __html: _("Below is a list of all entries posted against the bank account {0} which have not been cleared till {1}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formatDate(dates.toDate)}</strong>`])
+                }} />
+            </Paragraph>
         </div>
 
         {error && <ErrorBanner error={error} />}

banking/src/components/features/BankReconciliation/BankTransactionList.tsx

@@ -1,6 +1,7 @@
 import { useAtomValue, useSetAtom } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, bankRecUnreconcileModalAtom, selectedBankAccountAtom } from "./bankRecAtoms"
+import { Paragraph } from "@/components/ui/typography"
 import { formatDate } from "@/lib/date"
 import { ListView, type ListViewColumnMeta } from "@/components/ui/list-view"
 import { formatCurrency, getCurrencyFormatInfo } from "@/lib/numbers"
@@ -22,7 +23,6 @@ import { useCallback, useMemo, useState } from "react"
 import { Link } from "react-router"
 import { Empty, EmptyTitle, EmptyHeader, EmptyMedia, EmptyDescription, EmptyContent } from "@/components/ui/empty"
 import { InputGroup, InputGroupAddon } from "@/components/ui/input-group"
-import MarkdownRenderer from "@/components/ui/markdown"
 
 const BankTransactions = () => {
     const selectedBank = useAtomValue(selectedBankAccountAtom)
@@ -243,14 +243,14 @@ const BankTransactionListView = () => {
 
     }, [data, search, amountFilter, typeFilter, status])
 
-    const content = _("Below is a list of all bank transactions imported in the system for the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account_name}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
-
     return <div className="space-y-2 py-2">
 
         <div className="flex gap-2 justify-between items-center">
-            <span className="text-p-sm">
-                <MarkdownRenderer content={content} />
-            </span>
+            <Paragraph className="text-sm">
+                <span dangerouslySetInnerHTML={{
+                    __html: _("Below is a list of all bank transactions imported in the system for the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account_name}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
+                }} />
+            </Paragraph>
 
             <Button size='md' variant='subtle' asChild>
                 <Link to="/statement-importer">

banking/src/components/features/BankReconciliation/IncorrectlyClearedEntries.tsx

@@ -2,6 +2,7 @@ import { useAtomValue } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, selectedBankAccountAtom } from "./bankRecAtoms"
 import { useCurrentCompany } from "@/hooks/useCurrentCompany"
+import { Paragraph } from "@/components/ui/typography"
 import type { ColumnDef } from "@tanstack/react-table"
 import { useCallback, useMemo } from "react"
 import { useFrappeGetCall, useFrappePostCall } from "frappe-react-sdk"
@@ -17,7 +18,6 @@ import { PartyPopper } from "lucide-react"
 import ErrorBanner from "@/components/ui/error-banner"
 import _ from "@/lib/translate"
 import { Empty, EmptyTitle, EmptyDescription, EmptyMedia, EmptyHeader } from "@/components/ui/empty"
-import MarkdownRenderer from "@/components/ui/markdown"
 
 const IncorrectlyClearedEntries = () => {
     const companyID = useCurrentCompany()
@@ -177,22 +177,22 @@ const IncorrectlyClearedEntriesView = () => {
         [accountCurrency, onClearClick],
     )
 
-    const content = _("This report shows all entries in the system where the <strong>clearance date is before the posting date</strong> which is incorrect.")
-
-    const entriesContent = _("Entries below have a posting date after {0} but the clearance date is before {1}.", [`<strong>${formattedToDate}</strong>`, `<strong>${formattedToDate}</strong>`])
-
     return <div className="space-y-4 py-2">
 
         <div>
-            <span className="text-p-sm">
-                <MarkdownRenderer content={content} />
+            <Paragraph className="text-sm">
+                <span dangerouslySetInnerHTML={{
+                    __html: _("This report shows all entries in the system where the <strong>clearance date is before the posting date</strong> which is incorrect.")
+                }} />
                 <br />
                 {data && data.message.result.length > 0 && <span>
-                    <MarkdownRenderer content={entriesContent} />
+                    <span dangerouslySetInnerHTML={{
+                        __html: _("Entries below have a posting date after {0} but the clearance date is before {1}.", [`<strong>${formattedToDate}</strong>`, `<strong>${formattedToDate}</strong>`])
+                    }} />
                     <br />
                     {_("You can reset the clearing dates of these entries here.")}
                 </span>}
-            </span>
+            </Paragraph>
         </div>
 
         {error && <ErrorBanner error={error} />}

banking/src/components/features/BankReconciliation/Rules/RuleForm.tsx

@@ -11,7 +11,6 @@ import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
 import { H4, Paragraph } from "@/components/ui/typography"
 import { today } from "@/lib/date"
-import { evaluateAmountFormula } from "@/lib/amountFormula"
 import _ from "@/lib/translate"
 import { cn } from "@/lib/utils"
 import { BankTransactionRule } from "@/types/Accounts/BankTransactionRule"
@@ -446,10 +445,11 @@ const AmountFormulaRenderer = ({ value }: { value?: string }) => {
     // If it's a string and cannot be a number, then show it as a formula
 
     if (isNaN(Number(value))) {
+
         let calculatedValue = "";
 
         try {
-            calculatedValue = String(evaluateAmountFormula(value ?? "", 200));
+            calculatedValue = window.eval(`const transaction_amount = 200; ${value}`);
         } catch (error: unknown) {
             console.error(error);
             calculatedValue = "Error";

banking/src/components/features/BankStatementImporter/CSV/StatementDetails.tsx

@@ -14,7 +14,7 @@ import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip
 import { useFrappeEventListener, useFrappePostCall } from 'frappe-react-sdk'
 import { toast } from 'sonner'
 import ErrorBanner from '@/components/ui/error-banner'
-import { Link, useNavigate } from 'react-router'
+import { Link, useNavigate } from 'react-router-dom'
 import { useMemo, useState } from 'react'
 import { Progress } from '@/components/ui/progress'
 import { useSetAtom } from 'jotai'

banking/src/lib/amountFormula.ts

@@ -1,26 +0,0 @@
-import { Parser } from 'safe-expr-eval'
-
-const parser = new Parser()
-
-const PLAIN_NUMBER_PATTERN = /^-?\d+(\.\d+)?$/
-
-export function evaluateAmountFormula(expression: string, transactionAmount: number): number {
-    const trimmed = expression.trim()
-    if (!trimmed) {
-        return 0
-    }
-
-    if (PLAIN_NUMBER_PATTERN.test(trimmed)) {
-        return Number(trimmed)
-    }
-
-    try {
-        const result = parser.parse(trimmed).evaluate({ transaction_amount: transactionAmount })
-        if (typeof result !== 'number' || !Number.isFinite(result)) {
-            return 0
-        }
-        return result
-    } catch {
-        return 0
-    }
-}

banking/src/lib/frappe.ts

@@ -33,16 +33,6 @@ export const getErrorMessages = (error?: FrappeError | null): ParsedErrorMessage
         }
     })
 
-    // @ts-expect-error - some errors have _error_message
-    if (error?._error_message) {
-        eMessages.push({
-            // @ts-expect-error - some errors have _error_message
-            message: error?._error_message,
-            title: "Error",
-            indicator: "red"
-        })
-    }
-
     if (eMessages.length === 0) {
         // Get the message from the exception by removing the exc_type
         const indexOfFirstColon = error?.exception?.indexOf(':')

erpnext/__init__.py

@@ -3,6 +3,8 @@ import inspect
 from typing import TypeVar
 
 import frappe
+from frappe.model.document import Document
+from frappe.utils.user import is_website_user
 
 __version__ = "17.0.0-dev"
 
@@ -153,8 +155,6 @@ def allow_regional(fn):
 
 
 def check_app_permission():
-	from frappe.utils.user import is_website_user
-
 	if frappe.session.user == "Administrator":
 		return True
 
@@ -175,16 +175,9 @@ def normalize_ctx_input(T: type) -> callable:
 	- Casting the result to the specified type T
 	"""
 
-	from frappe.model.document import Document
-
 	def decorator(func: callable):
 		# conserve annotations for frappe.utils.typing_validations
-		@functools.wraps(
-			func,
-			assigned=(
-				a for a in functools.WRAPPER_ASSIGNMENTS if a not in ("__annotations__", "__annotate__")
-			),
-		)
+		@functools.wraps(func, assigned=(a for a in functools.WRAPPER_ASSIGNMENTS if a != "__annotations__"))
 		def wrapper(ctx: T | Document | dict | str, *args, **kwargs):
 			if isinstance(ctx, Document):
 				ctx = T(**ctx.as_dict())

erpnext/accounts/bulk_payment.py

@@ -1,129 +0,0 @@
-import frappe
-from frappe import _
-from frappe.utils import flt
-
-from erpnext.accounts.doctype.payment_entry.payment_entry import (
-	get_outstanding_reference_documents,
-	get_payment_entry,
-)
-from erpnext.utilities.bulk_transaction import transaction_processing
-
-
-@frappe.whitelist(methods=["POST"])
-def create_payment_entries(
-	grouped_invoices: str | list | None = None,
-	ungrouped_invoices: str | list | None = None,
-):
-	"""Create draft Payment Entries from AP report invoice selection."""
-	frappe.has_permission("Payment Entry", "create", throw=True)
-
-	grouped_invoices = [d for d in frappe.parse_json(grouped_invoices or "[]") if d.get("voucher_no")]
-	ungrouped_invoices = [d for d in frappe.parse_json(ungrouped_invoices or "[]") if d.get("voucher_no")]
-
-	if not grouped_invoices and not ungrouped_invoices:
-		frappe.throw(_("No Purchase Invoices selected"))
-
-	if ungrouped_invoices:
-		data = [{"name": d["voucher_no"]} for d in ungrouped_invoices]
-		transaction_processing(data, "Purchase Invoice", "Payment Entry")
-
-	if grouped_invoices:
-		groups = {}
-		for d in grouped_invoices:
-			key = (d["supplier"], d["party_account"])
-			groups.setdefault(
-				key, {"supplier": d["supplier"], "party_account": d["party_account"], "vouchers": []}
-			)["vouchers"].append(d["voucher_no"])
-
-		frappe.msgprint(
-			_("Started a background job to create {0} Grouped Payment Entries").format(len(groups))
-		)
-		frappe.enqueue(
-			make_grouped_payment_entries,
-			queue="long",
-			timeout=1500,
-			groups=list(groups.values()),
-		)
-
-
-def make_grouped_payment_entries(groups):
-	created, failed = 0, 0
-
-	for group in groups:
-		supplier = group["supplier"]
-		try:
-			frappe.db.savepoint("bulk_pe")
-			pe = _build_grouped_payment_entry(supplier, group["party_account"], group["vouchers"])
-			if not pe:
-				frappe.db.rollback(save_point="bulk_pe")
-				failed += 1
-				frappe.log_error(
-					title=_("Bulk Payment Entry skipped for {0}").format(supplier),
-					message=_(
-						"No outstanding invoices found for the selected vouchers in account {0}"
-					).format(group["party_account"]),
-				)
-				continue
-
-			pe.flags.ignore_validate = True
-			pe.set_title_field()
-			pe.insert(ignore_mandatory=True)
-			created += 1
-		except Exception:
-			frappe.db.rollback(save_point="bulk_pe")
-			failed += 1
-			frappe.log_error(title=_("Bulk Payment Entry creation failed for {0}").format(supplier))
-
-	message = _("Created {0} draft Grouped Payment Entries").format(created)
-
-	if failed:
-		message += " — " + _("{0} skipped (see Error Log)").format(failed)
-
-	frappe.publish_realtime(
-		"msgprint",
-		{"message": message, "title": _("Bulk Payment Entries"), "indicator": "green"},
-		user=frappe.session.user,
-		after_commit=True,
-	)
-
-
-def _build_grouped_payment_entry(supplier, party_account, names):
-	pe = get_payment_entry("Purchase Invoice", names[0])
-	pe.set("references", [])
-
-	refs = get_outstanding_reference_documents(
-		{
-			"party_type": "Supplier",
-			"party": supplier,
-			"party_account": party_account,
-			"company": pe.company,
-			"vouchers": [frappe._dict(voucher_type="Purchase Invoice", voucher_no=n) for n in names],
-		}
-	)
-
-	for r in refs:
-		if r.voucher_type != "Purchase Invoice":
-			continue
-		pe.append(
-			"references",
-			{
-				"reference_doctype": r.voucher_type,
-				"reference_name": r.voucher_no,
-				"bill_no": r.get("bill_no"),
-				"due_date": r.get("due_date"),
-				"payment_term": r.get("payment_term"),
-				"total_amount": r.invoice_amount,
-				"outstanding_amount": r.outstanding_amount,
-				"allocated_amount": r.outstanding_amount,
-				"exchange_rate": r.get("exchange_rate") or 1,
-			},
-		)
-
-	if not pe.references:
-		return None
-
-	# received_amount is in paid_to account currency; convert to paid_from account currency for paid_amount
-	pe.received_amount = sum(r.allocated_amount for r in pe.references)
-	pe.paid_amount = flt(pe.received_amount * pe.target_exchange_rate, pe.precision("paid_amount"))
-	pe.set_amounts()
-	return pe

erpnext/accounts/deferred_revenue.py

@@ -1,7 +1,6 @@
 import frappe
 from frappe import _
 from frappe.email import sendmail_to_system_managers
-from frappe.query_builder.functions import IfNull, Sum
 from frappe.utils import (
 	add_days,
 	add_months,
@@ -54,24 +53,20 @@ def validate_service_stop_date(doc):
 
 
 def build_conditions(process_type, account, company):
-	if process_type == "Income":
-		item = frappe.qb.DocType("Sales Invoice Item")
-		parent = frappe.qb.DocType("Sales Invoice")
-		deferred_account = item.deferred_revenue_account
-	else:
-		item = frappe.qb.DocType("Purchase Invoice Item")
-		parent = frappe.qb.DocType("Purchase Invoice")
-		deferred_account = item.deferred_expense_account
+	conditions = ""
+	deferred_account = (
+		"item.deferred_revenue_account" if process_type == "Income" else "item.deferred_expense_account"
+	)
 
 	if account:
-		return deferred_account == account
+		conditions += f"AND {deferred_account}={frappe.db.escape(account)}"
 	elif company:
-		return parent.company == company
+		conditions += f"AND p.company = {frappe.db.escape(company)}"
 
-	return None
+	return conditions
 
 
-def convert_deferred_expense_to_expense(deferred_process, start_date=None, end_date=None, conditions=None):
+def convert_deferred_expense_to_expense(deferred_process, start_date=None, end_date=None, conditions=""):
 	# book the expense/income on the last day, but it will be trigger on the 1st of month at 12:00 AM
 
 	if not start_date:
@@ -80,25 +75,17 @@ def convert_deferred_expense_to_expense(deferred_process, start_date=None, end_d
 		end_date = add_days(today(), -1)
 
 	# check for the purchase invoice for which GL entries has to be done
-	item = frappe.qb.DocType("Purchase Invoice Item")
-	parent = frappe.qb.DocType("Purchase Invoice")
-	query = (
-		frappe.qb.from_(item)
-		.inner_join(parent)
-		.on(item.parent == parent.name)
-		.select(item.parent)
-		.distinct()
-		.where(
-			(item.service_start_date <= end_date)
-			& (item.service_end_date >= start_date)
-			& (item.enable_deferred_expense == 1)
-			& (item.docstatus == 1)
-			& (IfNull(item.amount, 0) > 0)
-		)
-	)
-	if conditions is not None:
-		query = query.where(conditions)
-	invoices = query.run(pluck=True)
+	invoices = frappe.db.sql_list(
+		f"""
+		select distinct item.parent
+		from `tabPurchase Invoice Item` item, `tabPurchase Invoice` p
+		where item.service_start_date<=%s and item.service_end_date>=%s
+		and item.enable_deferred_expense = 1 and item.parent=p.name
+		and item.docstatus = 1 and ifnull(item.amount, 0) > 0
+		{conditions}
+	""",
+		(end_date, start_date),
+	)  # nosec
 
 	# For each invoice, book deferred expense
 	for invoice in invoices:
@@ -109,7 +96,7 @@ def convert_deferred_expense_to_expense(deferred_process, start_date=None, end_d
 		send_mail(deferred_process)
 
 
-def convert_deferred_revenue_to_income(deferred_process, start_date=None, end_date=None, conditions=None):
+def convert_deferred_revenue_to_income(deferred_process, start_date=None, end_date=None, conditions=""):
 	# book the expense/income on the last day, but it will be trigger on the 1st of month at 12:00 AM
 
 	if not start_date:
@@ -118,25 +105,17 @@ def convert_deferred_revenue_to_income(deferred_process, start_date=None, end_da
 		end_date = add_days(today(), -1)
 
 	# check for the sales invoice for which GL entries has to be done
-	item = frappe.qb.DocType("Sales Invoice Item")
-	parent = frappe.qb.DocType("Sales Invoice")
-	query = (
-		frappe.qb.from_(item)
-		.inner_join(parent)
-		.on(item.parent == parent.name)
-		.select(item.parent)
-		.distinct()
-		.where(
-			(item.service_start_date <= end_date)
-			& (item.service_end_date >= start_date)
-			& (item.enable_deferred_revenue == 1)
-			& (item.docstatus == 1)
-			& (IfNull(item.amount, 0) > 0)
-		)
-	)
-	if conditions is not None:
-		query = query.where(conditions)
-	invoices = query.run(pluck=True)
+	invoices = frappe.db.sql_list(
+		f"""
+		select distinct item.parent
+		from `tabSales Invoice Item` item, `tabSales Invoice` p
+		where item.service_start_date<=%s and item.service_end_date>=%s
+		and item.enable_deferred_revenue = 1 and item.parent=p.name
+		and item.docstatus = 1 and ifnull(item.amount, 0) > 0
+		{conditions}
+	""",
+		(end_date, start_date),
+	)  # nosec
 
 	for invoice in invoices:
 		doc = frappe.get_doc("Sales Invoice", invoice)
@@ -157,39 +136,26 @@ def get_booking_dates(doc, item, posting_date=None, prev_posting_date=None):
 	)
 
 	if not prev_posting_date:
-		prev_gl_entry = frappe.get_all(
-			"GL Entry",
-			filters={
-				"company": doc.company,
-				"account": item.get(deferred_account),
-				"voucher_type": doc.doctype,
-				"voucher_no": doc.name,
-				"voucher_detail_no": item.name,
-				"is_cancelled": 0,
-			},
-			fields=["name", "posting_date"],
-			order_by="posting_date desc",
-			limit=1,
+		prev_gl_entry = frappe.db.sql(
+			"""
+			select name, posting_date from `tabGL Entry` where company=%s and account=%s and
+			voucher_type=%s and voucher_no=%s and voucher_detail_no=%s
+			and is_cancelled = 0
+			order by posting_date desc limit 1
+		""",
+			(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
+			as_dict=True,
 		)
 
-		je = frappe.qb.DocType("Journal Entry")
-		jea = frappe.qb.DocType("Journal Entry Account")
-		prev_gl_via_je = (
-			frappe.qb.from_(je)
-			.inner_join(jea)
-			.on(je.name == jea.parent)
-			.select(je.name, je.posting_date)
-			.where(
-				(je.company == doc.company)
-				& (jea.account == item.get(deferred_account))
-				& (jea.reference_type == doc.doctype)
-				& (jea.reference_name == doc.name)
-				& (jea.reference_detail_no == item.name)
-				& (jea.docstatus < 2)
-			)
-			.orderby(je.posting_date, order=frappe.qb.desc)
-			.limit(1)
-			.run(as_dict=True)
+		prev_gl_via_je = frappe.db.sql(
+			"""
+			SELECT p.name, p.posting_date FROM `tabJournal Entry` p, `tabJournal Entry Account` c
+			WHERE p.name = c.parent and p.company=%s and c.account=%s
+			and c.reference_type=%s and c.reference_name=%s
+			and c.reference_detail_no=%s and c.docstatus < 2 order by posting_date desc limit 1
+		""",
+			(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
+			as_dict=True,
 		)
 
 		if prev_gl_via_je:
@@ -311,47 +277,26 @@ def get_already_booked_amount(doc, item):
 		total_credit_debit, total_credit_debit_currency = "credit", "credit_in_account_currency"
 		deferred_account = "deferred_expense_account"
 
-	gle = frappe.qb.DocType("GL Entry")
-	gl_entries_details = (
-		frappe.qb.from_(gle)
-		.select(
-			Sum(gle[total_credit_debit]).as_("total_credit"),
-			Sum(gle[total_credit_debit_currency]).as_("total_credit_in_account_currency"),
-			gle.voucher_detail_no,
-		)
-		.where(
-			(gle.company == doc.company)
-			& (gle.account == item.get(deferred_account))
-			& (gle.voucher_type == doc.doctype)
-			& (gle.voucher_no == doc.name)
-			& (gle.voucher_detail_no == item.name)
-			& (gle.is_cancelled == 0)
-		)
-		.groupby(gle.voucher_detail_no)
-		.run(as_dict=True)
+	gl_entries_details = frappe.db.sql(
+		"""
+		select sum({}) as total_credit, sum({}) as total_credit_in_account_currency, voucher_detail_no
+		from `tabGL Entry` where company=%s and account=%s and voucher_type=%s and voucher_no=%s and voucher_detail_no=%s
+		and is_cancelled = 0
+		group by voucher_detail_no
+	""".format(total_credit_debit, total_credit_debit_currency),
+		(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
+		as_dict=True,
 	)
 
-	je = frappe.qb.DocType("Journal Entry")
-	jea = frappe.qb.DocType("Journal Entry Account")
-	journal_entry_details = (
-		frappe.qb.from_(je)
-		.inner_join(jea)
-		.on(je.name == jea.parent)
-		.select(
-			Sum(jea[total_credit_debit]).as_("total_credit"),
-			Sum(jea[total_credit_debit_currency]).as_("total_credit_in_account_currency"),
-			jea.reference_detail_no,
-		)
-		.where(
-			(je.company == doc.company)
-			& (jea.account == item.get(deferred_account))
-			& (jea.reference_type == doc.doctype)
-			& (jea.reference_name == doc.name)
-			& (jea.reference_detail_no == item.name)
-			& (je.docstatus < 2)
-		)
-		.groupby(jea.reference_detail_no)
-		.run(as_dict=True)
+	journal_entry_details = frappe.db.sql(
+		"""
+		SELECT sum(c.{}) as total_credit, sum(c.{}) as total_credit_in_account_currency, reference_detail_no
+		FROM `tabJournal Entry` p , `tabJournal Entry Account` c WHERE p.name = c.parent and
+		p.company = %s and c.account=%s and c.reference_type=%s and c.reference_name=%s and c.reference_detail_no=%s
+		and p.docstatus < 2 group by reference_detail_no
+	""".format(total_credit_debit, total_credit_debit_currency),
+		(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
+		as_dict=True,
 	)
 
 	already_booked_amount = gl_entries_details[0].total_credit if gl_entries_details else 0
@@ -582,7 +527,6 @@ def make_gl_entries(
 				frappe.db.commit()
 		except Exception as e:
 			if frappe.in_test:
-				frappe.db.rollback()
 				doc.log_error(f"Error while processing deferred accounting for Invoice {doc.name}")
 				raise e
 			else:

erpnext/accounts/doctype/account/account.py

@@ -234,7 +234,7 @@ class Account(NestedSet):
 			if not frappe.db.get_value(
 				"Account", {"account_name": self.account_name, "company": ancestors[0]}, "name"
 			):
-				frappe.throw(_("Please add the account to root level Company - {0}").format(ancestors[0]))
+				frappe.throw(_("Please add the account to root level Company - {}").format(ancestors[0]))
 		elif self.parent_account:
 			descendants = get_descendants_of("Company", self.company)
 			if not descendants:
@@ -671,7 +671,7 @@ def _ensure_idle_system():
 	if last_gl_update > add_to_date(None, minutes=-5):
 		frappe.throw(
 			_(
-				"Last GL Entry update was done {0}. This operation is not allowed while system is actively being used. Please wait for 5 minutes before retrying."
+				"Last GL Entry update was done {}. This operation is not allowed while system is actively being used. Please wait for 5 minutes before retrying."
 			).format(pretty_date(last_gl_update)),
 			title=_("System In Use"),
 		)

erpnext/accounts/doctype/account/account_tree.js

@@ -236,9 +236,9 @@ frappe.treeview_settings["Account"] = {
 				function () {
 					let root_company = treeview.page.fields_dict.root_company.get_value();
 					if (root_company) {
-						frappe.throw(
-							__("Please add the account to root level Company - {0}", [root_company])
-						);
+						frappe.throw(__("Please add the account to root level Company - {0}"), [
+							root_company,
+						]);
 					} else {
 						treeview.new_node();
 					}

erpnext/accounts/doctype/account/chart_of_accounts/chart_of_accounts.py

@@ -137,7 +137,7 @@ def get_charts_for_country(country: str, with_standard: bool = False):
 
 	def _get_chart_name(content):
 		if content:
-			content = frappe.parse_json(content)
+			content = json.loads(content)
 			if (
 				content and content.get("disabled", "No") == "No"
 			) or frappe.local.flags.allow_unverified_charts:

erpnext/accounts/doctype/account/chart_of_accounts/verified/in_standard_chart_of_accounts.json

@@ -37,10 +37,6 @@
                         "account_type": "Stock",
                         "account_category": "Stock Assets"
                     },
-                    "Stock Delivered But Not Billed": {
-                        "account_type": "Stock Delivered But Not Billed",
-                        "account_category": "Stock Assets"
-                    },
                     "account_type": "Stock",
                     "account_category": "Stock Assets"
                 },
@@ -227,6 +223,10 @@
                     "Stock Received But Not Billed": {
                         "account_type": "Stock Received But Not Billed",
                         "account_category": "Trade Payables"
+                    },
+                    "Stock Delivered But Not Billed": {
+                        "account_type": "Stock Delivered But Not Billed",
+                        "account_category": "Trade Payables"
                     }
                 },
                 "Duties and Taxes": {

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -224,7 +224,7 @@ def disable_dimension(doc: str):
 
 
 def toggle_disabling(doc):
-	doc = frappe.parse_json(doc)
+	doc = json.loads(doc)
 
 	if doc.get("disabled"):
 		df = {"read_only": 1}

erpnext/accounts/doctype/accounting_period/accounting_period.py

@@ -5,7 +5,6 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.utils import getdate, nowdate
 
 
 class OverlapError(frappe.ValidationError):
@@ -37,20 +36,8 @@ class AccountingPeriod(Document):
 	# end: auto-generated types
 
 	def validate(self):
-		self.validate_dates()
 		self.validate_overlap()
 
-	def validate_dates(self):
-		if getdate(self.start_date) > getdate(self.end_date):
-			frappe.throw(_("Start Date cannot be after End Date"))
-
-		if getdate(self.end_date) > getdate(nowdate()):
-			frappe.throw(
-				_(
-					"Accounting Period cannot be created for a future date. End Date {0} is after today."
-				).format(frappe.bold(frappe.format(self.end_date, "Date")))
-			)
-
 	def before_insert(self):
 		self.bootstrap_doctypes_for_closing()
 

erpnext/accounts/doctype/accounting_period/test_accounting_period.py

@@ -2,7 +2,7 @@
 # See license.txt
 
 import frappe
-from frappe.utils import nowdate
+from frappe.utils import add_months, nowdate
 
 from erpnext.accounts.doctype.accounting_period.accounting_period import (
 	ClosedAccountingPeriod,
@@ -93,7 +93,7 @@ def create_accounting_period(**args):
 
 	accounting_period = frappe.new_doc("Accounting Period")
 	accounting_period.start_date = args.start_date or nowdate()
-	accounting_period.end_date = args.end_date or nowdate()
+	accounting_period.end_date = args.end_date or add_months(nowdate(), 1)
 	accounting_period.company = args.company or "_Test Company"
 	accounting_period.period_name = args.period_name or "_Test_Period_Name_1"
 	accounting_period.append("closed_documents", {"document_type": "Sales Invoice", "closed": 1})

erpnext/accounts/doctype/accounts_settings/accounts_settings.js

@@ -10,7 +10,7 @@ frappe.ui.form.on("Accounts Settings", {
 				},
 			};
 		});
-		if (!frm.naming_controller) frm.naming_controller = new frappe.ui.NamingSeriesController(frm);
+		if (!frm.naming_controller) frm.naming_controller = new erpnext.NamingSeriesController(frm);
 
 		frm.naming_controller.render_table("transaction_naming_html", get_transactions(frm));
 	},

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -87,7 +87,6 @@
   "period_closing_settings_section",
   "ignore_account_closing_balance",
   "use_legacy_controller_for_pcv",
-  "pcv_job_timeout",
   "column_break_25",
   "reports_tab",
   "remarks_section",
@@ -613,14 +612,6 @@
    "fieldtype": "Check",
    "label": "Use legacy controller for Period Closing Voucher"
   },
-  {
-   "default": "3600",
-   "depends_on": "eval: !doc.use_legacy_controller_for_pcv",
-   "description": "Timeout (in seconds) for each background job enqueued by Process Period Closing Voucher",
-   "fieldname": "pcv_job_timeout",
-   "fieldtype": "Int",
-   "label": "PCV Job Timeout (seconds)"
-  },
   {
    "description": "Users with this role will be notified if the asset depreciation gets failed",
    "fieldname": "role_to_notify_on_depreciation_failure",
@@ -765,7 +756,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2026-06-24 12:59:41.868865",
+ "modified": "2026-06-03 13:11:54.721495",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -90,7 +90,6 @@ class AccountsSettings(Document):
 		make_payment_via_journal_entry: DF.Check
 		merge_similar_account_heads: DF.Check
 		over_billing_allowance: DF.Currency
-		pcv_job_timeout: DF.Int
 		preview_mode: DF.Check
 		receivable_payable_fetch_method: DF.Literal["Buffered Cursor", "UnBuffered Cursor"]
 		receivable_payable_remarks_length: DF.Int

erpnext/accounts/doctype/advance_payment_ledger_entry/test_advance_payment_ledger_entry.py

@@ -22,13 +22,11 @@ class TestAdvancePaymentLedgerEntry(ERPNextTestSuite, AccountsTestMixin):
 	"""
 
 	def setUp(self):
-		self.company = "_Test Company"
-		self.customer = "_Test Customer"
-		self.supplier = "_Test Supplier"
-		self.item = "_Test Item"
-		self.cash = "Cash - _TC"
-		self.debtors_usd = "_Test Receivable USD - _TC"
-		self.creditors_usd = "_Test Payable USD - _TC"
+		self.create_company()
+		self.create_usd_receivable_account()
+		self.create_usd_payable_account()
+		self.create_item()
+		self.clear_old_entries()
 
 	def create_sales_order(self, qty=1, rate=100, currency="INR", do_not_submit=False):
 		"""

erpnext/accounts/doctype/bank_account_balance/bank_account_balance.json

@@ -1,6 +1,5 @@
 {
  "actions": [],
- "allow_bulk_edit": 1,
  "allow_rename": 1,
  "creation": "2026-04-11 19:48:13.622253",
  "doctype": "DocType",
@@ -8,8 +7,7 @@
  "field_order": [
   "bank_account",
   "date",
-  "balance",
-  "company"
+  "balance"
  ],
  "fields": [
   {
@@ -33,20 +31,12 @@
    "in_list_view": 1,
    "label": "Balance",
    "reqd": 1
-  },
-  {
-   "fetch_from": "bank_account.company",
-   "fieldname": "company",
-   "fieldtype": "Link",
-   "label": "Company",
-   "options": "Company",
-   "read_only": 1
   }
  ],
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2026-06-16 22:17:48.007982",
+ "modified": "2026-04-11 19:49:45.374695",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account Balance",

erpnext/accounts/doctype/bank_account_balance/bank_account_balance.py

@@ -16,7 +16,6 @@ class BankAccountBalance(Document):
 
 		balance: DF.Currency
 		bank_account: DF.Link
-		company: DF.Link | None
 		date: DF.Date
 	# end: auto-generated types
 

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -7,7 +7,7 @@ from frappe import _, msgprint
 from frappe.model.document import Document
 from frappe.query_builder import Case
 from frappe.query_builder.custom import ConstantColumn
-from frappe.query_builder.functions import Coalesce, Max, Sum
+from frappe.query_builder.functions import Coalesce, Sum
 from frappe.utils import cint, flt, fmt_money, getdate
 from pypika import Order
 
@@ -195,17 +195,14 @@ def get_payment_entries_for_bank_clearance(
 		.select(
 			ConstantColumn("Journal Entry").as_("payment_document"),
 			journal_entry.name.as_("payment_entry"),
-			# non-grouped columns are constant per grouped JE name / account (against_account is
-			# arbitrary per group on MySQL) -> Max() keeps the GROUP BY valid on postgres with the
-			# same value MySQL picked.
-			Max(journal_entry.cheque_no).as_("cheque_number"),
-			Max(journal_entry.cheque_date).as_("cheque_date"),
+			journal_entry.cheque_no.as_("cheque_number"),
+			journal_entry.cheque_date,
 			Sum(journal_entry_account.debit_in_account_currency).as_("debit"),
 			Sum(journal_entry_account.credit_in_account_currency).as_("credit"),
-			Max(journal_entry.posting_date).as_("posting_date"),
-			Max(journal_entry_account.against_account).as_("against_account"),
-			Max(journal_entry.clearance_date).as_("clearance_date"),
-			Max(journal_entry_account.account_currency).as_("account_currency"),
+			journal_entry.posting_date,
+			journal_entry_account.against_account,
+			journal_entry.clearance_date,
+			journal_entry_account.account_currency,
 		)
 		.where(
 			(journal_entry_account.account == account)
@@ -218,13 +215,12 @@ def get_payment_entries_for_bank_clearance(
 
 	if not include_reconciled_entries:
 		journal_entry_query = journal_entry_query.where(
-			(journal_entry.clearance_date.isnull())
-			| (journal_entry.clearance_date == ("0000-00-00" if frappe.db.db_type != "postgres" else None))
+			(journal_entry.clearance_date.isnull()) | (journal_entry.clearance_date == "0000-00-00")
 		)
 
 	journal_entries = (
 		journal_entry_query.groupby(journal_entry_account.account, journal_entry.name)
-		.orderby(Max(journal_entry.posting_date))
+		.orderby(journal_entry.posting_date)
 		.orderby(journal_entry.name, order=Order.desc)
 	).run(as_dict=True)
 
@@ -294,8 +290,7 @@ def get_payment_entries_for_bank_clearance(
 
 	if not include_reconciled_entries:
 		payment_entry_query = payment_entry_query.where(
-			(pe.clearance_date.isnull())
-			| (pe.clearance_date == ("0000-00-00" if frappe.db.db_type != "postgres" else None))
+			(pe.clearance_date.isnull()) | (pe.clearance_date == "0000-00-00")
 		)
 
 	payment_entries = (payment_entry_query.orderby(pe.posting_date).orderby(pe.name, order=Order.desc)).run(
@@ -332,8 +327,7 @@ def get_payment_entries_for_bank_clearance(
 
 	if not include_reconciled_entries:
 		paid_purchase_invoices_query = paid_purchase_invoices_query.where(
-			(pi.clearance_date.isnull())
-			| (pi.clearance_date == ("0000-00-00" if frappe.db.db_type != "postgres" else None))
+			(pi.clearance_date.isnull()) | (pi.clearance_date == "0000-00-00")
 		)
 
 	paid_purchase_invoices = (
@@ -373,8 +367,7 @@ def get_payment_entries_for_bank_clearance(
 
 		if not include_reconciled_entries:
 			pos_sales_invoices_query = pos_sales_invoices_query.where(
-				(si_payment.clearance_date.isnull())
-				| (si_payment.clearance_date == ("0000-00-00" if frappe.db.db_type != "postgres" else None))
+				(si_payment.clearance_date.isnull()) | (si_payment.clearance_date == "0000-00-00")
 			)
 
 		pos_sales_invoices = (

erpnext/accounts/doctype/bank_guarantee/bank_guarantee.js

@@ -9,13 +9,6 @@ cur_frm.add_fetch("bank", "swift_number", "swift_number");
 
 frappe.ui.form.on("Bank Guarantee", {
 	setup: function (frm) {
-		frm.set_query("reference_doctype", function () {
-			return {
-				filters: {
-					name: ["in", ["Sales Order", "Purchase Order"]],
-				},
-			};
-		});
 		frm.set_query("bank_account", function () {
 			return {
 				filters: {

erpnext/accounts/doctype/bank_guarantee/bank_guarantee.json

@@ -1,6 +1,5 @@
 {
  "actions": [],
- "allow_bulk_edit": 1,
  "autoname": "ACC-BG-.YYYY.-.#####",
  "creation": "2016-12-17 10:43:35.731631",
  "doctype": "DocType",
@@ -51,7 +50,8 @@
    "fieldname": "reference_doctype",
    "fieldtype": "Link",
    "label": "Reference Document Type",
-   "options": "DocType"
+   "options": "DocType",
+   "read_only": 1
   },
   {
    "fieldname": "reference_docname",
@@ -60,14 +60,14 @@
    "options": "reference_doctype"
   },
   {
-   "depends_on": "eval: doc.reference_doctype == \"Sales Order\"",
+   "depends_on": "eval: doc.bg_type == \"Receiving\"",
    "fieldname": "customer",
    "fieldtype": "Link",
    "label": "Customer",
    "options": "Customer"
   },
   {
-   "depends_on": "eval: doc.reference_doctype == \"Purchase Order\"",
+   "depends_on": "eval: doc.bg_type == \"Providing\"",
    "fieldname": "supplier",
    "fieldtype": "Link",
    "label": "Supplier",
@@ -218,11 +218,10 @@
  "grid_page_length": 50,
  "is_submittable": 1,
  "links": [],
- "modified": "2026-05-25 18:12:10.768835",
+ "modified": "2025-08-29 11:52:33.550847",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Guarantee",
- "naming_rule": "Expression",
  "owner": "Administrator",
  "permissions": [
   {

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -8,7 +8,7 @@ import frappe
 from frappe import _
 from frappe.model.document import Document
 from frappe.query_builder.custom import ConstantColumn
-from frappe.query_builder.functions import Max, Sum
+from frappe.query_builder.functions import Sum
 from frappe.utils import cint, create_batch, flt
 
 from erpnext import get_default_cost_center
@@ -1058,9 +1058,9 @@ def get_auto_reconcile_message(partially_reconciled, reconciled):
 
 
 @frappe.whitelist()
-def reconcile_vouchers(bank_transaction_name: str | int, vouchers: str | list, is_new_voucher: bool = False):
+def reconcile_vouchers(bank_transaction_name: str | int, vouchers: str, is_new_voucher: bool = False):
 	# updated clear date of all the vouchers based on the bank transaction
-	vouchers = frappe.parse_json(vouchers)
+	vouchers = json.loads(vouchers)
 	transaction = frappe.get_doc("Bank Transaction", bank_transaction_name)
 	transaction.add_payment_entries(vouchers, is_new_voucher)
 	transaction.validate_duplicate_references()
@@ -1410,14 +1410,12 @@ def get_je_matching_query(
 			Sum(getattr(jea, amount_field)).as_("paid_amount"),
 			ConstantColumn("Journal Entry").as_("doctype"),
 			je.name,
-			# non-grouped columns are constant per grouped JE name (party_type/currency come from the
-			# single bank-account line) -> Max() keeps the GROUP BY valid on postgres with the same value
-			Max(je.cheque_no).as_("reference_no"),
-			Max(je.cheque_date).as_("reference_date"),
-			Max(je.pay_to_recd_from).as_("party"),
-			Max(jea.party_type).as_("party_type"),
-			Max(je.posting_date).as_("posting_date"),
-			Max(jea.account_currency).as_("currency"),
+			je.cheque_no.as_("reference_no"),
+			je.cheque_date.as_("reference_date"),
+			je.pay_to_recd_from.as_("party"),
+			jea.party_type,
+			je.posting_date,
+			jea.account_currency.as_("currency"),
 		)
 		.where(je.docstatus == 1)
 		.where(je.voucher_type != "Opening Entry")
@@ -1425,7 +1423,7 @@ def get_je_matching_query(
 		.where(jea.account == common_filters.bank_account)
 		.where(filter_by_date)
 		.groupby(je.name)
-		.orderby(Max(je.cheque_date) if cint(filter_by_reference_date) else Max(je.posting_date))
+		.orderby(je.cheque_date if cint(filter_by_reference_date) else je.posting_date)
 	)
 
 	if frappe.flags.auto_reconcile_vouchers is True:

erpnext/accounts/doctype/bank_reconciliation_tool/test_bank_reconciliation_tool.py

@@ -17,10 +17,9 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestBankReconciliationTool(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.company = "_Test Company"
-		self.customer = "_Test Customer"
-		self.bank = "HDFC - _TC"
-		self.debit_to = "Debtors - _TC"
+		self.create_company()
+		self.create_customer()
+		self.clear_old_entries()
 		bank_dt = qb.DocType("Bank")
 		qb.from_(bank_dt).delete().where(bank_dt.name == "HDFC").run()
 		self.create_bank_account()

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.json

@@ -221,12 +221,12 @@
    "default": "0",
    "fieldname": "import_mt940_fromat",
    "fieldtype": "Check",
-   "label": "Import MT940 Format"
+   "label": "Import MT940 Fromat"
   }
  ],
  "hide_toolbar": 1,
  "links": [],
- "modified": "2026-06-19 14:18:00.000000",
+ "modified": "2026-05-31 00:41:11.251215",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Statement Import",

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.py

@@ -290,7 +290,7 @@ def update_mapping_db(bank, template_options):
 	for d in bank.bank_transaction_mapping:
 		d.delete()
 
-	for d in frappe.parse_json(template_options)["column_to_field_map"].items():
+	for d in json.loads(template_options)["column_to_field_map"].items():
 		bank.append("bank_transaction_mapping", {"bank_transaction_field": d[1], "file_field": d[0]})
 
 	bank.save()

erpnext/accounts/doctype/bank_statement_import_log/bank_statement_import_log.py

@@ -829,9 +829,7 @@ def compute_final_transactions(transaction_rows: list, date_format: str, amount_
 
 		if amount_format == 'Amount column has "CR"/"DR" values':
 			amount = transaction_row.get("amount")
-
-			# If the amount column has CR/DR in it - we should remove any signs (negative or positive) from the amount
-			float_amount = abs(get_float_amount(amount) or 0)
+			float_amount = get_float_amount(amount)
 			if "cr" in amount.lower():
 				return 0, float_amount
 			else:
@@ -934,18 +932,14 @@ def extract_pdf_tables(content: bytes, password: str | None = None) -> list[dict
 	from pypdf import PdfReader
 
 	reader = PdfReader(io.BytesIO(content))
-	if reader.is_encrypted:
-		# Try opening the PDF with a password - if no password is provided, try with a blank password
-		if not password:
-			password = ""
-		if not reader.decrypt(password):
-			frappe.throw(
-				_(
-					"This PDF is password protected. Please set the correct statement password on the"
-					" Bank Account and try again."
-				),
-				title=_("Password Required"),
-			)
+	if reader.is_encrypted and (not password or not reader.decrypt(password)):
+		frappe.throw(
+			_(
+				"This PDF is password protected. Please set the correct statement password on the"
+				" Bank Account and try again."
+			),
+			title=_("Password Required"),
+		)
 
 	text_settings = {"vertical_strategy": "text", "horizontal_strategy": "text"}
 	tables = []
@@ -1189,7 +1183,8 @@ def update_pdf_tables(statement_import_id: str, tables: list | str):
 	if doc.status == "Completed":
 		frappe.throw(_("This statement has already been imported."), title=_("Already Imported"))
 
-	tables = frappe.parse_json(tables)
+	if isinstance(tables, str):
+		tables = json.loads(tables)
 
 	doc.apply_pdf_tables(tables)
 
@@ -1209,7 +1204,8 @@ def reextract_pdf_table(statement_import_id: str, page: int, table_index: int, b
 	if doc.status == "Completed":
 		frappe.throw(_("This statement has already been imported."), title=_("Already Imported"))
 
-	bbox = frappe.parse_json(bbox)
+	if isinstance(bbox, str):
+		bbox = json.loads(bbox)
 
 	page = int(page)
 	table_index = int(table_index)
@@ -1294,7 +1290,8 @@ def update_column_mapping(statement_import_id: str, column_mapping: list | str):
 	if doc.status == "Completed":
 		frappe.throw(_("This statement has already been imported."), title=_("Already Imported"))
 
-	column_mapping = frappe.parse_json(column_mapping)
+	if isinstance(column_mapping, str):
+		column_mapping = json.loads(column_mapping)
 
 	doc.apply_column_mapping(column_mapping)
 	doc.save()

erpnext/accounts/doctype/bank_statement_import_log/test_bank_statement_import_log.py

@@ -26,9 +26,9 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestBankStatementImportLog(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.company = "_Test Company"
-		self.customer = "_Test Customer"
-		self.bank = "HDFC - _TC"
+		self.create_company()
+		self.create_customer()
+		self.clear_old_entries()
 		bank_dt = qb.DocType("Bank")
 		qb.from_(bank_dt).delete().where(bank_dt.name == "HDFC").run()
 		self.create_bank_account()

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -5,8 +5,6 @@ import frappe
 from frappe import _
 from frappe.model.docstatus import DocStatus
 from frappe.model.document import Document
-from frappe.query_builder import Tuple
-from frappe.query_builder.functions import Abs, Max, Sum
 from frappe.utils import flt, getdate
 
 
@@ -440,7 +438,7 @@ def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries
 
 		if bt_bank_account != gl_bank_account:
 			frappe.throw(
-				_("Bank Account {0} in Bank Transaction {1} is not matching with Bank Account {2}").format(
+				_("Bank Account {} in Bank Transaction {} is not matching with Bank Account {}").format(
 					bt_bank_account, payment_entry.payment_entry, gl_bank_account
 				)
 			)
@@ -449,7 +447,7 @@ def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries
 
 	if gl_bank_account not in gl_entries:
 		frappe.throw(
-			_("{0} {1} is not affecting bank account {2}").format(
+			_("{} {} is not affecting bank account {}").format(
 				payment_entry.payment_document, payment_entry.payment_entry, gl_bank_account
 			)
 		)
@@ -457,7 +455,7 @@ def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries
 	allocable_amount = gl_entries.pop(gl_bank_account) or 0
 	if allocable_amount <= 0.0:
 		frappe.throw(
-			_("Invalid amount in accounting entries of {0} {1} for Account {2}: {3}").format(
+			_("Invalid amount in accounting entries of {} {} for Account {}: {}").format(
 				payment_entry.payment_document, payment_entry.payment_entry, gl_bank_account, allocable_amount
 			)
 		)
@@ -480,28 +478,30 @@ def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries
 
 
 def get_related_bank_gl_entries(docs):
+	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
 	if not docs:
 		return {}
 
-	gle = frappe.qb.DocType("GL Entry")
-	ac = frappe.qb.DocType("Account")
-	result = (
-		frappe.qb.from_(gle)
-		.left_join(ac)
-		.on(ac.name == gle.account)
-		.select(
-			gle.voucher_type.as_("doctype"),
-			gle.voucher_no.as_("docname"),
-			gle.account.as_("gl_account"),
-			Sum(Abs(gle.credit_in_account_currency - gle.debit_in_account_currency)).as_("amount"),
-		)
-		.where(
-			(ac.account_type == "Bank")
-			& Tuple(gle.voucher_type, gle.voucher_no).isin([Tuple(vt, vn) for vt, vn in docs])
-			& (gle.is_cancelled == 0)
-		)
-		.groupby(gle.voucher_type, gle.voucher_no, gle.account)
-		.run(as_dict=True)
+	result = frappe.db.sql(
+		"""
+        SELECT
+            gle.voucher_type AS doctype,
+            gle.voucher_no AS docname,
+            gle.account AS gl_account,
+            SUM(ABS(gle.credit_in_account_currency - gle.debit_in_account_currency)) AS amount
+        FROM
+            `tabGL Entry` gle
+        LEFT JOIN
+            `tabAccount` ac ON ac.name = gle.account
+        WHERE
+            ac.account_type = 'Bank'
+            AND (gle.voucher_type, gle.voucher_no) IN %(docs)s
+            AND gle.is_cancelled = 0
+        GROUP BY
+            gle.voucher_type, gle.voucher_no, gle.account
+        """,
+		{"docs": docs},
+		as_dict=True,
 	)
 
 	entries = {}
@@ -523,32 +523,31 @@ def get_total_allocated_amount(docs):
 	if not docs:
 		return {}
 
-	# The original window query (ROW_NUMBER/FIRST_VALUE + rownum = 1) just collapses to one
-	# row per (account, payment_document, payment_entry) with the partition's allocation total
-	# and most recent transaction date — i.e. a plain GROUP BY with SUM and MAX.
-	btp = frappe.qb.DocType("Bank Transaction Payments")
-	bt = frappe.qb.DocType("Bank Transaction")
-	ba = frappe.qb.DocType("Bank Account")
-
-	result = (
-		frappe.qb.from_(btp)
-		.left_join(bt)
-		.on(bt.name == btp.parent)
-		.left_join(ba)
-		.on(ba.name == bt.bank_account)
-		.select(
-			Sum(btp.allocated_amount).as_("total"),
-			Max(bt.date).as_("latest_date"),
-			ba.account.as_("gl_account"),
-			btp.payment_document,
-			btp.payment_entry,
-		)
-		.where(
-			Tuple(btp.payment_document, btp.payment_entry).isin([Tuple(pd, pe) for pd, pe in docs])
-			& (bt.docstatus == 1)
-		)
-		.groupby(ba.account, btp.payment_document, btp.payment_entry)
-		.run(as_dict=True)
+	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
+	result = frappe.db.sql(
+		"""
+		SELECT total, latest_date, gl_account, payment_document, payment_entry FROM (
+			SELECT
+				ROW_NUMBER() OVER w AS rownum,
+				SUM(btp.allocated_amount) OVER(PARTITION BY ba.account, btp.payment_document, btp.payment_entry) AS total,
+				FIRST_VALUE(bt.date) OVER w AS latest_date,
+				ba.account AS gl_account,
+				btp.payment_document,
+				btp.payment_entry
+			FROM
+				`tabBank Transaction Payments` btp
+			LEFT JOIN `tabBank Transaction` bt ON bt.name=btp.parent
+			LEFT JOIN `tabBank Account` ba ON ba.name=bt.bank_account
+			WHERE
+				(btp.payment_document, btp.payment_entry) IN %(docs)s
+				AND bt.docstatus = 1
+			WINDOW w AS (PARTITION BY ba.account, btp.payment_document, btp.payment_entry ORDER BY bt.date DESC)
+		) temp
+		WHERE
+			rownum = 1
+		""",
+		dict(docs=docs),
+		as_dict=True,
 	)
 
 	payment_allocation_details = {}

erpnext/accounts/doctype/bank_transaction/bank_transaction_upload.py

@@ -35,19 +35,18 @@ def upload_bank_statement():
 
 
 @frappe.whitelist()
-def create_bank_entries(columns: str, data: str | list, bank_account: str):
+def create_bank_entries(columns: str, data: str, bank_account: str):
 	header_map = get_header_mapping(columns, bank_account)
 
 	success = 0
 	errors = 0
-	for d in frappe.parse_json(data):
+	for d in json.loads(data):
 		if all(item is None for item in d) is True:
 			continue
 		fields = {}
 		for key, value in header_map.items():
 			fields.update({key: d[int(value) - 1]})
 
-		frappe.db.savepoint("bank_entry")
 		try:
 			bank_transaction = frappe.get_doc({"doctype": "Bank Transaction"})
 			bank_transaction.update(fields)
@@ -57,8 +56,7 @@ def create_bank_entries(columns: str, data: str | list, bank_account: str):
 			bank_transaction.submit()
 			success += 1
 		except Exception:
-			frappe.db.rollback(save_point="bank_entry")
-			frappe.log_error(title="Bank entry creation failed")
+			bank_transaction.log_error("Bank entry creation failed")
 			errors += 1
 
 	return {"success": success, "errors": errors}
@@ -68,7 +66,7 @@ def get_header_mapping(columns, bank_account):
 	mapping = get_bank_mapping(bank_account)
 
 	header_map = {}
-	for column in frappe.parse_json(columns):
+	for column in json.loads(columns):
 		if column["content"] in mapping:
 			header_map.update({mapping[column["content"]]: column["colIndex"]})
 

erpnext/accounts/doctype/bank_transaction/test_bank_transaction.py

@@ -104,36 +104,6 @@ class TestBankTransaction(ERPNextTestSuite):
 		self.assertEqual(bank_transaction.unallocated_amount, 1700)
 		self.assertEqual(bank_transaction.payment_entries, [])
 
-	# Amending a reconciled payment entry must not carry over its clearance date
-	def test_clearance_date_cleared_on_amend(self):
-		bank_transaction = frappe.get_doc(
-			"Bank Transaction",
-			dict(description="1512567 BG/000003025 OPSKATTUZWXXX AT776000000098709849 Herr G"),
-		)
-		payment = frappe.get_doc("Payment Entry", dict(party="Mr G", paid_amount=1700))
-		vouchers = json.dumps(
-			[
-				{
-					"payment_doctype": "Payment Entry",
-					"payment_name": payment.name,
-					"amount": bank_transaction.unallocated_amount,
-				}
-			]
-		)
-		reconcile_vouchers(bank_transaction.name, vouchers)
-
-		self.assertTrue(frappe.db.get_value("Payment Entry", payment.name, "clearance_date"))
-
-		payment.reload()
-		payment.cancel()
-
-		amended = frappe.copy_doc(payment)
-		amended.amended_from = payment.name
-		amended.docstatus = 0
-		amended.insert()
-
-		self.assertFalse(amended.clearance_date)
-
 	# Check if ERPNext can correctly filter a linked payments based on the debit/credit amount
 	def test_debit_credit_output(self):
 		bank_transaction = frappe.get_doc(

erpnext/accounts/doctype/bank_transaction_rule/bank_transaction_rule.py

@@ -9,48 +9,6 @@ from frappe.model.document import Document
 
 from erpnext.accounts.doctype.bank_transaction.bank_transaction import BankTransaction
 
-PLAIN_NUMBER_PATTERN = re.compile(r"^-?\d+(\.\d+)?$")
-# Tokens accepted by safe-expr-eval on the frontend (must stay in sync).
-ALLOWED_FORMULA_TOKEN = re.compile(r"\s+|transaction_amount|\d+(?:\.\d+)?|[+\-*/%^()]")
-PYTHON_ONLY_OPERATORS = ("**", "//")
-
-
-def _is_expr_eval_formula(formula: str) -> bool:
-	position = 0
-	while position < len(formula):
-		match = ALLOWED_FORMULA_TOKEN.match(formula, position)
-		if not match:
-			return False
-		position = match.end()
-
-	return formula.count("(") == formula.count(")")
-
-
-def validate_amount_formula(formula: str) -> None:
-	if not formula:
-		return
-
-	stripped = formula.strip()
-	if PLAIN_NUMBER_PATTERN.match(stripped):
-		return
-
-	if any(operator in stripped for operator in PYTHON_ONLY_OPERATORS):
-		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
-
-	if not _is_expr_eval_formula(stripped):
-		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
-
-	# expr-eval uses ^ for exponentiation; translate for a smoke-test evaluation only.
-	python_formula = stripped.replace("^", "**")
-
-	try:
-		result = frappe.safe_eval(python_formula, eval_globals=None, eval_locals={"transaction_amount": 1})
-	except Exception:
-		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
-
-	if not isinstance(result, (int | float)):
-		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
-
 
 class BankTransactionRule(Document):
 	# begin: auto-generated types
@@ -108,7 +66,7 @@ class BankTransactionRule(Document):
 				frappe.throw(_("Party type is required to create a payment entry."))
 
 			if not self.party:
-				frappe.throw(_("Party is required to create a payment entry."))
+				frappe.throw(_("Party is required create a payment entry."))
 
 			if not self.account:
 				frappe.throw(_("Party account is required to create a payment entry."))
@@ -128,11 +86,6 @@ class BankTransactionRule(Document):
 							frappe.throw(
 								_("The last account row must not have any debit or credit amounts set.")
 							)
-					else:
-						if account.debit:
-							validate_amount_formula(account.debit)
-						if account.credit:
-							validate_amount_formula(account.credit)
 
 		# Validate regex
 		for rule in self.description_rules:

erpnext/accounts/doctype/bank_transaction_rule/test_bank_transaction_rule.py

@@ -11,11 +11,9 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestBankTransactionRule(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.company = "_Test Company"
-		self.customer = "_Test Customer"
-		self.bank = "HDFC - _TC"
-		self.debit_to = "Debtors - _TC"
-		self.cash = "Cash - _TC"
+		self.create_company()
+		self.create_customer()
+		self.clear_old_entries()
 		bank_dt = qb.DocType("Bank")
 		qb.from_(bank_dt).delete().where(bank_dt.name == "HDFC").run()
 		self.create_bank_account()
@@ -231,45 +229,3 @@ class TestBankTransactionRule(ERPNextTestSuite, AccountsTestMixin):
 		doc = self._rule("bad_rx", [{"check": "Regex", "value": "["}])
 		with self.assertRaises(ValidationError):
 			doc.insert()
-
-	def _multiple_accounts_rule(self, prefix: str, accounts, **fields):
-		return self._rule(
-			prefix,
-			[{"check": "Contains", "value": "x"}],
-			classify_as="Bank Entry",
-			bank_entry_type="Multiple Accounts",
-			accounts=accounts,
-			**fields,
-		)
-
-	def test_validate_bank_entry_multiple_valid_amount_formulas(self):
-		doc = self._multiple_accounts_rule(
-			"be_formula",
-			accounts=[
-				{"account": self.bank, "debit": "200", "credit": ""},
-				{"account": self.cash, "debit": "", "credit": "transaction_amount * 0.25"},
-				{"account": self.cash, "debit": "", "credit": ""},
-			],
-		)
-		doc.insert()
-		self.assertTrue(doc.name)
-
-	def test_validate_bank_entry_multiple_invalid_amount_formulas(self):
-		malicious_formulas = [
-			"__import__('os')",
-			"eval('1+1')",
-			"open('/etc/passwd')",
-			"transaction_amount ** 2",
-			"transaction_amount // 2",
-		]
-		for formula in malicious_formulas:
-			with self.subTest(formula=formula):
-				doc = self._multiple_accounts_rule(
-					"be_bad_formula",
-					accounts=[
-						{"account": self.bank, "debit": formula, "credit": ""},
-						{"account": self.cash, "debit": "", "credit": ""},
-					],
-				)
-				with self.assertRaises(ValidationError):
-					doc.insert()

erpnext/accounts/doctype/budget/budget.js

@@ -136,9 +136,6 @@ function set_total_budget_amount(frm) {
 function toggle_distribution_fields(frm) {
 	const grid = frm.fields_dict.budget_distribution.grid;
 
-	frm.set_df_property("budget_distribution", "cannot_add_rows", true);
-	frm.set_df_property("budget_distribution", "cannot_delete_rows", true);
-
 	["amount", "percent"].forEach((field) => {
 		grid.update_docfield_property(field, "read_only", frm.doc.distribute_equally);
 	});

erpnext/accounts/doctype/budget/budget.py

@@ -5,11 +5,9 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.query_builder import Criterion
-from frappe.query_builder.functions import Coalesce, Sum
+from frappe.query_builder.functions import Sum
 from frappe.utils import add_months, flt, fmt_money, get_last_day, getdate
 from frappe.utils.data import get_first_day
-from pypika.terms import ExistsCriterion
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
@@ -117,26 +115,23 @@ class Budget(Document):
 		if not account:
 			return
 
-		budget = frappe.qb.DocType("Budget")
-		fy_from = frappe.qb.DocType("Fiscal Year").as_("fy_from")
-		fy_to = frappe.qb.DocType("Fiscal Year").as_("fy_to")
-		existing_budget = (
-			frappe.qb.from_(budget)
-			.inner_join(fy_from)
-			.on(fy_from.name == budget.from_fiscal_year)
-			.inner_join(fy_to)
-			.on(fy_to.name == budget.to_fiscal_year)
-			.select(budget.name, budget.account)
-			.where(
-				(budget.docstatus < 2)
-				& (budget.company == self.company)
-				& (budget[budget_against_field] == budget_against)
-				& (budget.account == account)
-				& (budget.name != self.name)
-				& (fy_from.year_start_date <= self.budget_end_date)
-				& (fy_to.year_end_date >= self.budget_start_date)
-			)
-			.run(as_dict=True)
+		existing_budget = frappe.db.sql(
+			f"""
+			SELECT name, account
+			FROM `tabBudget`
+			WHERE
+				docstatus < 2
+				AND company = %s
+				AND {budget_against_field} = %s
+				AND account = %s
+				AND name != %s
+				AND (
+					(SELECT year_start_date FROM `tabFiscal Year` WHERE name = from_fiscal_year) <= %s
+					AND (SELECT year_end_date FROM `tabFiscal Year` WHERE name = to_fiscal_year) >= %s
+				)
+			""",
+			(self.company, budget_against, account, self.name, self.budget_end_date, self.budget_start_date),
+			as_dict=True,
 		)
 
 		if existing_budget:
@@ -162,9 +157,9 @@ class Budget(Document):
 			frappe.throw(_("Account {0} does not belong to company {1}").format(self.account, self.company))
 		elif account_details.report_type != "Profit and Loss":
 			frappe.throw(
-				_(
-					"Budget cannot be assigned against {0}, as its Root Type is not of Income or Expense"
-				).format(self.account)
+				_("Budget cannot be assigned against {0}, as it's not an Income or Expense account").format(
+					self.account
+				)
 			)
 
 	def set_null_value(self):
@@ -358,8 +353,8 @@ class Budget(Document):
 		if self.should_regenerate_budget_distribution():
 			return
 
-		total_amount = sum(flt(d.amount) for d in self.budget_distribution)
-		total_percent = sum(flt(d.percent) for d in self.budget_distribution)
+		total_amount = sum(d.amount for d in self.budget_distribution)
+		total_percent = sum(d.percent for d in self.budget_distribution)
 
 		if flt(abs(total_amount - self.budget_amount), 2) > 0.10:
 			frappe.throw(
@@ -386,24 +381,17 @@ def validate_expense_against_budget(params, expense_amount=0):
 	posting_fiscal_year = get_fiscal_year(posting_date, company=params.get("company"))[0]
 	year_start_date, year_end_date = get_fiscal_year_date_range(posting_fiscal_year, posting_fiscal_year)
 
-	budget = frappe.qb.DocType("Budget")
-	fy_from = frappe.qb.DocType("Fiscal Year").as_("fy_from")
-	fy_to = frappe.qb.DocType("Fiscal Year").as_("fy_to")
-	budget_exists = (
-		frappe.qb.from_(budget)
-		.inner_join(fy_from)
-		.on(fy_from.name == budget.from_fiscal_year)
-		.inner_join(fy_to)
-		.on(fy_to.name == budget.to_fiscal_year)
-		.select(budget.name)
-		.where(
-			(budget.company == params.company)
-			& (budget.docstatus == 1)
-			& (fy_from.year_start_date <= year_end_date)
-			& (fy_to.year_end_date >= year_start_date)
-		)
-		.limit(1)
-		.run()
+	budget_exists = frappe.db.sql(
+		"""
+		select name
+		from `tabBudget`
+		where company = %s
+		and docstatus = 1
+		and (SELECT year_start_date FROM `tabFiscal Year` WHERE name = from_fiscal_year) <= %s
+		and (SELECT year_end_date FROM `tabFiscal Year` WHERE name = to_fiscal_year) >= %s
+		limit 1
+		""",
+		(params.company, year_end_date, year_start_date),
 	)
 
 	if not budget_exists:
@@ -446,52 +434,50 @@ def validate_expense_against_budget(params, expense_amount=0):
 			and (frappe.get_cached_value("Account", params.account, "root_type") == "Expense")
 		):
 			doctype = dimension.get("document_type")
-			params.is_tree = bool(frappe.get_cached_value("DocType", doctype, "is_tree"))
+
+			if frappe.get_cached_value("DocType", doctype, "is_tree"):
+				lft, rgt = frappe.get_cached_value(doctype, params.get(budget_against), ["lft", "rgt"])
+				condition = f"""and exists(select name from `tab{doctype}`
+					where lft<={lft} and rgt>={rgt} and name=b.{budget_against})"""  # nosec
+				params.is_tree = True
+			else:
+				condition = f"and b.{budget_against}={frappe.db.escape(params.get(budget_against))}"
+				params.is_tree = False
+
 			params.budget_against_field = budget_against
 			params.budget_against_doctype = doctype
 
-			b = frappe.qb.DocType("Budget")
-			query = (
-				frappe.qb.from_(b)
-				.select(
+			budget_records = frappe.db.sql(
+				f"""
+				SELECT
 					b.name,
-					getattr(b, budget_against).as_("budget_against"),
+					b.{budget_against} AS budget_against,
 					b.budget_amount,
 					b.from_fiscal_year,
 					b.to_fiscal_year,
 					b.budget_start_date,
 					b.budget_end_date,
-					Coalesce(b.applicable_on_material_request, 0).as_("for_material_request"),
-					Coalesce(b.applicable_on_purchase_order, 0).as_("for_purchase_order"),
-					Coalesce(b.applicable_on_booking_actual_expenses, 0).as_("for_actual_expenses"),
+					IFNULL(b.applicable_on_material_request, 0) AS for_material_request,
+					IFNULL(b.applicable_on_purchase_order, 0) AS for_purchase_order,
+					IFNULL(b.applicable_on_booking_actual_expenses, 0) AS for_actual_expenses,
 					b.action_if_annual_budget_exceeded,
 					b.action_if_accumulated_monthly_budget_exceeded,
 					b.action_if_annual_budget_exceeded_on_mr,
 					b.action_if_accumulated_monthly_budget_exceeded_on_mr,
 					b.action_if_annual_budget_exceeded_on_po,
-					b.action_if_accumulated_monthly_budget_exceeded_on_po,
-				)
-				.where(b.company == params.company)
-				.where(b.docstatus == 1)
-				.where(b.budget_start_date <= params.posting_date)
-				.where(b.budget_end_date >= params.posting_date)
-				.where(b.account == params.account)
-			)
-
-			if params.is_tree:
-				lft, rgt = frappe.get_cached_value(doctype, params.get(budget_against), ["lft", "rgt"])
-				dim = frappe.qb.DocType(doctype)
-				query = query.where(
-					ExistsCriterion(
-						frappe.qb.from_(dim)
-						.select(dim.name)
-						.where((dim.lft <= lft) & (dim.rgt >= rgt) & (dim.name == getattr(b, budget_against)))
-					)
-				)
-			else:
-				query = query.where(getattr(b, budget_against) == params.get(budget_against))
-
-			budget_records = query.run(as_dict=True)
+					b.action_if_accumulated_monthly_budget_exceeded_on_po
+				FROM
+					`tabBudget` b
+				WHERE
+					b.company = %s
+					AND b.docstatus = 1
+					AND %s BETWEEN b.budget_start_date AND b.budget_end_date
+					AND b.account = %s
+					{condition}
+				""",
+				(params.company, params.posting_date, params.account),
+				as_dict=True,
+			)  # nosec
 
 			if budget_records:
 				validate_budget_records(params, budget_records, expense_amount)
@@ -688,27 +674,15 @@ def get_actions(params, budget):
 
 def get_requested_amount(params):
 	item_code = params.get("item_code")
+	condition = get_other_condition(params, "Material Request")
 
-	child = frappe.qb.DocType("Material Request Item")
-	parent = frappe.qb.DocType("Material Request")
-
-	data = (
-		frappe.qb.from_(child)
-		.join(parent)
-		.on(parent.name == child.parent)
-		.select(
-			# rate inside the aggregate: Sum(qty * rate) is the correct requested amount and is PG-valid
-			Coalesce(Sum((child.stock_qty - child.ordered_qty) * child.rate), 0).as_("amount")
-		)
-		.where(
-			(child.item_code == item_code)
-			& (parent.docstatus == 1)
-			& (child.stock_qty > child.ordered_qty)
-			& Criterion.all(get_other_condition(params, child, parent, "Material Request"))
-			& (parent.material_request_type == "Purchase")
-			& (parent.status != "Stopped")
-		)
-		.run(as_list=1)
+	data = frappe.db.sql(
+		""" select ifnull((sum(child.stock_qty - child.ordered_qty) * rate), 0) as amount
+		from `tabMaterial Request Item` child, `tabMaterial Request` parent where parent.name = child.parent and
+		child.item_code = %s and parent.docstatus = 1 and child.stock_qty > child.ordered_qty and {} and
+		parent.material_request_type = 'Purchase' and parent.status != 'Stopped'""".format(condition),
+		item_code,
+		as_list=1,
 	)
 
 	return data[0][0] if data else 0
@@ -716,43 +690,37 @@ def get_requested_amount(params):
 
 def get_ordered_amount(params):
 	item_code = params.get("item_code")
+	condition = get_other_condition(params, "Purchase Order")
 
-	child = frappe.qb.DocType("Purchase Order Item")
-	parent = frappe.qb.DocType("Purchase Order")
-
-	data = (
-		frappe.qb.from_(child)
-		.join(parent)
-		.on(parent.name == child.parent)
-		.select(Coalesce(Sum(child.amount - child.billed_amt), 0).as_("amount"))
-		.where(
-			(child.item_code == item_code)
-			& (parent.docstatus == 1)
-			& (child.amount > child.billed_amt)
-			& (parent.status != "Closed")
-			& Criterion.all(get_other_condition(params, child, parent, "Purchase Order"))
-		)
-		.run(as_list=1)
+	data = frappe.db.sql(
+		f""" select ifnull(sum(child.amount - child.billed_amt), 0) as amount
+		from `tabPurchase Order Item` child, `tabPurchase Order` parent where
+		parent.name = child.parent and child.item_code = %s and parent.docstatus = 1 and child.amount > child.billed_amt
+		and parent.status != 'Closed' and {condition}""",
+		item_code,
+		as_list=1,
 	)
 
 	return data[0][0] if data else 0
 
 
-def get_other_condition(params, child, parent, for_doc):
-	conditions = [child.expense_account == params.expense_account]
+def get_other_condition(params, for_doc):
+	condition = f"expense_account = {frappe.db.escape(params.expense_account)}"
 	budget_against_field = params.get("budget_against_field")
 
 	if budget_against_field and params.get(budget_against_field):
-		conditions.append(child[budget_against_field] == params.get(budget_against_field))
+		condition += (
+			f" and child.{budget_against_field} = {frappe.db.escape(params.get(budget_against_field))}"
+		)
 
 	date_field = "schedule_date" if for_doc == "Material Request" else "transaction_date"
 
 	start_date = frappe.get_cached_value("Fiscal Year", params.from_fiscal_year, "year_start_date")
 	end_date = frappe.get_cached_value("Fiscal Year", params.to_fiscal_year, "year_end_date")
 
-	conditions.append(parent[date_field][str(start_date) : str(end_date)])
+	condition += f" and parent.{date_field} between {frappe.db.escape(str(start_date))} and {frappe.db.escape(str(end_date))}"
 
-	return conditions
+	return condition
 
 
 def get_actual_expense(params):
@@ -760,19 +728,11 @@ def get_actual_expense(params):
 		params.budget_against_doctype = frappe.unscrub(params.budget_against_field)
 
 	budget_against_field = params.get("budget_against_field")
+	condition1 = " and gle.posting_date <= %(month_end_date)s" if params.get("month_end_date") else ""
 
-	gle = frappe.qb.DocType("GL Entry")
-
-	conditions = [
-		gle.is_cancelled == 0,
-		gle.account == params.get("account"),
-		gle.posting_date[str(params.budget_start_date) : str(params.budget_end_date)],
-		gle.company == params.get("company"),
-		gle.docstatus == 1,
-	]
-
-	if params.get("month_end_date"):
-		conditions.append(gle.posting_date <= params.get("month_end_date"))
+	date_condition = (
+		f"and gle.posting_date between '{params.budget_start_date}' and '{params.budget_end_date}'"
+	)
 
 	if params.is_tree:
 		lft_rgt = frappe.db.get_value(
@@ -780,27 +740,35 @@ def get_actual_expense(params):
 		)
 		params.update(lft_rgt)
 
-		tree = frappe.qb.DocType(params.budget_against_doctype)
-		conditions.append(
-			ExistsCriterion(
-				frappe.qb.from_(tree)
-				.select(tree.name)
-				.where(
-					(tree.lft >= params.get("lft"))
-					& (tree.rgt <= params.get("rgt"))
-					& (tree.name == gle[budget_against_field])
-				)
+		condition2 = f"""
+			and exists(
+				select name from `tab{params.budget_against_doctype}`
+				where lft >= %(lft)s and rgt <= %(rgt)s
+				and name = gle.{budget_against_field}
 			)
-		)
+		"""
 	else:
-		conditions.append(gle[budget_against_field] == params.get(budget_against_field))
+		condition2 = f"""
+			and gle.{budget_against_field} = %({budget_against_field})s
+		"""
 
 	amount = flt(
-		frappe.qb.from_(gle)
-		.select(Sum(gle.debit) - Sum(gle.credit))
-		.where(Criterion.all(conditions))
-		.run()[0][0]
-	)
+		frappe.db.sql(
+			f"""
+				select sum(gle.debit) - sum(gle.credit)
+				from `tabGL Entry` gle
+				where
+					is_cancelled = 0
+					and gle.account = %(account)s
+					{condition1}
+					{date_condition}
+					and gle.company = %(company)s
+					and gle.docstatus = 1
+					{condition2}
+			""",
+			params,
+		)[0][0]
+	)  # nosec
 
 	return amount
 

erpnext/accounts/doctype/budget_distribution/budget_distribution.json

@@ -18,7 +18,6 @@
    "in_list_view": 1,
    "label": "Start Date",
    "read_only": 1,
-   "reqd": 1,
    "search_index": 1
   },
   {
@@ -26,29 +25,26 @@
    "fieldtype": "Date",
    "in_list_view": 1,
    "label": "End Date",
-   "read_only": 1,
-   "reqd": 1
+   "read_only": 1
   },
   {
    "fieldname": "amount",
    "fieldtype": "Currency",
    "in_list_view": 1,
-   "label": "Amount",
-   "reqd": 1
+   "label": "Amount"
   },
   {
    "fieldname": "percent",
    "fieldtype": "Percent",
    "in_list_view": 1,
-   "label": "Percent",
-   "reqd": 1
+   "label": "Percent"
   }
  ],
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2026-06-18 11:23:17.669733",
+ "modified": "2025-11-03 13:18:28.398198",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Budget Distribution",

erpnext/accounts/doctype/budget_distribution/budget_distribution.py

@@ -15,12 +15,12 @@ class BudgetDistribution(Document):
 		from frappe.types import DF
 
 		amount: DF.Currency
-		end_date: DF.Date
+		end_date: DF.Date | None
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data
 		percent: DF.Percent
-		start_date: DF.Date
+		start_date: DF.Date | None
 	# end: auto-generated types
 
 	pass

erpnext/accounts/doctype/cashier_closing/cashier_closing.py

@@ -5,7 +5,6 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.query_builder.functions import Sum
 from frappe.utils import flt
 
 
@@ -44,17 +43,13 @@ class CashierClosing(Document):
 		self.make_calculations()
 
 	def get_outstanding(self):
-		si = frappe.qb.DocType("Sales Invoice")
-		values = (
-			frappe.qb.from_(si)
-			.select(Sum(si.outstanding_amount))
-			.where(
-				(si.posting_date == self.date)
-				& (si.posting_time >= self.from_time)
-				& (si.posting_time <= self.time)
-				& (si.owner == self.user)
-			)
-			.run()
+		values = frappe.db.sql(
+			"""
+			select sum(outstanding_amount)
+			from `tabSales Invoice`
+			where posting_date=%s and posting_time>=%s and posting_time<=%s and owner=%s
+		""",
+			(self.date, self.from_time, self.time, self.user),
 		)
 		self.outstanding_amount = flt(values[0][0] if values else 0)
 

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -63,8 +63,8 @@ def validate_company(company: str):
 	)
 
 	if parent_company and (not allow_account_creation_against_child_company):
-		msg = _("{0} is a child company.").format(frappe.bold(company)) + " "
-		msg += _("Please import accounts against parent company or enable {0} in company master.").format(
+		msg = _("{} is a child company.").format(frappe.bold(company)) + " "
+		msg += _("Please import accounts against parent company or enable {} in company master.").format(
 			frappe.bold(_("Allow Account Creation Against Child Company"))
 		)
 		frappe.throw(msg, title=_("Wrong Company"))
@@ -75,10 +75,7 @@ def validate_company(company: str):
 
 @frappe.whitelist()
 def import_coa(file_name: str, company: str):
-	frappe.only_for("Accounts Manager")
-
 	# delete existing data for accounts
-	frappe.has_permission("Company", "write", company, throw=True)
 	unset_existing_data(company)
 
 	# create accounts
@@ -456,7 +453,6 @@ def unset_existing_data(company):
 	fieldnames = get_linked_fields("Account").get("Company", {}).get("fieldname", [])
 	linked = [{"fieldname": name} for name in fieldnames]
 	update_values = {d.get("fieldname"): "" for d in linked}
-
 	frappe.db.set_value("Company", company, update_values, update_values)
 
 	# remove accounts data from various doctypes
@@ -468,7 +464,8 @@ def unset_existing_data(company):
 		"Sales Taxes and Charges Template",
 		"Purchase Taxes and Charges Template",
 	]:
-		frappe.get_query(doctype, delete=True, filters={"company": company}, ignore_permissions=False).run()
+		dt = frappe.qb.DocType(doctype)
+		frappe.qb.from_(dt).where(dt.company == company).delete().run()
 
 
 def set_default_accounts(company):

erpnext/accounts/doctype/cost_center/cost_center.py

@@ -84,10 +84,10 @@ class CostCenter(NestedSet):
 		return frappe.db.get_value("GL Entry", {"cost_center": self.name})
 
 	def check_if_child_exists(self):
-		return frappe.get_all(
-			"Cost Center",
-			filters={"parent_cost_center": self.name, "docstatus": ["!=", 2]},
-			pluck="name",
+		return frappe.db.sql(
+			"select name from `tabCost Center` where \
+			parent_cost_center = %s and docstatus != 2",
+			self.name,
 		)
 
 	def if_allocation_exists_against_cost_center(self):

erpnext/accounts/doctype/coupon_code/test_coupon_code.py

@@ -173,66 +173,3 @@ class TestCouponCode(ERPNextTestSuite):
 
 		# Clean up
 		coupon.delete()
-
-	def test_validate_coupon_code_rejections(self):
-		from frappe.utils import add_days, nowdate
-
-		from erpnext.accounts.doctype.pricing_rule.utils import validate_coupon_code
-
-		pricing_rule = frappe.db.get_value("Pricing Rule", {"title": "_Test Pricing Rule for _Test Item"})
-
-		def make_coupon(name, **kwargs):
-			frappe.delete_doc_if_exists("Coupon Code", name)
-			return frappe.get_doc(
-				{
-					"doctype": "Coupon Code",
-					"coupon_name": name,
-					"coupon_code": name,
-					"coupon_type": "Promotional",
-					"pricing_rule": pricing_rule,
-					**kwargs,
-				}
-			).insert(ignore_permissions=True)
-
-		with self.subTest("validity not yet started"):
-			make_coupon("_Test Coupon Future", valid_from=add_days(nowdate(), 5))
-			self.assertRaises(frappe.ValidationError, validate_coupon_code, "_Test Coupon Future")
-
-		with self.subTest("validity expired"):
-			make_coupon("_Test Coupon Expired", valid_upto=add_days(nowdate(), -5))
-			self.assertRaises(frappe.ValidationError, validate_coupon_code, "_Test Coupon Expired")
-
-		with self.subTest("maximum use exhausted"):
-			make_coupon("_Test Coupon Exhausted", maximum_use=2, used=2)
-			self.assertRaises(frappe.ValidationError, validate_coupon_code, "_Test Coupon Exhausted")
-
-		with self.subTest("valid coupon passes"):
-			make_coupon("_Test Coupon Valid", maximum_use=5, used=1, valid_upto=add_days(nowdate(), 5))
-			validate_coupon_code("_Test Coupon Valid")  # no raise
-
-	def test_update_coupon_code_count_cancel_and_exhaust(self):
-		from erpnext.accounts.doctype.pricing_rule.utils import update_coupon_code_count
-
-		pricing_rule = frappe.db.get_value("Pricing Rule", {"title": "_Test Pricing Rule for _Test Item"})
-		frappe.delete_doc_if_exists("Coupon Code", "_Test Coupon Count")
-		frappe.get_doc(
-			{
-				"doctype": "Coupon Code",
-				"coupon_name": "_Test Coupon Count",
-				"coupon_code": "_Test Coupon Count",
-				"coupon_type": "Promotional",
-				"pricing_rule": pricing_rule,
-				"maximum_use": 2,
-				"used": 1,
-			}
-		).insert(ignore_permissions=True)
-
-		# cancelling a transaction releases one use
-		update_coupon_code_count("_Test Coupon Count", "cancelled")
-		self.assertEqual(frappe.db.get_value("Coupon Code", "_Test Coupon Count", "used"), 0)
-
-		# using up to the maximum is allowed, beyond it is rejected
-		update_coupon_code_count("_Test Coupon Count", "used")
-		update_coupon_code_count("_Test Coupon Count", "used")
-		self.assertEqual(frappe.db.get_value("Coupon Code", "_Test Coupon Count", "used"), 2)
-		self.assertRaises(frappe.ValidationError, update_coupon_code_count, "_Test Coupon Count", "used")

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.py

@@ -90,7 +90,7 @@ class CurrencyExchangeSettings(Document):
 		try:
 			response = requests.get(api_url, params=params)
 		except requests.exceptions.RequestException as e:
-			frappe.throw(_("Error: {0}").format(str(e)))
+			frappe.throw("Error: " + str(e))
 
 		response.raise_for_status()
 		value = response.json()

erpnext/accounts/doctype/dunning/dunning.py

@@ -85,7 +85,7 @@ class Dunning(AccountsController):
 			if invoice_currency != self.currency:
 				frappe.throw(
 					_(
-						"The currency of invoice {0} ({1}) is different from the currency of this dunning ({2})."
+						"The currency of invoice {} ({}) is different from the currency of this dunning ({})."
 					).format(
 						frappe.get_desk_link(
 							"Sales Invoice",
@@ -248,7 +248,8 @@ def get_dunning_letter_text(dunning_type: str, doc: str | dict, language: str |
 	DOCTYPE = "Dunning Letter Text"
 	FIELDS = ["body_text", "closing_text", "language"]
 
-	doc = frappe.parse_json(doc)
+	if isinstance(doc, str):
+		doc = json.loads(doc)
 
 	if not language:
 		language = doc.get("language")

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js

@@ -136,7 +136,7 @@ frappe.ui.form.on("Exchange Rate Revaluation Account", {
 var get_account_details = function (frm, cdt, cdn) {
 	var row = frappe.get_doc(cdt, cdn);
 	if (!frm.doc.company || !frm.doc.posting_date) {
-		frappe.throw(__("Please select Company and Posting Date to get entries"));
+		frappe.throw(__("Please select Company and Posting Date to getting entries"));
 	}
 	frappe.call({
 		method: "erpnext.accounts.doctype.exchange_rate_revaluation.exchange_rate_revaluation.get_account_details",

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -8,7 +8,7 @@ from frappe import _, qb
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
 from frappe.query_builder import Criterion, Order
-from frappe.query_builder.functions import Max, NullIf, Sum
+from frappe.query_builder.functions import NullIf, Sum
 from frappe.utils import flt, get_link_to_form
 
 import erpnext
@@ -73,7 +73,7 @@ class ExchangeRateRevaluation(Document):
 
 	def validate_mandatory(self):
 		if not (self.company and self.posting_date):
-			frappe.throw(_("Please select Company and Posting Date to get entries"))
+			frappe.throw(_("Please select Company and Posting Date to getting entries"))
 
 	def before_submit(self):
 		self.remove_accounts_without_gain_loss()
@@ -188,17 +188,11 @@ class ExchangeRateRevaluation(Document):
 				accounts = [x[0] for x in res]
 
 			if accounts:
-				gle = qb.DocType("GL Entry")
+				having_clause = (qb.Field("balance") != qb.Field("balance_in_account_currency")) & (
+					(qb.Field("balance_in_account_currency") != 0) | (qb.Field("balance") != 0)
+				)
 
-				# balance expressions reused in both SELECT and HAVING; postgres can't reference a
-				# SELECT alias inside HAVING, so the aggregate expression must be repeated there.
-				balance = Sum(gle.debit) - Sum(gle.credit)
-				balance_in_account_currency = Sum(gle.debit_in_account_currency) - Sum(
-					gle.credit_in_account_currency
-				)
-				having_clause = (balance != balance_in_account_currency) & (
-					(balance_in_account_currency != 0) | (balance != 0)
-				)
+				gle = qb.DocType("GL Entry")
 
 				# conditions
 				conditions = []
@@ -215,15 +209,17 @@ class ExchangeRateRevaluation(Document):
 					qb.from_(gle)
 					.select(
 						gle.account,
-						# grouped by NullIf(party_type/party, ""); the bare columns + account_currency are
-						# constant per group -> Max() keeps the GROUP BY valid on postgres with the same value.
-						Max(gle.party_type).as_("party_type"),
-						Max(gle.party).as_("party"),
-						Max(gle.account_currency).as_("account_currency"),
-						balance_in_account_currency.as_("balance_in_account_currency"),
-						balance.as_("balance"),
-						# zero_balance is recomputed in Python below (after rounding), so the SQL value is
-						# unused -- dropped (it used MySQL's XOR operator, which postgres lacks).
+						gle.party_type,
+						gle.party,
+						gle.account_currency,
+						(Sum(gle.debit_in_account_currency) - Sum(gle.credit_in_account_currency)).as_(
+							"balance_in_account_currency"
+						),
+						(Sum(gle.debit) - Sum(gle.credit)).as_("balance"),
+						(Sum(gle.debit) - Sum(gle.credit) == 0)
+						^ (Sum(gle.debit_in_account_currency) - Sum(gle.credit_in_account_currency) == 0).as_(
+							"zero_balance"
+						),
 					)
 					.where(Criterion.all(conditions))
 					.groupby(gle.account, NullIf(gle.party_type, ""), NullIf(gle.party, ""))
@@ -350,14 +346,12 @@ class ExchangeRateRevaluation(Document):
 		zero_balance_jv = self.make_jv_for_zero_balance()
 		if zero_balance_jv:
 			frappe.msgprint(
-				_("Zero Balance Journal: {0}").format(get_link_to_form("Journal Entry", zero_balance_jv.name))
+				f"Zero Balance Journal: {get_link_to_form('Journal Entry', zero_balance_jv.name)}"
 			)
 
 		revaluation_jv = self.make_jv_for_revaluation()
 		if revaluation_jv:
-			frappe.msgprint(
-				_("Revaluation Journal: {0}").format(get_link_to_form("Journal Entry", revaluation_jv.name))
-			)
+			frappe.msgprint(f"Revaluation Journal: {get_link_to_form('Journal Entry', revaluation_jv.name)}")
 
 		return {
 			"revaluation_jv": revaluation_jv.name if revaluation_jv else None,
@@ -601,22 +595,17 @@ def calculate_exchange_rate_using_last_gle(company, account, party_type, party):
 			.select(gl.voucher_type, gl.voucher_no)
 			.where(Criterion.all(conditions))
 			.orderby(gl.posting_date, order=Order.desc)
-			.orderby(gl.name, order=Order.desc)
 			.limit(1)
 			.run()[0]
 		)
 
 		last_exchange_rate = (
 			qb.from_(gl)
-			.select(
-				(gl.debit - gl.credit)
-				/ NullIf(gl.debit_in_account_currency - gl.credit_in_account_currency, 0)
-			)
+			.select((gl.debit - gl.credit) / (gl.debit_in_account_currency - gl.credit_in_account_currency))
 			.where(
 				(gl.voucher_type == voucher_type) & (gl.voucher_no == voucher_no) & (gl.account == account)
 			)
 			.orderby(gl.posting_date, order=Order.desc)
-			.orderby(gl.name, order=Order.desc)
 			.limit(1)
 			.run()[0][0]
 		)
@@ -633,8 +622,6 @@ def get_account_details(
 	party: str | None = None,
 	rounding_loss_allowance: float = 0.0,
 ):
-	frappe.has_permission("Account", doc=account, throw=True)
-
 	if not (company and posting_date):
 		frappe.throw(_("Company and Posting Date is mandatory"))
 

erpnext/accounts/doctype/exchange_rate_revaluation/test_exchange_rate_revaluation.py

@@ -15,11 +15,11 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestExchangeRateRevaluation(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.company = "_Test Company"
-		self.item = "_Test Item"
-		self.customer = "_Test Customer"
-		self.cost_center = "Main - _TC"
-		self.debtors_usd = "_Test Receivable USD - _TC"
+		self.create_company()
+		self.create_usd_receivable_account()
+		self.create_item()
+		self.create_customer()
+		self.clear_old_entries()
 		self.set_system_and_company_settings()
 
 	def set_system_and_company_settings(self):

erpnext/accounts/doctype/financial_report_template/financial_report_engine.py

@@ -12,9 +12,8 @@ from typing import Any, Union
 import frappe
 from frappe import _
 from frappe.database.operator_map import OPERATOR_MAP
-from frappe.model import numeric_fieldtypes
 from frappe.query_builder import Case
-from frappe.query_builder.functions import Cast_, Sum
+from frappe.query_builder.functions import Sum
 from frappe.utils import cstr, date_diff, flt, getdate
 from frappe.utils.xlsxutils import XLSXMetadata, XLSXStyleBuilder
 from pypika.terms import Bracket, LiteralValue
@@ -865,15 +864,8 @@ class FilterExpressionParser:
 		field = getattr(table, field_name, None)
 		operator_fn = OPERATOR_MAP.get(operator.casefold())
 
-		if "like" in operator.casefold():
-			if "%" not in value:
-				value = f"%{value}%"
-			# Postgres has no LIKE/ILIKE operator for non-text columns; MariaDB implicitly casts
-			# the numeric column to text. Cast a numeric/Check Account field to varchar so the
-			# match runs on both engines and reproduces MariaDB's result.
-			meta_field = frappe.get_meta("Account").get_field(field_name)
-			if meta_field and meta_field.fieldtype in numeric_fieldtypes:
-				field = Cast_(field, "varchar")
+		if "like" in operator.casefold() and "%" not in value:
+			value = f"%{value}%"
 
 		return operator_fn(field, value)
 
@@ -1032,7 +1024,8 @@ class FormulaFieldUpdater:
 def get_filtered_accounts(company: str, account_rows: str | list):
 	frappe.has_permission("Financial Report Template", ptype="read", throw=True)
 
-	account_rows = [frappe._dict(row) for row in frappe.parse_json(account_rows)]
+	if isinstance(account_rows, str):
+		account_rows = json.loads(account_rows, object_hook=frappe._dict)
 
 	return DataCollector.get_filtered_accounts(company, account_rows)
 

erpnext/accounts/doctype/fiscal_year/fiscal_year.py

@@ -72,8 +72,10 @@ class FiscalYear(Document):
 
 		if existing_fiscal_years:
 			for existing in existing_fiscal_years:
-				company_for_existing = frappe.get_all(
-					"Fiscal Year Company", filters={"parent": existing.name}, pluck="company"
+				company_for_existing = frappe.db.sql_list(
+					"""select company from `tabFiscal Year Company`
+					where parent=%s""",
+					existing.name,
 				)
 
 				overlap = False
@@ -107,9 +109,6 @@ def auto_create_fiscal_year():
 	)
 
 	for d in fiscal_year:
-		# savepoint so a duplicate-year INSERT (Fiscal Year autoname=field:year) that aborts the
-		# statement doesn't poison the whole scheduler transaction on Postgres and kill the next iteration
-		frappe.db.savepoint("auto_create_fiscal_year")
 		try:
 			current_fy = frappe.get_doc("Fiscal Year", d[0])
 
@@ -130,7 +129,7 @@ def auto_create_fiscal_year():
 
 			new_fy.insert(ignore_permissions=True)
 		except frappe.NameError:
-			frappe.db.rollback(save_point="auto_create_fiscal_year")
+			pass
 
 
 def get_from_and_to_date(fiscal_year):

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -7,7 +7,6 @@ from frappe import _
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
 from frappe.model.naming import set_name_from_naming_options
-from frappe.query_builder.functions import Sum
 from frappe.utils import create_batch, flt, fmt_money, now
 
 import erpnext
@@ -332,12 +331,10 @@ def validate_balance_type(account, adv_adj=False):
 	if not adv_adj and account:
 		balance_must_be = frappe.get_cached_value("Account", account, "balance_must_be")
 		if balance_must_be:
-			gle = frappe.qb.DocType("GL Entry")
-			balance = (
-				frappe.qb.from_(gle)
-				.select(Sum(gle.debit) - Sum(gle.credit))
-				.where((gle.is_cancelled == 0) & (gle.account == account))
-				.run()
+			balance = frappe.db.sql(
+				"""select sum(debit) - sum(credit)
+				from `tabGL Entry` where is_cancelled = 0 and account = %s""",
+				account,
 			)[0][0]
 
 			if (balance_must_be == "Debit" and flt(balance) < 0) or (
@@ -351,48 +348,44 @@ def validate_balance_type(account, adv_adj=False):
 def update_outstanding_amt(
 	account, party_type, party, against_voucher_type, against_voucher, on_cancel=False
 ):
-	gle = frappe.qb.DocType("GL Entry")
-
-	conditions = (
-		(gle.against_voucher_type == against_voucher_type)
-		& (gle.against_voucher == against_voucher)
-		& (gle.voucher_type != "Invoice Discounting")
-	)
 	if party_type and party:
-		conditions &= (gle.party_type == party_type) & (gle.party == party)
+		party_condition = " and party_type={} and party={}".format(
+			frappe.db.escape(party_type), frappe.db.escape(party)
+		)
+	else:
+		party_condition = ""
 
 	if against_voucher_type == "Sales Invoice":
 		party_account = frappe.get_cached_value(against_voucher_type, against_voucher, "debit_to")
-		conditions &= gle.account.isin([account, party_account])
+		account_condition = f"and account in ({frappe.db.escape(account)}, {frappe.db.escape(party_account)})"
 	else:
-		conditions &= gle.account == account
+		account_condition = f" and account = {frappe.db.escape(account)}"
 
 	# get final outstanding amt
 	bal = flt(
-		frappe.qb.from_(gle)
-		.select(Sum(gle.debit_in_account_currency) - Sum(gle.credit_in_account_currency))
-		.where(conditions)
-		.run()[0][0]
+		frappe.db.sql(
+			f"""
+		select sum(debit_in_account_currency) - sum(credit_in_account_currency)
+		from `tabGL Entry`
+		where against_voucher_type=%s and against_voucher=%s
+		and voucher_type != 'Invoice Discounting'
+		{party_condition} {account_condition}""",
+			(against_voucher_type, against_voucher),
+		)[0][0]
 		or 0.0
 	)
 
 	if against_voucher_type == "Purchase Invoice":
 		bal = -bal
 	elif against_voucher_type == "Journal Entry":
-		je_conditions = (
-			(gle.voucher_type == "Journal Entry")
-			& (gle.voucher_no == against_voucher)
-			& (gle.account == account)
-			& (gle.against_voucher.isnull() | (gle.against_voucher == ""))
-		)
-		if party_type and party:
-			je_conditions &= (gle.party_type == party_type) & (gle.party == party)
-
 		against_voucher_amount = flt(
-			frappe.qb.from_(gle)
-			.select(Sum(gle.debit_in_account_currency) - Sum(gle.credit_in_account_currency))
-			.where(je_conditions)
-			.run()[0][0]
+			frappe.db.sql(
+				f"""
+			select sum(debit_in_account_currency) - sum(credit_in_account_currency)
+			from `tabGL Entry` where voucher_type = 'Journal Entry' and voucher_no = %s
+			and account = %s and (against_voucher is null or against_voucher='') {party_condition}""",
+				(against_voucher, account),
+			)[0][0]
 		)
 
 		if not against_voucher_amount:
@@ -471,25 +464,6 @@ def on_doctype_update():
 	frappe.db.add_index("GL Entry", ["posting_date", "company"])
 	frappe.db.add_index("GL Entry", ["party_type", "party"])
 
-	if frappe.db.db_type == "postgres":
-		# Postgres-only partial/covering indexes for the financial reports (General Ledger, Trial
-		# Balance, Balance Sheet, P&L), which always filter `is_cancelled = 0` and scope by company.
-		# `where`/`include` are no-ops on MariaDB and its optimizer ignores these anyway, so they are
-		# added only on postgres to avoid dead write overhead on this insert-hot table.
-		frappe.db.add_index(
-			"GL Entry",
-			["company", "posting_date", "account"],
-			index_name="gle_active_detail",
-			where="is_cancelled = 0",
-		)
-		frappe.db.add_index(
-			"GL Entry",
-			["company", "account", "posting_date"],
-			index_name="gle_active_cover",
-			where="is_cancelled = 0",
-			include=["debit", "credit"],
-		)
-
 
 def rename_gle_sle_docs():
 	for doctype in ["GL Entry", "Stock Ledger Entry"]:
@@ -506,14 +480,10 @@ def rename_temporarily_named_docs(doctype):
 			oldname = doc.name
 			set_name_from_naming_options(autoname, doc)
 			newname = doc.name
-			dt = frappe.qb.DocType(doctype)
-			(
-				frappe.qb.update(dt)
-				.set(dt.name, newname)
-				.set(dt.to_rename, 0)
-				.set(dt.modified, now())
-				.where(dt.name == oldname)
-			).run()
+			frappe.db.sql(
+				f"UPDATE `tab{doctype}` SET name = %s, to_rename = 0, modified = %s where name = %s",
+				(newname, now(), oldname),
+			)
 
 			for hook_type in ("on_gle_rename", "on_sle_rename"):
 				for hook in frappe.get_hooks(hook_type):

erpnext/accounts/doctype/gl_entry/test_gl_entry.py

@@ -26,17 +26,12 @@ class TestGLEntry(ERPNextTestSuite):
 		jv.flags.ignore_validate = True
 		jv.submit()
 
-		round_off_entry = frappe.get_all(
-			"GL Entry",
-			filters={
-				"voucher_type": "Journal Entry",
-				"voucher_no": jv.name,
-				"account": "_Test Write Off - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"debit": 0,
-				"credit": 0.01,
-			},
-			pluck="name",
+		round_off_entry = frappe.db.sql(
+			"""select name from `tabGL Entry`
+			where voucher_type='Journal Entry' and voucher_no = %s
+			and account='_Test Write Off - _TC' and cost_center='_Test Cost Center - _TC'
+			and debit = 0 and credit = '.01'""",
+			jv.name,
 		)
 
 		self.assertTrue(round_off_entry)
@@ -60,9 +55,8 @@ class TestGLEntry(ERPNextTestSuite):
 		)
 
 		self.assertTrue(all(entry.to_rename == 1 for entry in gl_entries))
-		series = frappe.qb.DocType("Series")
-		old_naming_series_current_value = (
-			frappe.qb.from_(series).select(series["current"]).where(series.name == naming_series).run()
+		old_naming_series_current_value = frappe.db.sql(
+			"SELECT current from tabSeries where name = %s", naming_series
 		)[0][0]
 
 		rename_gle_sle_docs()
@@ -79,8 +73,8 @@ class TestGLEntry(ERPNextTestSuite):
 			all(new.name != old.name for new, old in zip(gl_entries, new_gl_entries, strict=False))
 		)
 
-		new_naming_series_current_value = (
-			frappe.qb.from_(series).select(series["current"]).where(series.name == naming_series).run()
+		new_naming_series_current_value = frappe.db.sql(
+			"SELECT current from tabSeries where name = %s", naming_series
 		)[0][0]
 		self.assertEqual(old_naming_series_current_value + 2, new_naming_series_current_value)
 

erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py

@@ -317,50 +317,58 @@ class InvoiceDiscounting(AccountsController):
 
 
 @frappe.whitelist()
-def get_invoices(filters: str | dict):
-	filters = frappe._dict(frappe.parse_json(filters))
-	si = frappe.qb.DocType("Sales Invoice")
-	di = frappe.qb.DocType("Discounted Invoice")
-
-	discounted = frappe.qb.from_(di).select(di.sales_invoice).where(di.docstatus == 1)
-
-	query = (
-		frappe.qb.from_(si)
-		.select(
-			si.name.as_("sales_invoice"),
-			si.customer,
-			si.posting_date,
-			si.outstanding_amount,
-			si.debit_to,
-		)
-		.where((si.docstatus == 1) & (si.outstanding_amount > 0) & si.name.notin(discounted))
-	)
-
+def get_invoices(filters: str):
+	filters = frappe._dict(json.loads(filters))
+	cond = []
 	if filters.customer:
-		query = query.where(si.customer == filters.customer)
+		cond.append("customer=%(customer)s")
 	if filters.from_date:
-		query = query.where(si.posting_date >= filters.from_date)
+		cond.append("posting_date >= %(from_date)s")
 	if filters.to_date:
-		query = query.where(si.posting_date <= filters.to_date)
+		cond.append("posting_date <= %(to_date)s")
 	if filters.min_amount:
-		query = query.where(si.base_grand_total >= filters.min_amount)
+		cond.append("base_grand_total >= %(min_amount)s")
 	if filters.max_amount:
-		query = query.where(si.base_grand_total <= filters.max_amount)
+		cond.append("base_grand_total <= %(max_amount)s")
 
-	return query.run(as_dict=1)
+	where_condition = ""
+	if cond:
+		where_condition += " and " + " and ".join(cond)
+
+	return frappe.db.sql(
+		"""
+		select
+			name as sales_invoice,
+			customer,
+			posting_date,
+			outstanding_amount,
+			debit_to
+		from `tabSales Invoice` si
+		where
+			docstatus = 1
+			and outstanding_amount > 0
+			%s
+			and not exists(select di.name from `tabDiscounted Invoice` di
+				where di.docstatus=1 and di.sales_invoice=si.name)
+	"""
+		% where_condition,
+		filters,
+		as_dict=1,
+	)
 
 
 def get_party_account_based_on_invoice_discounting(sales_invoice):
 	party_account = None
-	par = frappe.qb.DocType("Invoice Discounting")
-	ch = frappe.qb.DocType("Discounted Invoice")
-	invoice_discounting = (
-		frappe.qb.from_(par)
-		.inner_join(ch)
-		.on(par.name == ch.parent)
-		.select(par.accounts_receivable_discounted, par.accounts_receivable_unpaid, par.status)
-		.where((par.docstatus == 1) & (ch.sales_invoice == sales_invoice))
-		.run(as_dict=1)
+	invoice_discounting = frappe.db.sql(
+		"""
+		select par.accounts_receivable_discounted, par.accounts_receivable_unpaid, par.status
+		from `tabInvoice Discounting` par, `tabDiscounted Invoice` ch
+		where par.name=ch.parent
+			and par.docstatus=1
+			and ch.sales_invoice = %s
+	""",
+		(sales_invoice),
+		as_dict=1,
 	)
 	if invoice_discounting:
 		if invoice_discounting[0].status == "Disbursed":

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -28,7 +28,6 @@ from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger
 )
 from erpnext.accounts.doctype.tax_withholding_entry.tax_withholding_entry import JournalTaxWithholding
 from erpnext.accounts.party import get_party_account
-from erpnext.accounts.services.gl_validator import validate_opening_entry_against_pcv
 from erpnext.accounts.utils import (
 	cancel_exchange_gain_loss_journal,
 	get_account_currency,
@@ -150,9 +149,6 @@ class JournalEntry(AccountsController):
 		if not self.is_opening:
 			self.is_opening = "No"
 
-		if self.is_opening == "Yes":
-			validate_opening_entry_against_pcv(self.company)
-
 		self.clearance_date = None
 
 		self.validate_party()
@@ -488,6 +484,12 @@ class JournalEntry(AccountsController):
 							d.idx, d.account, d.party_type
 						)
 					)
+			elif d.party_type or d.party:
+				frappe.throw(
+					_(
+						"Row {0}: Party Type or Party can only be set for Receivable / Payable account, but account {1} is of type {2}"
+					).format(d.idx, d.account, account_type or _("None"))
+				)
 
 	def check_credit_limit(self):
 		customers = list(
@@ -893,7 +895,7 @@ class JournalEntry(AccountsController):
 			msgprint(_("'Entries' cannot be empty"), raise_exception=True)
 			return
 
-		self.set_total_debit_credit()
+		self.total_debit, self.total_credit = 0, 0
 		diff = flt(self.difference, self.precision("difference"))
 		if diff:
 			self._apply_difference_to_blank_row(diff, difference_account)

erpnext/accounts/doctype/journal_entry/test_journal_entry.py

@@ -43,18 +43,18 @@ class TestJournalEntry(ERPNextTestSuite):
 
 		if test_voucher.doctype == "Journal Entry":
 			self.assertTrue(
-				frappe.get_all(
-					"Journal Entry Account",
-					filters={"account": "Debtors - _TC", "docstatus": 1, "parent": test_voucher.name},
-					pluck="name",
+				frappe.db.sql(
+					"""select name from `tabJournal Entry Account`
+				where account = %s and docstatus = 1 and parent = %s""",
+					("Debtors - _TC", test_voucher.name),
 				)
 			)
 
 		self.assertFalse(
-			frappe.get_all(
-				"Journal Entry Account",
-				filters={"reference_type": test_voucher.doctype, "reference_name": test_voucher.name},
-				pluck="name",
+			frappe.db.sql(
+				"""select name from `tabJournal Entry Account`
+			where reference_type = %s and reference_name = %s""",
+				(test_voucher.doctype, test_voucher.name),
 			)
 		)
 
@@ -69,14 +69,10 @@ class TestJournalEntry(ERPNextTestSuite):
 		submitted_voucher = frappe.get_doc(test_voucher.doctype, test_voucher.name)
 
 		self.assertTrue(
-			frappe.get_all(
-				"Journal Entry Account",
-				filters={
-					"reference_type": submitted_voucher.doctype,
-					"reference_name": submitted_voucher.name,
-					dr_or_cr: 400,
-				},
-				pluck="name",
+			frappe.db.sql(
+				f"""select name from `tabJournal Entry Account`
+			where reference_type = %s and reference_name = %s and {dr_or_cr}=400""",
+				(submitted_voucher.doctype, submitted_voucher.name),
 			)
 		)
 
@@ -86,20 +82,24 @@ class TestJournalEntry(ERPNextTestSuite):
 
 	def advance_paid_testcase(self, base_jv, test_voucher, dr_or_cr):
 		# Test advance paid field
-		advance_paid = frappe.db.get_value(test_voucher.doctype, test_voucher.name, "advance_paid")
+		advance_paid = frappe.db.sql(
+			"""select advance_paid from `tab{}`
+					where name={}""".format(test_voucher.doctype, "%s"),
+			(test_voucher.name),
+		)
 		payment_against_order = base_jv.get("accounts")[0].get(dr_or_cr)
 
-		self.assertEqual(flt(advance_paid), flt(payment_against_order))
+		self.assertEqual(flt(advance_paid[0][0]), flt(payment_against_order))
 
 	def cancel_against_voucher_testcase(self, test_voucher):
 		if test_voucher.doctype == "Journal Entry":
 			# if test_voucher is a Journal Entry, test cancellation of test_voucher
 			test_voucher.cancel()
 			self.assertFalse(
-				frappe.get_all(
-					"Journal Entry Account",
-					filters={"reference_type": "Journal Entry", "reference_name": test_voucher.name},
-					pluck="name",
+				frappe.db.sql(
+					"""select name from `tabJournal Entry Account`
+				where reference_type='Journal Entry' and reference_name=%s""",
+					test_voucher.name,
 				)
 			)
 
@@ -202,10 +202,10 @@ class TestJournalEntry(ERPNextTestSuite):
 		# cancel
 		jv.cancel()
 
-		gle = frappe.get_all(
-			"GL Entry",
-			filters={"voucher_type": "Sales Invoice", "voucher_no": jv.name},
-			pluck="name",
+		gle = frappe.db.sql(
+			"""select name from `tabGL Entry`
+			where voucher_type='Sales Invoice' and voucher_no=%s""",
+			jv.name,
 		)
 
 		self.assertFalse(gle)
@@ -526,16 +526,9 @@ class TestJournalEntry(ERPNextTestSuite):
 
 		gl_entries = query.run(as_dict=True)
 
-		# MariaDB and Postgres collate `account` differently, so the DB ordering isn't portable;
-		# sort both sides identically before the positional comparison.
-		def _key(row):
-			return tuple(str(row[f]) for f in self.fields)
-
-		gl_entries = sorted(gl_entries, key=_key)
-		expected_gle = sorted(self.expected_gle, key=_key)
-		for i in range(len(expected_gle)):
+		for i in range(len(self.expected_gle)):
 			for field in self.fields:
-				self.assertEqual(expected_gle[i][field], gl_entries[i][field])
+				self.assertEqual(self.expected_gle[i][field], gl_entries[i][field])
 
 	def test_negative_debit_and_credit_with_same_account_head(self):
 		from erpnext.accounts.general_ledger import process_gl_map
@@ -669,6 +662,13 @@ class TestJournalEntry(ERPNextTestSuite):
 		jv.save()
 		self.assertRaises(frappe.ValidationError, jv.submit)
 
+	def test_party_not_allowed_for_non_receivable_payable_account(self):
+		customer = make_customer("_Test New Customer")
+		jv = make_journal_entry(account1="_Test Cash - _TC", account2="_Test Bank - _TC", amount=100, save=False)
+		jv.accounts[0].party_type = "Customer"
+		jv.accounts[0].party = customer
+		self.assertRaises(frappe.ValidationError, jv.save)
+
 	def test_validate_reference_doc_debit_against_sales_order_throws(self):
 		"""Characterize: a debit entry linked to a Sales Order is rejected."""
 		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
@@ -771,29 +771,6 @@ class TestJournalEntry(ERPNextTestSuite):
 		self.assertEqual(blank_row.credit_in_account_currency, 100)
 		self.assertEqual(jv.total_debit, jv.total_credit)
 
-	def test_get_balance_recomputes_difference_ignoring_client_value(self):
-		"""get_balance computes its own difference instead of trusting a stale client-sent value."""
-		jv = frappe.new_doc("Journal Entry")
-		jv.company = "_Test Company"
-		jv.posting_date = nowdate()
-		jv.append(
-			"accounts",
-			{
-				"account": "_Test Cash - _TC",
-				"debit_in_account_currency": 100,
-				"debit": 100,
-				"exchange_rate": 1,
-			},
-		)
-		jv.append("accounts", {"account": "_Test Bank - _TC", "exchange_rate": 1})
-		# a stale/incorrect value as the client might send; get_balance must not rely on it
-		jv.difference = 0
-
-		jv.get_balance()
-		self.assertEqual(jv.accounts[1].credit_in_account_currency, 100)
-		self.assertEqual(jv.total_debit, jv.total_credit)
-		self.assertEqual(jv.difference, 0)
-
 	def test_get_outstanding_invoices_builds_write_off_rows(self):
 		"""Characterize: get_outstanding_invoices adds a party row for each outstanding invoice."""
 		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice

erpnext/accounts/doctype/journal_entry_account/journal_entry_account.json

@@ -44,7 +44,6 @@
   {
    "bold": 1,
    "columns": 4,
-   "fetch_from": "bank_account.account",
    "fieldname": "account",
    "fieldtype": "Link",
    "in_global_search": 1,

erpnext/accounts/doctype/ledger_health/test_ledger_health.py

@@ -12,11 +12,10 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestLedgerHealth(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.company = "_Test Company"
-		self.customer = "_Test Customer"
-		self.debit_to = "Debtors - _TC"
-		self.income_account = "Sales - _TC"
+		self.create_company()
+		self.create_customer()
 		self.configure_monitoring_tool()
+		self.clear_old_entries()
 
 	def configure_monitoring_tool(self):
 		monitor_settings = frappe.get_doc("Ledger Health Monitor")

erpnext/accounts/doctype/ledger_merge/ledger_merge.py

@@ -65,7 +65,6 @@ def start_merge(docname):
 	total = len(ledger_merge.merge_accounts)
 	for row in ledger_merge.merge_accounts:
 		if not row.merged:
-			frappe.db.savepoint("ledger_merge_row")
 			try:
 				merge_account(
 					row.account,
@@ -80,7 +79,8 @@ def start_merge(docname):
 					{"ledger_merge": ledger_merge.name, "current": successful_merges, "total": total},
 				)
 			except Exception:
-				frappe.db.rollback(save_point="ledger_merge_row")
+				if not frappe.in_test:
+					frappe.db.rollback()
 				ledger_merge.log_error("Ledger merge failed")
 			finally:
 				if successful_merges == total:

erpnext/accounts/doctype/loyalty_point_entry/loyalty_point_entry.py

@@ -39,32 +39,28 @@ def get_loyalty_point_entries(customer, loyalty_program, company, expiry_date=No
 	if not expiry_date:
 		expiry_date = today()
 
-	return frappe.get_all(
-		"Loyalty Point Entry",
-		filters={
-			"customer": customer,
-			"loyalty_program": loyalty_program,
-			"expiry_date": [">=", expiry_date],
-			"loyalty_points": [">", 0],
-			"company": company,
-		},
-		fields=["name", "loyalty_points", "expiry_date", "loyalty_program_tier", "invoice_type", "invoice"],
-		order_by="expiry_date",
+	return frappe.db.sql(
+		"""
+		select name, loyalty_points, expiry_date, loyalty_program_tier, invoice_type, invoice
+		from `tabLoyalty Point Entry`
+		where customer=%s and loyalty_program=%s
+			and expiry_date>=%s and loyalty_points>0 and company=%s
+		order by expiry_date
+	""",
+		(customer, loyalty_program, expiry_date, company),
+		as_dict=1,
 	)
 
 
 def get_redemption_details(customer, loyalty_program, company):
 	return frappe._dict(
-		frappe.get_all(
-			"Loyalty Point Entry",
-			filters={
-				"customer": customer,
-				"loyalty_program": loyalty_program,
-				"loyalty_points": ["<", 0],
-				"company": company,
-			},
-			fields=["redeem_against", {"SUM": "loyalty_points", "as": "loyalty_points"}],
-			group_by="redeem_against",
-			as_list=True,
+		frappe.db.sql(
+			"""
+		select redeem_against, sum(loyalty_points)
+		from `tabLoyalty Point Entry`
+		where customer=%s and loyalty_program=%s and loyalty_points<0 and company=%s
+		group by redeem_against
+	""",
+			(customer, loyalty_program, company),
 		)
 	)

erpnext/accounts/doctype/loyalty_point_entry/test_loyalty_point_entry.py

@@ -2,7 +2,6 @@
 # See license.txt
 
 import frappe
-from frappe.query_builder.functions import Sum
 from frappe.utils import today
 
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
@@ -64,9 +63,13 @@ class TestLoyaltyPointEntry(ERPNextTestSuite):
 		self.assertEqual(doc.loyalty_points, -7)
 
 		# Check balance
-		lpe = frappe.qb.DocType("Loyalty Point Entry")
-		balance = (
-			frappe.qb.from_(lpe).select(Sum(lpe.loyalty_points)).where(lpe.customer == self.customer_name)
-		).run()[0][0]
+		balance = frappe.db.sql(
+			"""
+			SELECT SUM(loyalty_points)
+			FROM `tabLoyalty Point Entry`
+			WHERE customer = %s
+		""",
+			(self.customer_name,),
+		)[0][0]
 
 		self.assertEqual(balance, 3)  # 10 added, 7 redeemed

erpnext/accounts/doctype/loyalty_program/loyalty_program.js

@@ -36,7 +36,7 @@ frappe.ui.form.on("Loyalty Program", {
 							)}
 						</li>
 						<li>
-							${__("One customer can be part of only a single Loyalty Program.")}
+							${__("One customer can be part of only single Loyalty Program.")}
 						</li>
 					</ul>
 				</td></tr>
@@ -62,7 +62,7 @@ frappe.ui.form.on("Loyalty Program", {
 	refresh: function (frm) {
 		if (frm.doc.loyalty_program_type === "Single Tier Program" && frm.doc.collection_rules.length > 1) {
 			frappe.throw(
-				__("Please select the Multiple Tier Program type for more than one collection rule.")
+				__("Please select the Multiple Tier Program type for more than one collection rules.")
 			);
 		}
 	},

erpnext/accounts/doctype/loyalty_program/test_loyalty_program.py

@@ -3,7 +3,6 @@
 import unittest
 
 import frappe
-from frappe.query_builder.functions import Sum
 from frappe.utils import cint, flt, getdate, today
 
 from erpnext.accounts.doctype.loyalty_program.loyalty_program import (
@@ -263,12 +262,14 @@ class TestLoyaltyProgram(ERPNextTestSuite):
 
 def get_points_earned(self):
 	def get_returned_amount():
-		si = frappe.qb.DocType("Sales Invoice")
-		returned_amount = (
-			frappe.qb.from_(si)
-			.select(Sum(si.grand_total))
-			.where((si.docstatus == 1) & (si.is_return == 1) & (si.return_against == self.name))
-		).run()
+		returned_amount = frappe.db.sql(
+			"""
+			select sum(grand_total)
+			from `tabSales Invoice`
+			where docstatus=1 and is_return=1 and ifnull(return_against, '')=%s
+		""",
+			self.name,
+		)
 		return abs(flt(returned_amount[0][0])) if returned_amount else 0
 
 	lp_details = get_loyalty_program_details_with_points(

erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py

@@ -52,14 +52,15 @@ class ModeofPayment(Document):
 
 	def validate_pos_mode_of_payment(self):
 		if not self.enabled:
-			pos_profiles = frappe.get_all(
-				"Sales Invoice Payment",
-				filters={"parenttype": "POS Profile", "mode_of_payment": self.name},
-				pluck="parent",
+			pos_profiles = frappe.db.sql(
+				"""SELECT sip.parent FROM `tabSales Invoice Payment` sip
+				WHERE sip.parenttype = 'POS Profile' and sip.mode_of_payment = %s""",
+				(self.name),
 			)
+			pos_profiles = list(map(lambda x: x[0], pos_profiles))
 
 			if pos_profiles:
 				message = _(
-					"POS Profile {0} contains Mode of Payment {1}. Please remove them to disable this mode."
+					"POS Profile {} contains Mode of Payment {}. Please remove them to disable this mode."
 				).format(frappe.bold(", ".join(pos_profiles)), frappe.bold(str(self.name)))
 				frappe.throw(message, title=_("Not Allowed"))

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js

@@ -74,31 +74,29 @@ frappe.ui.form.on("Opening Invoice Creation Tool", {
 	},
 
 	setup_company_filters: function (frm) {
-		frm.events.apply_company_query_filter(frm, "cost_center", "invoices", { is_group: 0 });
-		frm.events.apply_company_query_filter(frm, "project", "invoices");
-		frm.events.apply_company_query_filter(frm, "project");
-		frm.events.apply_company_query_filter(frm, "cost_center", undefined, { is_group: 0 });
-		frm.events.apply_company_query_filter(frm, "temporary_opening_account", "invoices", {
-			account_type: "Temporary",
-			is_group: 0,
-		});
-	},
-
-	apply_company_query_filter: function (frm, field_name, child_doctype = null, filters = {}) {
-		const query = function (doc) {
+		frm.set_query("cost_center", "invoices", function (doc, cdt, cdn) {
 			return {
 				filters: {
 					company: doc.company,
-					...filters,
 				},
 			};
-		};
+		});
 
-		if (child_doctype) {
-			frm.set_query(field_name, child_doctype, query);
-		} else {
-			frm.set_query(field_name, query);
-		}
+		frm.set_query("cost_center", function (doc) {
+			return {
+				filters: {
+					company: doc.company,
+				},
+			};
+		});
+
+		frm.set_query("temporary_opening_account", "invoices", function (doc, cdt, cdn) {
+			return {
+				filters: {
+					company: doc.company,
+				},
+			};
+		});
 	},
 
 	company: function (frm) {
@@ -122,6 +120,11 @@ frappe.ui.form.on("Opening Invoice Creation Tool", {
 	},
 
 	invoice_type: function (frm) {
+		$.each(frm.doc.invoices, (idx, row) => {
+			row.party_type = frm.doc.invoice_type == "Sales" ? "Customer" : "Supplier";
+			frappe.model.set_value(row.doctype, row.name, "party", "");
+			frappe.model.set_value(row.doctype, row.name, "party_name", "");
+		});
 		frm.clear_table("invoices");
 		frm.refresh_fields();
 		frm.trigger("update_party_labels");
@@ -216,19 +219,7 @@ frappe.ui.form.on("Opening Invoice Creation Tool Item", {
 		});
 	},
 
-	invoices_add: (frm, cdt, cdn) => {
-		const row = frappe.get_doc(cdt, cdn);
-		const field_copy = [];
-
-		["project", "cost_center"].forEach((fieldname) => {
-			if (frm.doc[fieldname]) {
-				frappe.model.set_value(cdt, cdn, fieldname, frm.doc[fieldname]);
-			} else {
-				field_copy.push(fieldname);
-			}
-		});
-
-		frm.script_manager.copy_from_first_row("invoices", row, field_copy);
+	invoices_add: (frm) => {
 		frm.trigger("update_invoice_table");
 	},
 });

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py

@@ -110,7 +110,7 @@ class OpeningInvoiceCreationTool(Document):
 	def validate_mandatory_invoice_fields(self, row):
 		if self.create_missing_party:
 			if not row.party and not row.party_name:
-				frappe.throw(_("Row #{0}: Either Party ID or Party Name is required").format(row.idx))
+				frappe.throw(_("Row #{}: Either Party ID or Party Name is required").format(row.idx))
 
 			if not row.party and row.party_name:
 				row.party = self.add_party(row.party_type, row.party_name)
@@ -120,10 +120,10 @@ class OpeningInvoiceCreationTool(Document):
 
 		else:
 			if not row.party:
-				frappe.throw(_("Row #{0}: Party ID is required").format(row.idx))
+				frappe.throw(_("Row #{}: Party ID is required").format(row.idx))
 			if not frappe.db.exists(row.party_type, row.party):
 				frappe.throw(
-					_("Row #{0}: {1} {2} does not exist.").format(
+					_("Row #{}: {} {} does not exist.").format(
 						row.idx, frappe.bold(row.party_type), frappe.bold(row.party)
 					)
 				)
@@ -133,17 +133,6 @@ class OpeningInvoiceCreationTool(Document):
 			if not row.get(scrub(d)):
 				frappe.throw(mandatory_error_msg.format(row.idx, d, self.invoice_type))
 
-		self.validate_temporary_opening_account(row)
-
-	def validate_temporary_opening_account(self, row):
-		account_type = frappe.get_cached_value("Account", row.temporary_opening_account, "account_type")
-		if account_type != "Temporary":
-			frappe.throw(
-				_("Row #{0}: {1} account is not of type {2}").format(
-					row.idx, row.temporary_opening_account, "Temporary"
-				)
-			)
-
 	def get_invoices(self):
 		invoices = []
 		for row in self.invoices:
@@ -214,7 +203,6 @@ class OpeningInvoiceCreationTool(Document):
 					"description": row.item_name or "Opening Invoice Item",
 					income_expense_account_field: row.temporary_opening_account,
 					"cost_center": cost_center,
-					"project": row.get("project") or self.get("project"),
 				}
 			)
 
@@ -282,13 +270,6 @@ def start_import(invoices):
 	errors = 0
 	names = []
 	for idx, d in enumerate(invoices):
-		# Scope each invoice to a savepoint so a failure only undoes that invoice.
-		# A plain rollback() would discard the whole transaction — including invoices
-		# imported earlier in this batch and the error logs of earlier failures (the
-		# latter only survive on mariadb because the Error Log table is MyISAM; on
-		# postgres they would be lost). Rolling back to a savepoint keeps both.
-		savepoint = f"opening_invoice_{frappe.generate_hash(length=8)}"
-		frappe.db.savepoint(savepoint)
 		try:
 			invoice_number = None
 			if d.invoice_number:
@@ -303,11 +284,11 @@ def start_import(invoices):
 			names.append(doc.name)
 		except Exception:
 			errors += 1
-			frappe.db.rollback(save_point=savepoint)
+			frappe.db.rollback()
 			doc.log_error("Opening invoice creation failed")
 	if errors:
 		frappe.msgprint(
-			_("You had {0} errors while creating opening invoices. Check {1} for more details").format(
+			_("You had {} errors while creating opening invoices. Check {} for more details").format(
 				errors, "<a href='/app/List/Error Log' class='variant-click'>Error Log</a>"
 			),
 			indicator="red",

erpnext/accounts/doctype/opening_invoice_creation_tool/test_opening_invoice_creation_tool.py

@@ -2,12 +2,10 @@
 # See license.txt
 
 import frappe
-from frappe.utils import add_days, today
 
 from erpnext.accounts.doctype.opening_invoice_creation_tool.opening_invoice_creation_tool import (
 	get_temporary_opening_account,
 )
-from erpnext.projects.doctype.project.test_project import make_project
 from erpnext.tests.utils import ERPNextTestSuite
 
 
@@ -16,26 +14,21 @@ class TestOpeningInvoiceCreationTool(ERPNextTestSuite):
 		self,
 		invoice_type="Sales",
 		company=None,
-		invoices=None,
-		project=None,
-		cost_center=None,
+		party_1=None,
+		party_2=None,
+		invoice_number=None,
 		department=None,
-		return_doc=False,
 	):
 		doc = frappe.get_single("Opening Invoice Creation Tool")
 		args = get_opening_invoice_creation_dict(
 			invoice_type=invoice_type,
 			company=company,
-			invoices=invoices,
-			project=project,
-			cost_center=cost_center,
+			party_1=party_1,
+			party_2=party_2,
+			invoice_number=invoice_number,
 			department=department,
 		)
 		doc.update(args)
-
-		if return_doc:
-			return doc
-
 		return doc.make_invoices()
 
 	def test_opening_sales_invoice_creation(self):
@@ -44,8 +37,8 @@ class TestOpeningInvoiceCreationTool(ERPNextTestSuite):
 		self.assertEqual(len(invoices), 2)
 		expected_value = {
 			"keys": ["customer", "outstanding_amount", "status"],
-			0: ["_Test Customer", 200, "Overdue"],
-			1: ["_Test Customer 1", 200, "Overdue"],
+			0: ["_Test Customer", 300, "Overdue"],
+			1: ["_Test Customer 1", 250, "Overdue"],
 		}
 		self.check_expected_values(invoices, expected_value)
 
@@ -62,34 +55,48 @@ class TestOpeningInvoiceCreationTool(ERPNextTestSuite):
 			for field_idx, field in enumerate(expected_value["keys"]):
 				self.assertEqual(si.get(field, ""), expected_value[invoice_idx][field_idx])
 
-	def test_opening_invoice_requires_temporary_account_type(self):
-		doc = self.make_invoices(company="_Test Opening Invoice Company", return_doc=True)
-		doc.invoices[0].temporary_opening_account = "Sales - _TOIC"
-		self.assertRaises(frappe.ValidationError, doc.make_invoices)
-
 	def test_opening_purchase_invoice_creation(self):
 		invoices = self.make_invoices(invoice_type="Purchase", company="_Test Opening Invoice Company")
 
 		self.assertEqual(len(invoices), 2)
 		expected_value = {
 			"keys": ["supplier", "outstanding_amount", "status"],
-			0: ["_Test Supplier", 200, "Overdue"],
-			1: ["_Test Supplier 1", 200, "Overdue"],
+			0: ["_Test Supplier", 300, "Overdue"],
+			1: ["_Test Supplier 1", 250, "Overdue"],
 		}
 		self.check_expected_values(invoices, expected_value, "Purchase")
 
 	def test_opening_sales_invoice_creation_with_missing_debit_account(self):
+		company = "_Test Opening Invoice Company"
 		party_1, party_2 = make_customer("Customer A"), make_customer("Customer B")
 
-		old_default_receivable_account = frappe.db.get_value(
-			"Company", "_Test Opening Invoice Company", "default_receivable_account"
-		)
-		frappe.db.set_value("Company", "_Test Opening Invoice Company", "default_receivable_account", "")
+		old_default_receivable_account = frappe.db.get_value("Company", company, "default_receivable_account")
+		frappe.db.set_value("Company", company, "default_receivable_account", "")
 
-		self.make_invoices(
-			company="_Test Opening Invoice Company",
-			invoices=[{"party": party_1}, {"party": party_2}],
-		)
+		if not frappe.db.exists("Cost Center", "_Test Opening Invoice Company - _TOIC"):
+			cc = frappe.get_doc(
+				{
+					"doctype": "Cost Center",
+					"cost_center_name": "_Test Opening Invoice Company",
+					"is_group": 1,
+					"company": "_Test Opening Invoice Company",
+				}
+			)
+			cc.insert(ignore_mandatory=True)
+			cc2 = frappe.get_doc(
+				{
+					"doctype": "Cost Center",
+					"cost_center_name": "Main",
+					"is_group": 0,
+					"company": "_Test Opening Invoice Company",
+					"parent_cost_center": cc.name,
+				}
+			)
+			cc2.insert()
+
+		frappe.db.set_value("Company", company, "cost_center", "Main - _TOIC")
+
+		self.make_invoices(company="_Test Opening Invoice Company", party_1=party_1, party_2=party_2)
 
 		# Check if missing debit account error raised
 		error_log = frappe.db.exists(
@@ -99,107 +106,71 @@ class TestOpeningInvoiceCreationTool(ERPNextTestSuite):
 		self.assertTrue(error_log)
 
 		# teardown
-		frappe.db.set_value(
-			"Company",
-			"_Test Opening Invoice Company",
-			"default_receivable_account",
-			old_default_receivable_account,
-		)
+		frappe.db.set_value("Company", company, "default_receivable_account", old_default_receivable_account)
 
 	def test_renaming_of_invoice_using_invoice_number_field(self):
+		company = "_Test Opening Invoice Company"
 		party_1, party_2 = make_customer("Customer A"), make_customer("Customer B")
-		invoices = self.make_invoices(
-			company="_Test Opening Invoice Company",
-			invoices=[
-				{"party": party_1, "invoice_number": "TEST-NEW-INV-11"},
-				{"party": party_2},
-			],
+		self.make_invoices(
+			company=company, party_1=party_1, party_2=party_2, invoice_number="TEST-NEW-INV-11"
 		)
 
-		self.assertEqual(invoices[0], "TEST-NEW-INV-11")
+		sales_inv1 = frappe.get_all("Sales Invoice", filters={"customer": "Customer A"})[0].get("name")
+		sales_inv2 = frappe.get_all("Sales Invoice", filters={"customer": "Customer B"})[0].get("name")
+		self.assertEqual(sales_inv1, "TEST-NEW-INV-11")
+
+		# teardown
+		for inv in [sales_inv1, sales_inv2]:
+			doc = frappe.get_doc("Sales Invoice", inv)
+			doc.cancel()
 
 	def test_opening_invoice_with_accounting_dimension(self):
 		invoices = self.make_invoices(
 			invoice_type="Sales", company="_Test Opening Invoice Company", department="Sales - _TOIC"
 		)
 
-		for invoice in invoices:
-			self.assertEqual(frappe.db.get_value("Sales Invoice", invoice, "department"), "Sales - _TOIC")
-
-	def test_opening_entry_project_linking(self):
-		doc = self.make_invoices(
-			company="_Test Opening Invoice Company", invoice_type="Sales", return_doc=True
-		)
-		project_1 = make_project(
-			{"project_name": "Test Opening Invoice projecty 01", "company": "_Test Opening Invoice Company"}
-		)
-		project_2 = make_project(
-			{"project_name": "Test Opening Invoice projecty 02", "company": "_Test Opening Invoice Company"}
-		)
-		doc.invoices[0].project = project_1.name
-		doc.invoices[1].project = project_2.name
-		invoices = doc.make_invoices()
-		sales_invoice_1 = frappe.get_doc("Sales Invoice", invoices[0])
-		sales_invoice_2 = frappe.get_doc("Sales Invoice", invoices[1])
-
-		self.assertEqual(sales_invoice_1.items[0].project, project_1.name)
-		self.assertEqual(sales_invoice_2.items[0].project, project_2.name)
+		expected_value = {
+			"keys": ["customer", "outstanding_amount", "status", "department"],
+			0: ["_Test Customer", 300, "Overdue", "Sales - _TOIC"],
+			1: ["_Test Customer 1", 250, "Overdue", "Sales - _TOIC"],
+		}
+		self.check_expected_values(invoices, expected_value, invoice_type="Sales")
 
 
 def get_opening_invoice_creation_dict(**args):
 	party = "Customer" if args.get("invoice_type", "Sales") == "Sales" else "Supplier"
 	company = args.get("company", "_Test Company")
-	default_invoices = []
-	default_invoice_rows = [
-		{
-			"qty": 1.0,
-			"outstanding_amount": 200,
-			"party": f"_Test {party}",
-			"item_name": "Opening Item",
-			"due_date": add_days(today(), -10),
-			"posting_date": add_days(today(), -15),
-			"temporary_opening_account": get_temporary_opening_account(company),
-		},
-		{
-			"qty": 1.0,
-			"outstanding_amount": 200,
-			"party": f"_Test {party} 1",
-			"item_name": "Opening Item",
-			"due_date": add_days(today(), -10),
-			"posting_date": add_days(today(), -15),
-			"temporary_opening_account": get_temporary_opening_account(company),
-		},
-	]
-
-	for row in args.get("invoices") or default_invoice_rows:
-		default_invoices.append(
-			{
-				"qty": row.get("qty") or 1.0,
-				"outstanding_amount": row.get("outstanding_amount") or 200,
-				"party": row.get("party") or f"_Test {party}",
-				"item_name": row.get("item_name") or "Opening Item",
-				"due_date": row.get("due_date") or add_days(today(), -10),
-				"posting_date": row.get("posting_date") or add_days(today(), -15),
-				"temporary_opening_account": row.get("temporary_opening_account")
-				or get_temporary_opening_account(company),
-				"invoice_number": row.get("invoice_number"),
-				"project": row.get("project"),
-				"cost_center": row.get("cost_center"),
-			}
-		)
 
 	invoice_dict = frappe._dict(
 		{
 			"company": company,
 			"invoice_type": args.get("invoice_type", "Sales"),
-			"project": args.get("project"),
-			"cost_center": args.get("cost_center"),
-			"invoices": default_invoices,
+			"invoices": [
+				{
+					"qty": 1.0,
+					"outstanding_amount": 300,
+					"party": args.get("party_1") or f"_Test {party}",
+					"item_name": "Opening Item",
+					"due_date": "2016-09-10",
+					"posting_date": "2016-09-05",
+					"temporary_opening_account": get_temporary_opening_account(company),
+					"invoice_number": args.get("invoice_number"),
+				},
+				{
+					"qty": 2.0,
+					"outstanding_amount": 250,
+					"party": args.get("party_2") or f"_Test {party} 1",
+					"item_name": "Opening Item",
+					"due_date": "2016-09-10",
+					"posting_date": "2016-09-05",
+					"temporary_opening_account": get_temporary_opening_account(company),
+					"invoice_number": None,
+				},
+			],
 		}
 	)
 
 	invoice_dict.update(args)
-	invoice_dict.invoices = default_invoices
 	return invoice_dict
 
 

erpnext/accounts/doctype/opening_invoice_creation_tool_item/opening_invoice_creation_tool_item.json

@@ -21,8 +21,7 @@
   "qty",
   "accounting_dimensions_section",
   "cost_center",
-  "dimension_col_break",
-  "project"
+  "dimension_col_break"
  ],
  "fields": [
   {
@@ -126,17 +125,11 @@
    "fieldtype": "Data",
    "in_list_view": 1,
    "label": "Party Name"
-  },
-  {
-   "fieldname": "project",
-   "fieldtype": "Link",
-   "label": "Project",
-   "options": "Project"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2026-04-29 17:08:15.617047",
+ "modified": "2026-03-20 02:11:42.023575",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Opening Invoice Creation Tool Item",

erpnext/accounts/doctype/opening_invoice_creation_tool_item/opening_invoice_creation_tool_item.py

@@ -26,7 +26,6 @@ class OpeningInvoiceCreationToolItem(Document):
 		party_name: DF.Data | None
 		party_type: DF.Link | None
 		posting_date: DF.Date | None
-		project: DF.Link | None
 		qty: DF.Data | None
 		supplier_invoice_date: DF.Date | None
 		temporary_opening_account: DF.Link | None

erpnext/accounts/doctype/party_link/party_link.py

@@ -37,7 +37,7 @@ class PartyLink(Document):
 		)
 		if existing_party_link:
 			frappe.throw(
-				_("{0} {1} is already linked with {2} {3}").format(
+				_("{} {} is already linked with {} {}").format(
 					self.primary_role,
 					bold(self.primary_party),
 					self.secondary_role,
@@ -50,7 +50,7 @@ class PartyLink(Document):
 		)
 		if existing_party_link:
 			frappe.throw(
-				_("{0} {1} is already linked with another {2}").format(
+				_("{} {} is already linked with another {}").format(
 					self.secondary_role, self.secondary_party, existing_party_link[0]
 				)
 			)
@@ -60,7 +60,7 @@ class PartyLink(Document):
 		)
 		if existing_party_link:
 			frappe.throw(
-				_("{0} {1} is already linked with another {2}").format(
+				_("{} {} is already linked with another {}").format(
 					self.primary_role, self.primary_party, existing_party_link[0]
 				)
 			)

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -754,21 +754,17 @@ frappe.ui.form.on("Payment Entry", {
 		frm.set_paid_amount_based_on_received_amount = true;
 		let company_currency = frappe.get_doc(":Company", frm.doc.company).default_currency;
 
-		if (frm.doc.paid_amount && frm.doc.source_exchange_rate) {
-			frm.set_value("base_paid_amount", flt(frm.doc.paid_amount) * flt(frm.doc.source_exchange_rate));
-			frm.set_value("base_received_amount", frm.doc.base_paid_amount);
+		if (frm.doc.base_received_amount && frm.doc.source_exchange_rate) {
+			frm.set_value("base_paid_amount", frm.doc.base_received_amount);
 
 			// target exchange rate should always be same as source if both account currencies is same
 			if (frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency) {
 				frm.set_value("target_exchange_rate", frm.doc.source_exchange_rate);
-				frm.set_value("received_amount", frm.doc.paid_amount);
 			} else {
-				const target_rate =
-					flt(frm.doc.target_exchange_rate) ||
-					(company_currency == frm.doc.paid_to_account_currency ? 1 : 0);
-				if (target_rate) {
-					frm.set_value("received_amount", flt(frm.doc.base_received_amount) / target_rate);
-				}
+				frm.set_value(
+					"paid_amount",
+					flt(frm.doc.base_paid_amount) / flt(frm.doc.source_exchange_rate)
+				);
 			}
 
 			// set_unallocated_amount is called by below method,
@@ -784,23 +780,18 @@ frappe.ui.form.on("Payment Entry", {
 	target_exchange_rate: function (frm) {
 		let company_currency = frappe.get_doc(":Company", frm.doc.company).default_currency;
 
-		if (frm.doc.received_amount && frm.doc.target_exchange_rate) {
-			frm.set_value(
-				"base_received_amount",
-				flt(frm.doc.received_amount) * flt(frm.doc.target_exchange_rate)
-			);
-			frm.set_value("base_paid_amount", frm.doc.base_received_amount);
-
-			if (frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency) {
+		if (frm.doc.base_paid_amount && frm.doc.target_exchange_rate) {
+			frm.set_value("base_received_amount", frm.doc.base_paid_amount);
+			if (
+				!frm.doc.source_exchange_rate &&
+				frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency
+			) {
 				frm.set_value("source_exchange_rate", frm.doc.target_exchange_rate);
-				frm.set_value("paid_amount", frm.doc.received_amount);
 			} else {
-				const source_rate =
-					flt(frm.doc.source_exchange_rate) ||
-					(company_currency == frm.doc.paid_from_account_currency ? 1 : 0);
-				if (source_rate) {
-					frm.set_value("paid_amount", flt(frm.doc.base_paid_amount) / source_rate);
-				}
+				frm.set_value(
+					"received_amount",
+					flt(frm.doc.base_received_amount) / flt(frm.doc.target_exchange_rate)
+				);
 			}
 
 			// set_unallocated_amount is called by below method,
@@ -977,7 +968,7 @@ frappe.ui.form.on("Payment Entry", {
 			let to_field = fields[key][1];
 
 			if (filters[from_field] && !filters[to_field]) {
-				frappe.throw(__("Error: {0} is a mandatory field", [to_field.replace(/_/g, " ")]));
+				frappe.throw(__("Error: {0} is mandatory field", [to_field.replace(/_/g, " ")]));
 			} else if (filters[from_field] && filters[from_field] > filters[to_field]) {
 				frappe.throw(
 					__("{0}: {1} must be less than {2}", [

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -9,8 +9,8 @@ import frappe
 from frappe import ValidationError, _, qb, scrub, throw
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
-from frappe.query_builder import Case, Tuple
-from frappe.query_builder.functions import Abs, Count, Max
+from frappe.query_builder import Tuple
+from frappe.query_builder.functions import Count
 from frappe.utils import cint, comma_or, flt, getdate, nowdate
 from frappe.utils.data import comma_and, fmt_money, get_link_to_form
 from pypika.functions import Coalesce, Sum
@@ -514,12 +514,10 @@ class PaymentEntry(AccountsController):
 				invoice_names.add((ref.reference_doctype, ref.reference_name))
 
 		for doctype, name in invoice_names:
-			frappe.db.savepoint("subscription_update")
 			try:
 				doc = frappe.get_doc(doctype, name)
 				doc.refresh_subscription_status()
 			except Exception:
-				frappe.db.rollback(save_point="subscription_update")
 				frappe.log_error(_("Failed to update subscription status for {0} {1}").format(doctype, name))
 
 	def set_missing_values(self):
@@ -623,7 +621,7 @@ class PaymentEntry(AccountsController):
 
 	def validate_payment_type(self):
 		if self.payment_type not in ("Receive", "Pay", "Internal Transfer"):
-			frappe.throw(_("Payment Type must be one of Receive, Pay, or Internal Transfer"))
+			frappe.throw(_("Payment Type must be one of Receive, Pay and Internal Transfer"))
 
 	def validate_party_details(self):
 		if self.party and not frappe.db.exists(self.party_type, self.party):
@@ -680,7 +678,7 @@ class PaymentEntry(AccountsController):
 
 			elif d.reference_name:
 				if not frappe.db.exists(d.reference_doctype, d.reference_name):
-					frappe.throw(_("{0} {1} does not exist").format(_(d.reference_doctype), d.reference_name))
+					frappe.throw(_("{0} {1} does not exist").format(d.reference_doctype, d.reference_name))
 
 				ref_doc = frappe.get_lazy_doc(d.reference_doctype, d.reference_name)
 
@@ -768,19 +766,13 @@ class PaymentEntry(AccountsController):
 	def validate_journal_entry(self):
 		for d in self.get("references"):
 			if d.allocated_amount and d.reference_doctype == "Journal Entry":
-				je_accounts = frappe.get_all(
-					"Journal Entry Account",
-					filters={
-						"account": self.party_account,
-						"party": self.party,
-						"docstatus": 1,
-						"parent": d.reference_name,
-					},
-					or_filters=[
-						["reference_type", "is", "not set"],
-						["reference_type", "in", ["Sales Order", "Purchase Order"]],
-					],
-					fields=["debit", "credit"],
+				je_accounts = frappe.db.sql(
+					"""select debit, credit from `tabJournal Entry Account`
+					where account = %s and party=%s and docstatus = 1 and parent = %s
+					and (reference_type is null or reference_type in ("", "Sales Order", "Purchase Order"))
+					""",
+					(self.party_account, self.party, d.reference_name),
+					as_dict=True,
 				)
 
 				if not je_accounts:
@@ -865,17 +857,27 @@ class PaymentEntry(AccountsController):
 			)
 			base_outstanding = flt(allocated_amount * conversion_rate, base_outstanding_precision)
 
-			ps = frappe.qb.DocType("Payment Schedule")
 			if cancel:
-				(
-					frappe.qb.update(ps)
-					.set(ps.paid_amount, ps.paid_amount - (allocated_amount - discounted_amt))
-					.set(ps.base_paid_amount, ps.base_paid_amount - base_paid_amount)
-					.set(ps.discounted_amount, ps.discounted_amount - discounted_amt)
-					.set(ps.outstanding, ps.outstanding + allocated_amount)
-					.set(ps.base_outstanding, ps.base_outstanding - base_outstanding)
-					.where((ps.parent == key[1]) & (ps.payment_term == key[0]))
-				).run()
+				frappe.db.sql(
+					"""
+					UPDATE `tabPayment Schedule`
+					SET
+						paid_amount = `paid_amount` - %s,
+						base_paid_amount = `base_paid_amount` - %s,
+						discounted_amount = `discounted_amount` - %s,
+						outstanding = `outstanding` + %s,
+						base_outstanding = `base_outstanding` - %s
+					WHERE parent = %s and payment_term = %s""",
+					(
+						allocated_amount - discounted_amt,
+						base_paid_amount,
+						discounted_amt,
+						allocated_amount,
+						base_outstanding,
+						key[1],
+						key[0],
+					),
+				)
 			else:
 				if allocated_amount > outstanding:
 					frappe.throw(
@@ -885,15 +887,26 @@ class PaymentEntry(AccountsController):
 					)
 
 				if allocated_amount and outstanding:
-					(
-						frappe.qb.update(ps)
-						.set(ps.paid_amount, ps.paid_amount + (allocated_amount - discounted_amt))
-						.set(ps.base_paid_amount, ps.base_paid_amount + base_paid_amount)
-						.set(ps.discounted_amount, ps.discounted_amount + discounted_amt)
-						.set(ps.outstanding, ps.outstanding - allocated_amount)
-						.set(ps.base_outstanding, ps.base_outstanding - base_outstanding)
-						.where((ps.parent == key[1]) & (ps.payment_term == key[0]))
-					).run()
+					frappe.db.sql(
+						"""
+						UPDATE `tabPayment Schedule`
+						SET
+							paid_amount = `paid_amount` + %s,
+							base_paid_amount = `base_paid_amount` + %s,
+							discounted_amount = `discounted_amount` + %s,
+							outstanding = `outstanding` - %s,
+							base_outstanding = `base_outstanding` - %s
+						WHERE parent = %s and payment_term = %s""",
+						(
+							allocated_amount - discounted_amt,
+							base_paid_amount,
+							discounted_amt,
+							allocated_amount,
+							base_outstanding,
+							key[1],
+							key[0],
+						),
+					)
 
 	def get_allocated_amount_in_transaction_currency(
 		self, allocated_amount, reference_doctype, reference_docname
@@ -1193,9 +1206,9 @@ class PaymentEntry(AccountsController):
 				continue
 
 			if tax.add_deduct_tax == "Add":
-				included_taxes += flt(tax.base_tax_amount)
+				included_taxes += tax.base_tax_amount
 			else:
-				included_taxes -= flt(tax.base_tax_amount)
+				included_taxes -= tax.base_tax_amount
 
 		return included_taxes
 
@@ -1203,7 +1216,11 @@ class PaymentEntry(AccountsController):
 	# Clear the reference document which doesn't have allocated amount on validate so that form can be loaded fast
 	def clear_unallocated_reference_document_rows(self):
 		self.set("references", self.get("references", {"allocated_amount": ["not in", [0, None, ""]]}))
-		frappe.db.delete("Payment Entry Reference", {"parent": self.name, "allocated_amount": 0})
+		frappe.db.sql(
+			"""delete from `tabPayment Entry Reference`
+			where parent = %s and allocated_amount = 0""",
+			self.name,
+		)
 
 	def set_title(self):
 		if frappe.flags.in_import and self.title:
@@ -1807,7 +1824,8 @@ class PaymentEntry(AccountsController):
 		if not self.references or not matched_payment_requests:
 			return
 
-		matched_payment_requests = frappe.parse_json(matched_payment_requests)
+		if isinstance(matched_payment_requests, str):
+			matched_payment_requests = json.loads(matched_payment_requests)
 
 		# modify matched_payment_requests
 		# like (reference_doctype, reference_name, allocated_amount): payment_request
@@ -1858,7 +1876,7 @@ def get_matched_payment_request_of_references(references=None):
 			PR.reference_doctype,
 			PR.reference_name,
 			PR.outstanding_amount.as_("allocated_amount"),
-			Max(PR.name).as_("payment_request"),  # count == 1 below ⇒ one row per group; postgres-safe
+			PR.name.as_("payment_request"),
 			Count("*").as_("count"),
 		)
 		.where(Tuple(PR.reference_doctype, PR.reference_name, PR.outstanding_amount).isin(refs))
@@ -2012,7 +2030,8 @@ def validate_inclusive_tax(tax, doc):
 
 @frappe.whitelist()
 def get_outstanding_reference_documents(args: str | dict, validate: bool = False):
-	args = frappe.parse_json(args)
+	if isinstance(args, str):
+		args = json.loads(args)
 
 	if args.get("party_type") == "Member":
 		return
@@ -2296,7 +2315,12 @@ def get_orders_to_be_billed(
 	if not voucher_type:
 		return []
 
+	# dynamic dimension filters
+	condition = ""
 	active_dimensions = get_dimensions(True)[0]
+	for dim in active_dimensions:
+		if filters.get(dim.fieldname):
+			condition += f" and {dim.fieldname}={frappe.db.escape(filters.get(dim.fieldname))}"
 
 	if party_account_currency == company_currency:
 		grand_total_field = "base_grand_total"
@@ -2305,38 +2329,38 @@ def get_orders_to_be_billed(
 		grand_total_field = "grand_total"
 		rounded_total_field = "rounded_total"
 
-	voucher = frappe.qb.DocType(voucher_type)
-	invoice_amount = (
-		Case()
-		.when(voucher[rounded_total_field] != 0, voucher[rounded_total_field])
-		.else_(voucher[grand_total_field])
+	orders = frappe.db.sql(
+		"""
+		select
+			name as voucher_no,
+			if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) as invoice_amount,
+			(if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) - advance_paid) as outstanding_amount,
+			transaction_date as posting_date
+		from
+			`tab{voucher_type}`
+		where
+			{party_type} = %s
+			and docstatus = 1
+			and company = %s
+			and status != "Closed"
+			and if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) > advance_paid
+			and abs(100 - per_billed) > 0.01
+			{condition}
+		order by
+			transaction_date, name
+	""".format(
+			**{
+				"rounded_total_field": rounded_total_field,
+				"grand_total_field": grand_total_field,
+				"voucher_type": voucher_type,
+				"party_type": scrub(party_type),
+				"condition": condition,
+			}
+		),
+		(party, company),
+		as_dict=True,
 	)
 
-	query = (
-		frappe.qb.from_(voucher)
-		.select(
-			voucher.name.as_("voucher_no"),
-			invoice_amount.as_("invoice_amount"),
-			(invoice_amount - voucher.advance_paid).as_("outstanding_amount"),
-			voucher.transaction_date.as_("posting_date"),
-		)
-		.where(
-			(voucher[scrub(party_type)] == party)
-			& (voucher.docstatus == 1)
-			& (voucher.company == company)
-			& (voucher.status != "Closed")
-			& (invoice_amount > voucher.advance_paid)
-			& (Abs(100 - voucher.per_billed) > 0.01)
-		)
-	)
-
-	# dynamic dimension filters
-	for dim in active_dimensions:
-		if filters.get(dim.fieldname):
-			query = query.where(voucher[dim.fieldname] == filters.get(dim.fieldname))
-
-	orders = query.orderby(voucher.transaction_date).orderby(voucher.name).run(as_dict=True)
-
 	order_list = []
 	for d in orders:
 		if (
@@ -2385,8 +2409,8 @@ def get_negative_outstanding_invoices(
 	return frappe.db.sql(
 		"""
 		select
-			'{voucher_type}' as voucher_type, name as voucher_no, {account} as account,
-			coalesce(nullif({rounded_total_field}, 0), {grand_total_field}) as invoice_amount,
+			"{voucher_type}" as voucher_type, name as voucher_no, {account} as account,
+			if({rounded_total_field}, {rounded_total_field}, {grand_total_field}) as invoice_amount,
 			outstanding_amount, posting_date,
 			due_date, conversion_rate as exchange_rate
 		from
@@ -2685,7 +2709,7 @@ def get_payment_entry(
 
 	# only Purchase Invoice can be blocked individually
 	if doc.doctype == "Purchase Invoice" and doc.invoice_is_blocked():
-		frappe.msgprint(_("{0} is on hold until {1}").format(doc.name, doc.release_date))
+		frappe.msgprint(_("{0} is on hold till {1}").format(doc.name, doc.release_date))
 	else:
 		if doc.doctype in (
 			"Sales Invoice",
@@ -2795,9 +2819,6 @@ def get_open_payment_requests_for_references(references=None):
 		.where(PR.docstatus == 1)
 		.where(PR.outstanding_amount > 0)  # to avoid old PRs with 0 outstanding amount
 		.orderby(Coalesce(PR.transaction_date, PR.creation), order=frappe.qb.asc)
-		# unique tiebreaker so PRs sharing a transaction_date allocate in the same order on both engines
-		.orderby(PR.creation, order=frappe.qb.asc)
-		.orderby(PR.name, order=frappe.qb.asc)
 	).run(as_dict=True)
 
 	if not response:
@@ -3092,7 +3113,7 @@ def apply_early_payment_discount(paid_amount, received_amount, doc, party_accoun
 		if total_discount:
 			currency = doc.get("currency") if is_multi_currency else doc.company_currency
 			money = frappe.utils.fmt_money(total_discount, currency=currency)
-			frappe.msgprint(_("Discount of {0} applied as per Payment Term").format(money), alert=1)
+			frappe.msgprint(_("Discount of {} applied as per Payment Term").format(money), alert=1)
 
 	return paid_amount, received_amount, total_discount, valid_discounts
 
@@ -3251,28 +3272,27 @@ def get_reference_as_per_payment_terms(
 
 
 def get_paid_amount(dt, dn, party_type, party, account, due_date):
-	gle = frappe.qb.DocType("GL Entry")
 	if party_type == "Customer":
-		dr_or_cr = gle.credit_in_account_currency - gle.debit_in_account_currency
+		dr_or_cr = "credit_in_account_currency - debit_in_account_currency"
 	else:
-		dr_or_cr = gle.debit_in_account_currency - gle.credit_in_account_currency
+		dr_or_cr = "debit_in_account_currency - credit_in_account_currency"
 
-	paid_amount = (
-		frappe.qb.from_(gle)
-		.select(Sum(dr_or_cr))
-		.where(
-			(gle.against_voucher_type == dt)
-			& (gle.against_voucher == dn)
-			& (gle.party_type == party_type)
-			& (gle.party == party)
-			& (gle.account == account)
-			& (gle.due_date == due_date)
-			& (dr_or_cr > 0)
-		)
-		.run()
+	paid_amount = frappe.db.sql(
+		f"""
+		select ifnull(sum({dr_or_cr}), 0) as paid_amount
+		from `tabGL Entry`
+		where against_voucher_type = %s
+			and against_voucher = %s
+			and party_type = %s
+			and party = %s
+			and account = %s
+			and due_date = %s
+			and {dr_or_cr} > 0
+	""",
+		(dt, dn, party_type, party, account, due_date),
 	)
 
-	return (paid_amount[0][0] or 0) if paid_amount else 0
+	return paid_amount[0][0] if paid_amount else 0
 
 
 @frappe.whitelist()

erpnext/accounts/doctype/payment_entry/services/gl_composer.py

@@ -34,14 +34,8 @@ class PaymentEntryGLComposer(BaseGLComposer):
 		self.add_deductions_gl_entries(gl_entries)
 		self.add_tax_gl_entries(gl_entries)
 		add_regional_gl_entries(gl_entries, doc)
-		self.set_transaction_currency_and_rate_in_gl_map(gl_entries, doc)
 		return gl_entries
 
-	def set_transaction_currency_and_rate_in_gl_map(self, gl_entries, doc):
-		for gle in gl_entries:
-			gle.setdefault("transaction_currency", doc.transaction_currency)
-			gle.setdefault("transaction_exchange_rate", doc.transaction_exchange_rate)
-
 	def add_party_gl_entries(self, gl_entries):
 		doc = self.doc
 		if not doc.party_account:

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -818,11 +818,12 @@ class TestPaymentEntry(ERPNextTestSuite):
 			self.assertEqual(expected_gle[gle.account][3], gle.against_voucher)
 
 	def get_gle(self, voucher_no):
-		return frappe.get_all(
-			"GL Entry",
-			filters={"voucher_type": "Payment Entry", "voucher_no": voucher_no},
-			fields=["account", "debit", "credit", "against_voucher"],
-			order_by="account asc",
+		return frappe.db.sql(
+			"""select account, debit, credit, against_voucher
+			from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s
+			order by account asc""",
+			voucher_no,
+			as_dict=1,
 		)
 
 	def test_payment_entry_write_off_difference(self):
@@ -917,19 +918,13 @@ class TestPaymentEntry(ERPNextTestSuite):
 			"Debtors - _TC": {"cost_center": cost_center},
 		}
 
-		gl_entries = frappe.get_all(
-			"GL Entry",
-			filters={"voucher_type": "Payment Entry", "voucher_no": pe.name},
-			fields=[
-				"account",
-				"cost_center",
-				"account_currency",
-				"debit",
-				"credit",
-				"debit_in_account_currency",
-				"credit_in_account_currency",
-			],
-			order_by="account asc",
+		gl_entries = frappe.db.sql(
+			"""select account, cost_center, account_currency, debit, credit,
+			debit_in_account_currency, credit_in_account_currency
+			from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s
+			order by account asc""",
+			pe.name,
+			as_dict=1,
 		)
 
 		self.assertTrue(gl_entries)
@@ -960,19 +955,13 @@ class TestPaymentEntry(ERPNextTestSuite):
 			"Creditors - _TC": {"cost_center": cost_center},
 		}
 
-		gl_entries = frappe.get_all(
-			"GL Entry",
-			filters={"voucher_type": "Payment Entry", "voucher_no": pe.name},
-			fields=[
-				"account",
-				"cost_center",
-				"account_currency",
-				"debit",
-				"credit",
-				"debit_in_account_currency",
-				"credit_in_account_currency",
-			],
-			order_by="account asc",
+		gl_entries = frappe.db.sql(
+			"""select account, cost_center, account_currency, debit, credit,
+			debit_in_account_currency, credit_in_account_currency
+			from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s
+			order by account asc""",
+			pe.name,
+			as_dict=1,
 		)
 
 		self.assertTrue(gl_entries)
@@ -1048,17 +1037,14 @@ class TestPaymentEntry(ERPNextTestSuite):
 				gle.credit_in_account_currency,
 				gle.debit_in_transaction_currency,
 				gle.credit_in_transaction_currency,
-				gle.transaction_currency,
-				gle.transaction_exchange_rate,
 			)
 			.orderby(gle.account)
 			.where(gle.voucher_no == payment_entry.name)
 			.run()
 		)
-		# transaction currency/rate come from the paid-from USD account (company currency is INR)
 		expected_gl_entries = (
-			(paid_from, 0.0, 8440.0, 0.0, 100.0, 0.0, 100.0, "USD", 84.4),
-			("_Test Payable USD - _TC", 8440.0, 0.0, 100.0, 0.0, 100.0, 0.0, "USD", 84.4),
+			(paid_from, 0.0, 8440.0, 0.0, 100.0, 0.0, 100.0),
+			("_Test Payable USD - _TC", 8440.0, 0.0, 100.0, 0.0, 100.0, 0.0),
 		)
 		self.assertEqual(gl_entries, expected_gl_entries)
 
@@ -1124,27 +1110,6 @@ class TestPaymentEntry(ERPNextTestSuite):
 
 		self.assertEqual(gl_entries, expected_gl_entries)
 
-	def test_payment_entry_with_inclusive_tax(self):
-		# inclusive tax built server-side: base_tax_amount is None until apply_taxes()
-		payment_entry = create_payment_entry(paid_amount=1180)
-		payment_entry.append(
-			"taxes",
-			{
-				"account_head": "_Test Account Service Tax - _TC",
-				"charge_type": "On Paid Amount",
-				"rate": 18,
-				"included_in_paid_amount": 1,
-				"add_deduct_tax": "Add",
-				"description": "Service Tax",
-			},
-		)
-		payment_entry.save()
-		payment_entry.submit()
-
-		# 1180 incl 18% => 1000 base + 180 tax
-		self.assertEqual(flt(payment_entry.total_taxes_and_charges, 2), 180.0)
-		self.assertEqual(flt(payment_entry.unallocated_amount, 2), 1000.0)
-
 	def test_payment_entry_against_onhold_purchase_invoice(self):
 		pi = make_purchase_invoice()
 
@@ -1781,18 +1746,9 @@ class TestPaymentEntry(ERPNextTestSuite):
 			.where((gle.voucher_no == self.voucher_no) & (gle.is_cancelled == 0))
 			.orderby(gle.account, gle.debit, gle.credit, order=frappe.qb.desc)
 		).run(as_dict=True)
-		# MariaDB and Postgres collate `account` differently, so the DB ordering isn't portable;
-		# sort both sides identically before the positional comparison.
-		fields = ["account", "debit", "credit"]
-
-		def _key(row):
-			return tuple(str(row[f]) for f in fields)
-
-		gl_entries = sorted(gl_entries, key=_key)
-		expected_gle = sorted(self.expected_gle, key=_key)
-		for row in range(len(expected_gle)):
-			for field in fields:
-				self.assertEqual(expected_gle[row][field], gl_entries[row][field])
+		for row in range(len(self.expected_gle)):
+			for field in ["account", "debit", "credit"]:
+				self.assertEqual(self.expected_gle[row][field], gl_entries[row][field])
 
 	def test_reverse_payment_reconciliation(self):
 		customer = create_customer(frappe.generate_hash(length=10), "INR")

erpnext/accounts/doctype/payment_ledger_entry/test_payment_ledger_entry.py

@@ -10,22 +10,76 @@ from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_ent
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+from erpnext.stock.doctype.item.test_item import create_item
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestPaymentLedgerEntry(ERPNextTestSuite):
 	def setUp(self):
 		self.ple = qb.DocType("Payment Ledger Entry")
-		self.company = "_Test Company"
-		self.cost_center = "Main - _TC"
-		self.warehouse = "Stores - _TC"
-		self.income_account = "Sales - _TC"
-		self.expense_account = "Cost of Goods Sold - _TC"
-		self.debit_to = "Debtors - _TC"
-		self.creditors = "Creditors - _TC"
-		self.bank = "Cash - _TC"
-		self.item = "_Test Item"
-		self.customer = "_Test Customer"
+		self.create_company()
+		self.create_item()
+		self.create_customer()
+		self.clear_old_entries()
+
+	def create_company(self):
+		company_name = "_Test Payment Ledger"
+		company = None
+		if frappe.db.exists("Company", company_name):
+			company = frappe.get_doc("Company", company_name)
+		else:
+			company = frappe.get_doc(
+				{
+					"doctype": "Company",
+					"company_name": company_name,
+					"country": "India",
+					"default_currency": "INR",
+					"create_chart_of_accounts_based_on": "Standard Template",
+					"chart_of_accounts": "Standard",
+				}
+			)
+			company = company.save()
+
+		self.company = company.name
+		self.cost_center = company.cost_center
+		self.warehouse = "All Warehouses - _PL"
+		self.income_account = "Sales - _PL"
+		self.expense_account = "Cost of Goods Sold - _PL"
+		self.debit_to = "Debtors - _PL"
+		self.creditors = "Creditors - _PL"
+
+		# create bank account
+		if frappe.db.exists("Account", "HDFC - _PL"):
+			self.bank = "HDFC - _PL"
+		else:
+			bank_acc = frappe.get_doc(
+				{
+					"doctype": "Account",
+					"account_name": "HDFC",
+					"parent_account": "Bank Accounts - _PL",
+					"company": self.company,
+				}
+			)
+			bank_acc.save()
+			self.bank = bank_acc.name
+
+	def create_item(self):
+		item_name = "_Test PL Item"
+		item = create_item(
+			item_code=item_name, is_stock_item=0, company=self.company, warehouse=self.warehouse
+		)
+		self.item = item if isinstance(item, str) else item.item_code
+
+	def create_customer(self):
+		name = "_Test PL Customer"
+		if frappe.db.exists("Customer", name):
+			self.customer = name
+		else:
+			customer = frappe.new_doc("Customer")
+			customer.customer_name = name
+			customer.type = "Individual"
+			customer.save()
+			self.customer = customer.name
 
 	def create_sales_invoice(
 		self, qty=1, rate=100, posting_date=None, do_not_save=False, do_not_submit=False
@@ -98,6 +152,18 @@ class TestPaymentLedgerEntry(ERPNextTestSuite):
 		)
 		return so
 
+	def clear_old_entries(self):
+		doctype_list = [
+			"GL Entry",
+			"Payment Ledger Entry",
+			"Sales Invoice",
+			"Purchase Invoice",
+			"Payment Entry",
+			"Journal Entry",
+		]
+		for doctype in doctype_list:
+			qb.from_(qb.DocType(doctype)).delete().where(qb.DocType(doctype).company == self.company).run()
+
 	def create_journal_entry(self, acc1=None, acc2=None, amount=0, posting_date=None, cost_center=None):
 		je = frappe.new_doc("Journal Entry")
 		je.posting_date = posting_date or nowdate()

erpnext/accounts/doctype/payment_order/payment_order.py

@@ -60,32 +60,23 @@ class PaymentOrder(Document):
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def get_mop_query(doctype: str, txt: str, searchfield: str, start: int, page_len: int, filters: dict):
-	return frappe.get_all(
-		"Payment Order Reference",
-		filters={"parent": filters.get("parent"), "mode_of_payment": ["like", f"%{txt}%"]},
-		fields=["mode_of_payment"],
-		limit_start=start,
-		limit_page_length=page_len,
-		order_by="",  # match the original query (no ORDER BY); avoid get_all's default sort
-		as_list=True,
+	return frappe.db.sql(
+		""" select mode_of_payment from `tabPayment Order Reference`
+		where parent = %(parent)s and mode_of_payment like %(txt)s
+		limit %(page_len)s offset %(start)s""",
+		{"parent": filters.get("parent"), "start": start, "page_len": page_len, "txt": "%%%s%%" % txt},
 	)
 
 
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def get_supplier_query(doctype: str, txt: str, searchfield: str, start: int, page_len: int, filters: dict):
-	return frappe.get_all(
-		"Payment Order Reference",
-		filters={
-			"parent": filters.get("parent"),
-			"supplier": ["like", f"%{txt}%"],
-			"payment_reference": ["is", "not set"],
-		},
-		fields=["supplier"],
-		limit_start=start,
-		limit_page_length=page_len,
-		order_by="",  # match the original query (no ORDER BY); avoid get_all's default sort
-		as_list=True,
+	return frappe.db.sql(
+		""" select supplier from `tabPayment Order Reference`
+		where parent = %(parent)s and supplier like %(txt)s and
+		(payment_reference is null or payment_reference='')
+		limit %(page_len)s offset %(start)s""",
+		{"parent": filters.get("parent"), "start": start, "page_len": page_len, "txt": "%%%s%%" % txt},
 	)
 
 

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -6,10 +6,8 @@ import frappe
 from frappe import _, msgprint, qb
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
-from frappe.permissions import get_allowed_docs_for_doctype, get_user_permissions
 from frappe.query_builder import Case, Criterion
 from frappe.query_builder.custom import ConstantColumn
-from frappe.query_builder.functions import IfNull
 from frappe.utils import flt, fmt_money, get_link_to_form, getdate, nowdate, today
 
 import erpnext
@@ -75,7 +73,6 @@ class PaymentReconciliation(Document):
 		self.accounting_dimension_filter_conditions = []
 		self.ple_posting_date_filter = []
 		self.dimensions = get_dimensions(with_cost_center_and_project=True)[0]
-		self.user_permissions = get_user_permissions(frappe.session.user)
 
 	def load_from_db(self):
 		# 'modified' attribute is required for `run_doc_method` to work properly.
@@ -156,22 +153,6 @@ class PaymentReconciliation(Document):
 
 		self.add_payment_entries(non_reconciled_payments)
 
-	def get_permitted_dimension_values(self, document_type, reference_doctype):
-		return get_allowed_docs_for_doctype(self.user_permissions.get(document_type, []), reference_doctype)
-
-	def validate_permitted_dimension_value(self, document_type, value, allowed):
-		if value and allowed and value not in allowed:
-			frappe.throw(
-				_("You do not have enough permission to access {0}: {1}").format(_(document_type), value),
-				frappe.PermissionError,
-			)
-
-	def get_user_permission_dimension_condition(self, field, allowed):
-		value_condition = field.isin(allowed)
-		if frappe.get_system_settings("apply_strict_user_permissions"):
-			return value_condition
-		return (IfNull(field, "") == "") | value_condition
-
 	def get_payment_entries(self):
 		party_account = [self.receivable_payable_account]
 
@@ -195,13 +176,8 @@ class PaymentReconciliation(Document):
 		dimensions = {}
 		for x in self.dimensions:
 			dimension = x.fieldname
-			allowed = self.get_permitted_dimension_values(x.document_type, "Payment Entry")
-			if value := self.get(dimension):
-				self.validate_permitted_dimension_value(x.document_type, value, allowed)
-				dimensions[dimension] = value
-			elif allowed:
-				dimensions[dimension] = allowed
-
+			if self.get(dimension):
+				dimensions.update({dimension: self.get(dimension)})
 		condition.update({"accounting_dimensions": dimensions})
 
 		payment_entries = get_advance_payment_entries_for_regional(
@@ -225,12 +201,8 @@ class PaymentReconciliation(Document):
 		# Dimension filters
 		for x in self.dimensions:
 			dimension = x.fieldname
-			allowed = self.get_permitted_dimension_values(x.document_type, "Journal Entry Account")
-			if value := self.get(dimension):
-				self.validate_permitted_dimension_value(x.document_type, value, allowed)
-				conditions.append(jea[dimension] == value)
-			elif allowed:
-				conditions.append(self.get_user_permission_dimension_condition(jea[dimension], allowed))
+			if self.get(dimension):
+				conditions.append(jea[dimension] == self.get(dimension))
 
 		if self.payment_name:
 			conditions.append(je.name.like(f"%%{self.payment_name}%%"))
@@ -776,15 +748,8 @@ class PaymentReconciliation(Document):
 		ple = qb.DocType("Payment Ledger Entry")
 		for x in self.dimensions:
 			dimension = x.fieldname
-			if frappe.db.has_column("Payment Ledger Entry", dimension):
-				allowed = self.get_permitted_dimension_values(x.document_type, "Payment Ledger Entry")
-				if value := self.get(dimension):
-					self.validate_permitted_dimension_value(x.document_type, value, allowed)
-					self.accounting_dimension_filter_conditions.append(ple[dimension] == value)
-				elif allowed:
-					self.accounting_dimension_filter_conditions.append(
-						self.get_user_permission_dimension_condition(ple[dimension], allowed)
-					)
+			if self.get(dimension) and frappe.db.has_column("Payment Ledger Entry", dimension):
+				self.accounting_dimension_filter_conditions.append(ple[dimension] == self.get(dimension))
 
 	def build_qb_filter_conditions(self, get_invoices=False, get_return_invoices=False):
 		self.common_filter_conditions.clear()

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -3,7 +3,7 @@
 
 
 import frappe
-from frappe.utils import add_days, add_years, cint, flt, getdate, nowdate, today
+from frappe.utils import add_days, add_years, flt, getdate, nowdate, today
 from frappe.utils.data import getdate as convert_to_date
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
@@ -1102,101 +1102,6 @@ class TestPaymentReconciliation(ERPNextTestSuite):
 		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
 		self.assertCountEqual(payment_vouchers, [je2.name, pe2.name])
 
-	def test_user_permission_on_accounting_dimension_filters_vouchers(self):
-		test_user = "test@example.com"
-		permitted_ccs = ["_Test Cost Center - _TC", "_Test Cost Center 2 - _TC"]
-		restricted_cc = "_Test Write Off Cost Center - _TC"
-		existing_apply_strict_user_permissions = cint(
-			frappe.db.get_single_value("System Settings", "apply_strict_user_permissions")
-		)
-		self.addCleanup(
-			frappe.db.set_single_value,
-			"System Settings",
-			"apply_strict_user_permissions",
-			existing_apply_strict_user_permissions,
-		)
-		transaction_date = nowdate()
-		rate = 100
-
-		def make_invoice(cost_center):
-			si = self.create_sales_invoice(
-				qty=1, rate=rate, posting_date=transaction_date, do_not_submit=True
-			)
-			si.cost_center = cost_center
-			for row in si.items:
-				row.cost_center = cost_center
-			return si.submit()
-
-		def make_payment(cost_center):
-			pe = self.create_payment_entry(posting_date=transaction_date, amount=rate)
-			pe.cost_center = cost_center
-			return pe.save().submit()
-
-		def make_journal(cost_center):
-			je = self.create_journal_entry(
-				self.bank, self.debit_to, 100, transaction_date, cost_center=cost_center
-			)
-			je.accounts[1].party_type = "Customer"
-			je.accounts[1].party = self.customer
-			return je.save().submit()
-
-		# Vouchers tagged with the two permitted cost centers
-		si_allowed = make_invoice(permitted_ccs[0])
-		pe_allowed = make_payment(permitted_ccs[1])
-		je_allowed = make_journal(permitted_ccs[0])
-
-		# Vouchers tagged with the restricted cost center
-		si_restricted = make_invoice(restricted_cc)
-		pe_restricted = make_payment(restricted_cc)
-		je_restricted = make_journal(restricted_cc)
-
-		# Payment entry with a BLANK cost center
-		pe_blank = make_payment(None)
-
-		for cc in permitted_ccs:
-			frappe.permissions.add_user_permission("Cost Center", cc, test_user)
-
-		# Without strict user permissions
-		frappe.db.set_single_value("System Settings", "apply_strict_user_permissions", 0)
-		with self.set_user(test_user):
-			pr = self.create_payment_reconciliation()
-			pr.get_unreconciled_entries()
-
-		invoice_numbers = [x.get("invoice_number") for x in pr.get("invoices")]
-		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
-		self.assertIn(si_allowed.name, invoice_numbers)
-		self.assertIn(pe_allowed.name, payment_vouchers)
-		self.assertIn(je_allowed.name, payment_vouchers)
-		self.assertIn(pe_blank.name, payment_vouchers)
-		self.assertNotIn(si_restricted.name, invoice_numbers)
-		self.assertNotIn(pe_restricted.name, payment_vouchers)
-		self.assertNotIn(je_restricted.name, payment_vouchers)
-
-		# With strict user permissions
-		frappe.db.set_single_value("System Settings", "apply_strict_user_permissions", 1)
-		with self.set_user(test_user):
-			pr = self.create_payment_reconciliation()
-			pr.get_unreconciled_entries()
-
-		invoice_numbers = [x.get("invoice_number") for x in pr.get("invoices")]
-		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
-		self.assertIn(si_allowed.name, invoice_numbers)
-		self.assertIn(pe_allowed.name, payment_vouchers)
-		self.assertIn(je_allowed.name, payment_vouchers)
-		self.assertNotIn(pe_blank.name, payment_vouchers)
-		self.assertNotIn(si_restricted.name, invoice_numbers)
-		self.assertNotIn(pe_restricted.name, payment_vouchers)
-		self.assertNotIn(je_restricted.name, payment_vouchers)
-
-		# with restricted dimension as a filter
-		with self.set_user(test_user):
-			pr = self.create_payment_reconciliation()
-			pr.cost_center = restricted_cc
-			self.assertRaises(frappe.PermissionError, pr.get_unreconciled_entries)
-
-		for cc in permitted_ccs:
-			frappe.permissions.remove_user_permission("Cost Center", cc, test_user)
-
 	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -629,9 +629,11 @@ class PaymentRequest(Document):
 
 	def check_if_payment_entry_exists(self):
 		if self.status == "Paid":
-			if frappe.db.exists(
+			if frappe.get_all(
 				"Payment Entry Reference",
-				{"reference_name": self.reference_name, "docstatus": ["<", 2]},
+				filters={"reference_name": self.reference_name, "docstatus": ["<", 2]},
+				fields=["parent"],
+				limit=1,
 			):
 				frappe.throw(_("Payment Entry already exists"), title=_("Error"))
 
@@ -740,7 +742,7 @@ def make_payment_request(**args):
 
 	# Schedule-based PRs are allowed only if no Payment Entry exists for this document.
 	# Any existing Payment Entry forces legacy (amount-based) flow.
-	selected_payment_schedules = frappe.parse_json(args.get("schedules")) if args.get("schedules") else []
+	selected_payment_schedules = json.loads(args.get("schedules")) if args.get("schedules") else []
 
 	# Backend guard:
 	# If any Payment Entry exists, schedule-based PRs are not allowed.
@@ -931,7 +933,7 @@ def apply_payment_references(pr, payment_reference):
 
 
 def set_payment_references(payment_schedules):
-	payment_schedules = frappe.parse_json(payment_schedules) if payment_schedules else []
+	payment_schedules = json.loads(payment_schedules) if payment_schedules else []
 	payment_reference = []
 
 	for row in payment_schedules:
@@ -1210,11 +1212,10 @@ def get_dummy_message(doc):
 @frappe.whitelist()
 def get_subscription_details(reference_doctype: str, reference_name: str):
 	if reference_doctype == "Sales Invoice":
-		subscriptions = frappe.get_all(
-			"Subscription Invoice",
-			filters={"invoice": reference_name},
-			fields=["parent as sub_name"],
-			order_by="",  # match the original query (no ORDER BY); avoid get_all's default sort
+		subscriptions = frappe.db.sql(
+			"""SELECT parent as sub_name FROM `tabSubscription Invoice` WHERE invoice=%s""",
+			reference_name,
+			as_dict=1,
 		)
 		subscription_plans = []
 		for subscription in subscriptions: