odoo-addon-mis-builder 17.0.1.3.0__py3-none-any.whl → 18.0.1.1.0__py3-none-any.whl

odoo/addons/mis_builder/models/aep.py

@@ -5,13 +5,14 @@ import logging
 import re
 from collections import defaultdict
 
-from odoo import _, fields
+from odoo import fields
 from odoo.exceptions import UserError
 from odoo.models import expression
 from odoo.tools.float_utils import float_is_zero
 from odoo.tools.safe_eval import datetime, dateutil, safe_eval, time
 
 from .accounting_none import AccountingNone
+from .simple_array import SimpleArray
 
 _logger = logging.getLogger(__name__)
 
@@ -23,72 +24,15 @@ def _is_domain(s):
     return _DOMAIN_START_RE.match(s)
 
 
-class Accumulator:
-    """A simple class to accumulate debit, credit and custom field values.
-
-    >>> acc1 = Accumulator(["f1", "f2"])
-    >>> acc1.debit
-    AccountingNone
-    >>> acc1.credit
-    AccountingNone
-    >>> acc1.custom_fields
-    {'f1': AccountingNone, 'f2': AccountingNone}
-    >>> acc1.add_debit_credit(10, 20)
-    >>> acc1.debit, acc1.credit
-    (10, 20)
-    >>> acc1.add_custom_field("f1", 10)
-    >>> acc1.custom_fields
-    {'f1': 10, 'f2': AccountingNone}
-    >>> acc2 = Accumulator(["f1", "f2"])
-    >>> acc2.add_debit_credit(21, 31)
-    >>> acc2.add_custom_field("f2", 41)
-    >>> acc1 += acc2
-    >>> acc1.debit, acc1.credit
-    (31, 51)
-    >>> acc1.custom_fields
-    {'f1': 10, 'f2': 41}
-    """
-
-    def __init__(self, custom_field_names=()):
-        self.debit = AccountingNone
-        self.credit = AccountingNone
-        self.custom_fields = {
-            custom_field: AccountingNone for custom_field in custom_field_names
-        }
-
-    def has_data(self):
-        return (
-            self.debit is not AccountingNone
-            or self.credit is not AccountingNone
-            or any(v is not AccountingNone for v in self.custom_fields.values())
-        )
-
-    def add_debit_credit(self, debit, credit):
-        self.debit += debit
-        self.credit += credit
-
-    def add_custom_field(self, field, value):
-        self.custom_fields[field] += value
-
-    def __iadd__(self, other):
-        self.debit += other.debit
-        self.credit += other.credit
-        for field in self.custom_fields:
-            self.custom_fields[field] += other.custom_fields[field]
-        return self
-
-
 class AccountingExpressionProcessor:
     """Processor for accounting expressions.
 
-    Expressions of the form
-    <field><mode>(.fieldname)?[accounts][optional move line domain]
+    Expressions of the form <field><mode>[accounts][optional move line domain]
     are supported, where:
         * field is bal, crd, deb, pbal (positive balances only),
-          nbal (negative balance only), fld (custom field)
+          nbal (negative balance only)
         * mode is i (initial balance), e (ending balance),
           p (moves over period)
-        * .fieldname is used only with fldp and specifies the field name to sum
         * there is also a special u mode (unallocated P&L) which computes
           the sum from the beginning until the beginning of the fiscal year
           of the period; it is only meaningful for P&L accounts
@@ -102,7 +46,6 @@ class AccountingExpressionProcessor:
           over the period (it is the same as balp[70]);
         * bali[70,60]: balance of accounts 70 and 60 at the start of period;
         * bale[1%]: balance of accounts starting with 1 at end of period.
-        * fldp.quantity[60%]: sum of the quantity field of moves on accounts 60
 
     How to use:
         * repeatedly invoke parse_expr() for each expression containing
@@ -134,9 +77,8 @@ class AccountingExpressionProcessor:
     MODE_UNALLOCATED = "u"
 
     _ACC_RE = re.compile(
-        r"(?P<field>\bbal|\bpbal|\bnbal|\bcrd|\bdeb|\bfld)"
+        r"(?P<field>\bbal|\bpbal|\bnbal|\bcrd|\bdeb)"
         r"(?P<mode>[piseu])?"
-        r"(?P<fld_name>\.[a-zA-Z0-9_]+)?"
         r"\s*"
         r"(?P<account_sel>_[a-zA-Z0-9]+|\[.*?\])"
         r"\s*"
@@ -150,7 +92,7 @@ class AccountingExpressionProcessor:
             self.currency = companies.mapped("currency_id")
             if len(self.currency) > 1:
                 raise UserError(
-                    _(
+                    self.env._(
                         "If currency_id is not provided, "
                         "all companies must have the same currency."
                     )
@@ -168,8 +110,6 @@ class AccountingExpressionProcessor:
         # a first query to get the initial balance and another
         # to get the variation, so it's a bit slower
         self.smart_end = True
-        # custom field to query and sum
-        self._custom_fields = set()
         # Account model
         self._account_model = self.env[account_model].with_context(active_test=False)
 
@@ -189,7 +129,7 @@ class AccountingExpressionProcessor:
     def _parse_match_object(self, mo):
         """Split a match object corresponding to an accounting variable
 
-        Returns field, mode, fld_name, account domain, move line domain.
+        Returns field, mode, account domain, move line domain.
         """
         domain_eval_context = {
             "ref": self.env.ref,
@@ -198,16 +138,12 @@ class AccountingExpressionProcessor:
             "datetime": datetime,
             "dateutil": dateutil,
         }
-        field, mode, fld_name, account_sel, ml_domain = mo.groups()
+        field, mode, account_sel, ml_domain = mo.groups()
         # handle some legacy modes
         if not mode:
             mode = self.MODE_VARIATION
         elif mode == "s":
             mode = self.MODE_END
-        # custom fields
-        if fld_name:
-            assert fld_name[0] == "."
-            fld_name = fld_name[1:]  # strip leading dot
         # convert account selector to account domain
         if account_sel.startswith("_"):
             # legacy bal_NNN%
@@ -230,7 +166,7 @@ class AccountingExpressionProcessor:
             ml_domain = tuple(safe_eval(ml_domain, domain_eval_context))
         else:
             ml_domain = tuple()
-        return field, mode, fld_name, acc_domain, ml_domain
+        return field, mode, acc_domain, ml_domain
 
     def parse_expr(self, expr):
         """Parse an expression, extracting accounting variables.
@@ -241,7 +177,7 @@ class AccountingExpressionProcessor:
         and mode.
         """
         for mo in self._ACC_RE.finditer(expr):
-            field, mode, fld_name, acc_domain, ml_domain = self._parse_match_object(mo)
+            _, mode, acc_domain, ml_domain = self._parse_match_object(mo)
             if mode == self.MODE_END and self.smart_end:
                 modes = (self.MODE_INITIAL, self.MODE_VARIATION, self.MODE_END)
             else:
@@ -249,40 +185,26 @@ class AccountingExpressionProcessor:
             for mode in modes:
                 key = (ml_domain, mode)
                 self._map_account_ids[key].add(acc_domain)
-            if field == "fld":
-                if mode != self.MODE_VARIATION:
-                    raise UserError(
-                        _(
-                            "`fld` can only be used with mode `p` (variation) "
-                            "in expression %s",
-                            expr,
-                        )
-                    )
-                if not fld_name:
-                    raise UserError(
-                        _("`fld` must have a field name in exression %s", expr)
-                    )
-                self._custom_fields.add(fld_name)
-            else:
-                if fld_name:
-                    raise UserError(
-                        _(
-                            "`%(field)s` cannot have a field name "
-                            "in expression %(expr)s",
-                            field=field,
-                            expr=expr,
-                        )
-                    )
 
     def done_parsing(self):
         """Replace account domains by account ids in map"""
         for key, acc_domains in self._map_account_ids.items():
             all_account_ids = set()
             for acc_domain in acc_domains:
-                acc_domain_with_company = expression.AND(
-                    [acc_domain, [("company_id", "in", self.companies.ids)]]
-                )
-                account_ids = self._account_model.search(acc_domain_with_company).ids
+                # XXX It is apparently not possible to search accounts by code
+                # across multiple companies at once (due to how _search_code is
+                # implemented for instance), so we have to search each company
+                # separately.
+                account_ids = []
+                for company in self.companies:
+                    acc_domain_with_company = expression.AND(
+                        [acc_domain, [("company_ids", "=", company.id)]]
+                    )
+                    account_ids += (
+                        self._account_model.with_company(company)
+                        .search(acc_domain_with_company)
+                        .ids
+                    )
                 self._account_ids_by_acc_domain[acc_domain].update(account_ids)
                 all_account_ids.update(account_ids)
             self._map_account_ids[key] = list(all_account_ids)
@@ -299,7 +221,7 @@ class AccountingExpressionProcessor:
         """
         account_ids = set()
         for mo in self._ACC_RE.finditer(expr):
-            _, _, _, acc_domain, _ = self._parse_match_object(mo)
+            field, mode, acc_domain, ml_domain = self._parse_match_object(mo)
             account_ids.update(self._account_ids_by_acc_domain[acc_domain])
         return account_ids
 
@@ -313,7 +235,7 @@ class AccountingExpressionProcessor:
         aml_domains = []
         date_domain_by_mode = {}
         for mo in self._ACC_RE.finditer(expr):
-            field, mode, fld_name, acc_domain, ml_domain = self._parse_match_object(mo)
+            field, mode, acc_domain, ml_domain = self._parse_match_object(mo)
             aml_domain = list(ml_domain)
             account_ids = set()
             account_ids.update(self._account_ids_by_acc_domain[acc_domain])
@@ -329,8 +251,6 @@ class AccountingExpressionProcessor:
                 aml_domain.append(("credit", "<>", 0.0))
             elif field == "deb":
                 aml_domain.append(("debit", "<>", 0.0))
-            elif fld_name:
-                aml_domain.append((fld_name, "!=", False))
             aml_domains.append(expression.normalize_domain(aml_domain))
             if mode not in date_domain_by_mode:
                 date_domain_by_mode[mode] = self.get_aml_domain_for_dates(
@@ -406,10 +326,10 @@ class AccountingExpressionProcessor:
             aml_model = self.env[aml_model]
         aml_model = aml_model.with_context(active_test=False)
         company_rates = self._get_company_rates(date_to)
-        # {(domain, mode): {account_id: Accumulator}}
+        # {(domain, mode): {account_id: (debit, credit)}}
         self._data = defaultdict(
             lambda: defaultdict(
-                lambda: Accumulator(self._custom_fields),
+                lambda: SimpleArray((AccountingNone, AccountingNone)),
             )
         )
         domain_by_mode = {}
@@ -431,49 +351,36 @@ class AccountingExpressionProcessor:
             # fetch sum of debit/credit, grouped by account_id
             _logger.debug("read_group domain: %s", domain)
             try:
-                accs = aml_model.read_group(
+                accs = aml_model.with_context(
+                    allowed_company_ids=self.companies.ids
+                )._read_group(
                     domain,
-                    [
-                        "debit",
-                        "credit",
-                        "account_id",
-                        "company_id",
-                        *self._custom_fields,
-                    ],
-                    ["account_id", "company_id"],
-                    lazy=False,
+                    groupby=("account_id", "company_id"),
+                    aggregates=("debit:sum", "credit:sum"),
                 )
             except ValueError as e:
                 raise UserError(
-                    _(
+                    self.env._(
                         'Error while querying move line source "%(model_name)s". '
                         "This is likely due to a filter or expression referencing "
                         "a field that does not exist in the model.\n\n"
-                        "The technical error message is: %(exception)s. "
-                    )
-                    % dict(
+                        "The technical error message is: %(exception)s. ",
                         model_name=aml_model._description,
                         exception=e,
                     )
                 ) from e
-            for acc in accs:
-                rate, dp = company_rates[acc["company_id"][0]]
-                debit = acc["debit"] or 0.0
-                credit = acc["credit"] or 0.0
+            for account_id, company_id, debit, credit in accs:
+                rate, dp = company_rates[company_id.id]
+                debit = debit or 0.0
+                credit = credit or 0.0
                 if mode in (self.MODE_INITIAL, self.MODE_UNALLOCATED) and float_is_zero(
                     debit - credit, precision_digits=self.dp
                 ):
                     # in initial mode, ignore accounts with 0 balance
                     continue
-                # due to branches, it's possible to have multiple groups
-                # with the same account_id, because multiple companies can
-                # use the same account
-                account_data = self._data[key][acc["account_id"][0]]
-                account_data.add_debit_credit(debit * rate, credit * rate)
-                for field_name in self._custom_fields:
-                    account_data.add_custom_field(
-                        field_name, acc[field_name] or AccountingNone
-                    )
+                # due to branches, it's possible to have multiple acc
+                # with the same account_id
+                self._data[key][account_id.id] += (debit * rate, credit * rate)
         # compute ending balances by summing initial and variation
         for key in ends:
             domain, mode = key
@@ -481,8 +388,11 @@ class AccountingExpressionProcessor:
             variation_data = self._data[(domain, self.MODE_VARIATION)]
             account_ids = set(initial_data.keys()) | set(variation_data.keys())
             for account_id in account_ids:
-                self._data[key][account_id] += initial_data[account_id]
-                self._data[key][account_id] += variation_data[account_id]
+                di, ci = initial_data.get(account_id, (AccountingNone, AccountingNone))
+                dv, cv = variation_data.get(
+                    account_id, (AccountingNone, AccountingNone)
+                )
+                self._data[key][account_id] = (di + dv, ci + cv)
 
     def replace_expr(self, expr):
         """Replace accounting variables in an expression by their amount.
@@ -493,30 +403,25 @@ class AccountingExpressionProcessor:
         """
 
         def f(mo):
-            field, mode, fld_name, acc_domain, ml_domain = self._parse_match_object(mo)
+            field, mode, acc_domain, ml_domain = self._parse_match_object(mo)
             key = (ml_domain, mode)
             account_ids_data = self._data[key]
             v = AccountingNone
             account_ids = self._account_ids_by_acc_domain[acc_domain]
             for account_id in account_ids:
-                entry = account_ids_data[account_id]
-                debit = entry.debit
-                credit = entry.credit
+                debit, credit = account_ids_data.get(
+                    account_id, (AccountingNone, AccountingNone)
+                )
                 if field == "bal":
                     v += debit - credit
-                elif field == "pbal":
-                    if debit >= credit:
-                        v += debit - credit
-                elif field == "nbal":
-                    if debit < credit:
-                        v += debit - credit
+                elif field == "pbal" and debit >= credit:
+                    v += debit - credit
+                elif field == "nbal" and debit < credit:
+                    v += debit - credit
                 elif field == "deb":
                     v += debit
                 elif field == "crd":
                     v += credit
-                else:
-                    assert field == "fld"
-                    v += entry.custom_fields[fld_name]
             # in initial balance mode, assume 0 is None
             # as it does not make sense to distinguish 0 from "no data"
             if (
@@ -539,7 +444,7 @@ class AccountingExpressionProcessor:
         """
 
         def f(mo):
-            field, mode, fld_name, acc_domain, ml_domain = self._parse_match_object(mo)
+            field, mode, acc_domain, ml_domain = self._parse_match_object(mo)
             key = (ml_domain, mode)
             # first check if account_id is involved in
             # the current expression part
@@ -547,9 +452,9 @@ class AccountingExpressionProcessor:
                 return "(AccountingNone)"
             # here we know account_id is involved in acc_domain
             account_ids_data = self._data[key]
-            entry = account_ids_data[account_id]
-            debit = entry.debit
-            credit = entry.credit
+            debit, credit = account_ids_data.get(
+                account_id, (AccountingNone, AccountingNone)
+            )
             if field == "bal":
                 v = debit - credit
             elif field == "pbal":
@@ -566,9 +471,6 @@ class AccountingExpressionProcessor:
                 v = debit
             elif field == "crd":
                 v = credit
-            else:
-                assert field == "fld"
-                v = entry.custom_fields[fld_name]
             # in initial balance mode, assume 0 is None
             # as it does not make sense to distinguish 0 from "no data"
             if (
@@ -582,11 +484,11 @@ class AccountingExpressionProcessor:
         account_ids = set()
         for expr in exprs:
             for mo in self._ACC_RE.finditer(expr):
-                _, mode, _, acc_domain, ml_domain = self._parse_match_object(mo)
+                field, mode, acc_domain, ml_domain = self._parse_match_object(mo)
                 key = (ml_domain, mode)
                 account_ids_data = self._data[key]
                 for account_id in self._account_ids_by_acc_domain[acc_domain]:
-                    if account_ids_data[account_id].has_data():
+                    if account_id in account_ids_data:
                         account_ids.add(account_id)
 
         for account_id in account_ids:
@@ -602,7 +504,7 @@ class AccountingExpressionProcessor:
         aep.parse_expr(expr)
         aep.done_parsing()
         aep.do_queries(date_from, date_to)
-        return {k: (v.debit, v.credit) for k, v in aep._data[((), mode)].items()}
+        return aep._data[((), mode)]
 
     @classmethod
     def get_balances_initial(cls, companies, date):

odoo/addons/mis_builder/models/aggregate.py

@@ -64,11 +64,11 @@ def _min(*args):
     >>> min()
     Traceback (most recent call last):
       File "<stdin>", line 1, in ?
-    TypeError: min expected at least 1 argument, got 0
+    TypeError: min expected 1 arguments, got 0
     >>> _min()
     Traceback (most recent call last):
       File "<stdin>", line 1, in ?
-    TypeError: min expected at least 1 argument, got 0
+    TypeError: min expected 1 arguments, got 0
     >>> min([])
     Traceback (most recent call last):
       File "<stdin>", line 1, in ?
@@ -107,11 +107,11 @@ def _max(*args):
     >>> max()
     Traceback (most recent call last):
       File "<stdin>", line 1, in ?
-    TypeError: max expected at least 1 argument, got 0
+    TypeError: max expected 1 arguments, got 0
     >>> _max()
     Traceback (most recent call last):
       File "<stdin>", line 1, in ?
-    TypeError: max expected at least 1 argument, got 0
+    TypeError: max expected 1 arguments, got 0
     >>> max([])
     Traceback (most recent call last):
       File "<stdin>", line 1, in ?

odoo/addons/mis_builder/models/kpimatrix.py

@@ -4,7 +4,6 @@
 import logging
 from collections import OrderedDict, defaultdict
 
-from odoo import _
 from odoo.exceptions import UserError
 
 from .accounting_none import AccountingNone
@@ -245,10 +244,9 @@ class KpiMatrix:
                     self.lang, row.style_props, kpi.type, val
                 )
                 if row.kpi.multi and subcol.subkpi:
-                    val_comment = "{}.{} = {}".format(
-                        row.kpi.name,
-                        subcol.subkpi.name,
-                        row.kpi._get_expression_str_for_subkpi(subcol.subkpi),
+                    val_comment = (
+                        f"{row.kpi.name}.{subcol.subkpi.name} = "
+                        f"{row.kpi._get_expression_str_for_subkpi(subcol.subkpi)}"
                     )
                 else:
                     val_comment = f"{row.kpi.name} = {row.kpi.expression}"
@@ -309,7 +307,7 @@ class KpiMatrix:
             common_subkpis = self._common_subkpis([col, base_col])
             if (col.subkpis or base_col.subkpis) and not common_subkpis:
                 raise UserError(
-                    _(
+                    self.env._(
                         "Columns %(descr)s and %(base_descr)s are not comparable",
                         descr=col.description,
                         base_descr=base_col.description,
@@ -395,11 +393,12 @@ class KpiMatrix:
             common_subkpis = self._common_subkpis(sumcols)
             if any(c.subkpis for c in sumcols) and not common_subkpis:
                 raise UserError(
-                    _(
-                        "Sum cannot be computed in column {} "
+                    self.env._(
+                        "Sum cannot be computed in column %s "
                         "because the columns to sum have no "
-                        "common subkpis"
-                    ).format(label)
+                        "common subkpis",
+                        label,
+                    )
                 )
             sum_col = KpiMatrixCol(
                 sumcol_key,

odoo/addons/mis_builder/models/mis_kpi_data.py

@@ -3,7 +3,7 @@
 
 from collections import defaultdict
 
-from odoo import _, api, fields, models
+from odoo import api, fields, models
 from odoo.exceptions import UserError
 from odoo.osv import expression
 
@@ -60,11 +60,9 @@ class MisKpiData(models.AbstractModel):
                 subkpi_name = "." + subkpi_name
             else:
                 subkpi_name = ""
-            rec.name = "{}{}: {} - {}".format(
-                rec.kpi_expression_id.kpi_id.name,
-                subkpi_name,
-                rec.date_from,
-                rec.date_to,
+            rec.name = (
+                f"{rec.kpi_expression_id.kpi_id.name}{subkpi_name}: "
+                f"{rec.date_from} - {rec.date_to}"
             )
 
     @api.model
@@ -99,7 +97,7 @@ class MisKpiData(models.AbstractModel):
                 res_avg[item.kpi_expression_id].append((i_days, item.amount))
             else:
                 raise UserError(
-                    _(
+                    self.env._(
                         "Unexpected accumulation method %(method)s for %(name)s.",
                         method=item.kpi_expression_id.kpi_id.accumulation_method,
                         name=item.name,