ixbrl-viewer 1.4.1__py3-none-any.whl → 1.4.86__py3-none-any.whl

iXBRLViewerPlugin/viewer/src/js/calculation.js

@@ -0,0 +1,213 @@
+// See COPYRIGHT.md for copyright information
+
+import Decimal from 'decimal.js';
+import { setDefault } from './util.js';
+import { Interval } from './interval.js';
+import { FactSet } from './factset.js';
+import { CALC11_ARCROLE, CALC_ARCROLE } from './util.js';
+
+export class Calculation {
+    
+    constructor(fact, calc11) {
+        this.fact = fact;
+        this.calc11 = calc11;
+    }
+
+    /* Resolve calculation relationships to a map of maps of arrays 
+     * (ELR->conceptName->facts) */
+    calculationFacts() {
+        const fact = this.fact;
+        const report = fact.report;
+        if (!this._conceptToFact) {
+            const ctf = {};
+            for (const version of [CALC_ARCROLE, CALC11_ARCROLE]) {
+                const rels = report.getChildRelationships(fact.conceptName(), version)
+                for (const [elr, rr] of Object.entries(rels)) {
+                    setDefault(ctf, version, {});
+                    ctf[version][elr] = {};
+                    if (rr.length > 0) {
+                        const otherFacts = report.getAlignedFacts(fact, {"c": rr.map(r => r.t )});
+                        otherFacts.forEach(otherFact => setDefault(ctf[version][elr], otherFact.conceptName(), new FactSet()).add(otherFact));
+                    }
+                }
+            }
+            this._conceptToFact = ctf;
+        }
+        return this._conceptToFact;
+    }
+
+    hasCalculations() {
+        const ctf = this.calculationFacts();
+        return Object.keys(ctf).length > 0;
+    }
+
+    resolvedCalculations() {
+        const calculations = [];
+        const ctf = this.calculationFacts();
+        for (const [version, o] of Object.entries(ctf)) {
+            for (const [elr, concepts] of Object.entries(o)) {
+                if (Object.keys(concepts).length > 0) {
+                    calculations.push(this.resolvedCalculation(elr, version));
+                }
+            } 
+        }
+        return calculations;
+    }
+
+    /*
+     * Select the ELR which is the best match for a given array of facts
+     */
+    bestELRForFactSet(facts) {
+        const ctf = this.calculationFacts();
+        let bestMatchELR = "";
+        let bestMatchCount = -1;
+        for (const [version, o] of Object.entries(ctf)) {
+            for (const [elr, rr] of Object.entries(o)) {
+                let matchCount = 0;
+                for (const [concept, calcFactSet] of Object.entries(rr)) {
+                    let matched = 0;
+                    for (const calcFact of calcFactSet.items()) {
+                        if (facts.includes(calcFact.vuid)) {
+                            matched = 1;
+                        } 
+                    }
+                    matchCount += matched;
+                }
+                if (matchCount/Object.keys(rr).length > bestMatchCount) {
+                    bestMatchCount = matchCount/Object.keys(rr).length;    
+                    bestMatchELR = elr;
+                }
+            } 
+        }
+        return bestMatchELR;
+    }
+
+    /*
+     * Returns a ResolvedCalculation object for the specified ELR
+     */
+    resolvedCalculation(elr, version) {
+        const calcFacts = this.calculationFacts()[version][elr];
+        const report = this.fact.report;
+        const rels = report.getChildRelationships(this.fact.conceptName(), version)[elr];
+        const resolvedCalcClass = this.calc11 ? ResolvedCalc11Calculation : ResolvedLegacyCalculation;
+        const resolvedCalculation = new resolvedCalcClass(elr, this.fact, version);
+        for (const r of rels) {
+            const factset = calcFacts[r.t] ?? new FactSet();
+            resolvedCalculation.addRow(new CalculationContribution(report.getConcept(r.t), r.w, factset));
+        }
+        return resolvedCalculation;
+    }
+}
+
+class CalculationContribution {
+
+    constructor(concept, weight, facts) {
+        this.concept = concept;
+        this.weight = weight;
+        this.facts = facts;
+
+        if (weight == 1) {
+            this.weightSign = '+';
+        }
+        else if (weight == -1) {
+            this.weightSign = '-';
+        }
+        else {
+            this.weightSign = weight.toString();
+        }
+    }
+
+    contributionInterval() {
+        const intersection = this.facts.valueIntersection();
+        if (intersection === undefined) {
+            return undefined;
+        }
+        return intersection.times(this.weight); 
+    }
+}
+
+class AbstractResolvedCalculation {
+
+    constructor(elr, fact, relationshipVersion) {
+        this.totalFact = fact;
+        this.totalFactSet = new FactSet(fact.report.getAlignedFacts(fact));
+        this.elr = elr;
+        this.rows = [];
+        this.relationshipVersion = relationshipVersion;
+    }
+
+    addRow(contribution) {
+        this.rows.push(contribution);
+    }
+
+    binds() {
+        return this.rows.some((r) => !r.facts.isEmpty());
+    }
+
+    unchecked() {
+        return false;
+    }
+}
+
+export class ResolvedCalc11Calculation extends AbstractResolvedCalculation {
+
+    calculatedTotalInterval() {
+        let total = new Interval(0, 0);
+        for (const item of this.rows) {
+            if (!item.facts.isEmpty()) {
+                const contribution = item.contributionInterval();
+                if (contribution === undefined) {
+                    // Inconsistent duplicates
+                    return undefined;
+                }
+
+                total = total.plus(contribution);
+            }
+        }
+        return total;
+    }
+
+    /*
+     * Is the calculation consistent under Calculations v1.1 rules?
+     */
+    isConsistent() {
+        const cti = this.calculatedTotalInterval();
+        const ti = this.totalFactSet.valueIntersection();
+        return cti !== undefined && cti.intersection(ti) !== undefined;
+    }
+}
+
+export class ResolvedLegacyCalculation extends AbstractResolvedCalculation {
+
+    binds() {
+        return this.relationshipVersion == CALC_ARCROLE && super.binds() && this.rows.every((r) => r.facts.completeDuplicates());
+    }
+
+    unchecked() {
+        return super.binds() && !this.binds();
+    }
+
+    uncheckedDueToVersionMismatch() {
+        return this.relationshipVersion !== CALC_ARCROLE;
+    }
+
+    calculatedTotal() {
+        let total = new Decimal(0);
+
+        for (const row of this.rows) {
+            if (!row.facts.isConsistent()) {
+                return undefined;
+            }
+            if (!row.facts.isEmpty()) {
+                // Calculation does not bind if there are consistent (non-exact)
+                // duplicates, so we can just take the first duplicate value
+                total = total.plus(row.facts.items()[0].roundedValue().times(row.weight));
+            }
+        }
+        return total;
+    }
+
+    isConsistent() {
+        return this.calculatedTotal().equals(this.totalFact.roundedValue());
+    }
+}

iXBRLViewerPlugin/viewer/src/js/calculation.test.js

@@ -0,0 +1,306 @@
+// See COPYRIGHT.md for copyright information
+
+import Decimal from 'decimal.js';
+import { FactSet } from "./factset.js";
+import { Fact  } from "./fact.js";
+import { Interval  } from "./interval.js";
+import { NAMESPACE_ISO4217, viewerUniqueId } from "./util.js";
+import { ReportSet } from "./reportset.js";
+import { Calculation } from "./calculation.js";
+import './test-utils.js';
+
+const testReportData = {
+    "prefixes": {
+        "eg": "http://www.example.com",
+        "iso4217": NAMESPACE_ISO4217,
+        "e": "http://example.com/entity",
+        "group": "http://example.com/group",
+    },
+    "concepts": {
+        "eg:Total": {
+            "labels": {
+                "std": {
+                    "en": "Total"
+                }
+            }
+        },
+        "eg:Item1": {
+            "labels": {
+                "std": {
+                    "en": "Item 1"
+                }
+            }
+        },
+        "eg:Item2": {
+            "labels": {
+                "std": {
+                    "en": "Item 2"
+                }
+            }
+        },
+        "eg:Total2": {
+            "labels": {
+                "std": {
+                    "en": "Total 2"
+                }
+            }
+        },
+    },
+    "facts": {
+    },
+    "rels": {
+        "calc": {
+            "group": {
+                "eg:Total": [
+                    {"t": "eg:Item1", "w": 1},
+                    {"t": "eg:Item2", "w": -1}
+                ],
+                "eg:Total2": [
+                    {"t": "eg:Item1", "w": 2},
+                    {"t": "eg:Item2", "w": -2}
+                ]
+            }
+        }
+    }
+};
+
+function testReportSet(facts) {
+    // Deep copy of standing data
+    const data = JSON.parse(JSON.stringify(testReportData));
+    data.facts = facts;
+    const reportset = new ReportSet(data);
+    reportset._initialize();
+    return reportset;
+}
+
+function testFact(aspectData, value, decimals) {
+    const factData = { "a": aspectData, "v": value, "d": decimals};
+    return factData;
+}
+
+function getFact(reportSet, id) {
+  return reportSet.getItemById(viewerUniqueId(0, id));
+}
+
+describe("Simple consistent calculation", () => {
+    const reportSet = testReportSet({
+        "f1": testFact({"c": "eg:Total", "u": "iso2417:GBP"}, 10000, -3),
+        "f2": testFact({"c": "eg:Item1", "u": "iso2417:GBP"}, 12000, -3),
+        "f3": testFact({"c": "eg:Item2", "u": "iso2417:GBP"}, 2000, -3),
+    });
+
+    test("Calc 1.1 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), true);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotalInterval()).toEqual(new Interval(9000, 11000));
+        expect(Interval.fromFact(rCalc.totalFact)).toEqual(new Interval(9500, 10500));
+        expect(rCalc.isConsistent()).toBe(true);
+
+    });
+
+    test("Calc contributor", () => {
+        const calc11 = new Calculation(getFact(reportSet, "f2"), true);
+        expect(calc11.hasCalculations()).toBe(false);
+        const calc10 = new Calculation(getFact(reportSet, "f2"), false);
+        expect(calc10.hasCalculations()).toBe(false);
+    });
+
+    test("Calc 1.0 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), false);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotal()).toEqual(new Decimal(10000));
+        expect(rCalc.unchecked()).toBe(false);
+        expect(rCalc.isConsistent()).toBe(true);
+    });
+});
+
+describe("Consistent only under 1.1", () => {
+    const reportSet = testReportSet({
+        "f1": testFact({"c": "eg:Total", "u": "iso2417:GBP"}, 11000, -3),
+        "f2": testFact({"c": "eg:Item1", "u": "iso2417:GBP"}, 12000, -3),
+        "f3": testFact({"c": "eg:Item2", "u": "iso2417:GBP"}, 2000, -3),
+    });
+
+    test("Calc 1.1 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), true);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotalInterval()).toEqual(new Interval(9000, 11000));
+        expect(Interval.fromFact(rCalc.totalFact)).toEqual(new Interval(10500, 11500));
+        expect(rCalc.isConsistent()).toBe(true);
+
+        expect(rCalc.rows[0].concept.name).toBe("eg:Item1");
+        expect(rCalc.rows[0].weight).toBe(1);
+        expect(rCalc.rows[0].weightSign).toBe("+");
+        expect(rCalc.rows[0].facts.size()).toBe(1);
+
+        expect(rCalc.rows[1].concept.name).toBe("eg:Item2");
+        expect(rCalc.rows[1].weight).toBe(-1);
+        expect(rCalc.rows[1].weightSign).toBe("-");
+        expect(rCalc.rows[1].facts.size()).toBe(1);
+
+    });
+
+    test("Calc contributor", () => {
+        const calc11 = new Calculation(getFact(reportSet, "f2"), true);
+        expect(calc11.hasCalculations()).toBe(false);
+        const calc10 = new Calculation(getFact(reportSet, "f2"), false);
+        expect(calc10.hasCalculations()).toBe(false);
+    });
+
+    test("Calc 1.0 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), false);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotal()).toEqual(new Decimal(10000));
+        expect(rCalc.unchecked()).toBe(false);
+        expect(rCalc.isConsistent()).toBe(false);
+    });
+
+});
+
+describe("Consistent duplicate contributor", () => {
+    const reportSet = testReportSet({
+        "f1": testFact({"c": "eg:Total", "u": "iso2417:GBP"}, 10000, -3),
+        "f2": testFact({"c": "eg:Item1", "u": "iso2417:GBP"}, 12000, -3),
+        "f3": testFact({"c": "eg:Item2", "u": "iso2417:GBP"}, 2000, -3),
+        "f4": testFact({"c": "eg:Item2", "u": "iso2417:GBP"}, 1990, -1),
+    });
+
+    test("Calc 1.1 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), true);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotalInterval()).toEqual(new Interval(9505, 10515));
+        expect(Interval.fromFact(rCalc.totalFact)).toEqual(new Interval(9500, 10500));
+        expect(rCalc.isConsistent()).toBe(true);
+
+        expect(rCalc.rows[0].concept.name).toBe("eg:Item1");
+        expect(rCalc.rows[0].weight).toBe(1);
+        expect(rCalc.rows[0].weightSign).toBe("+");
+        expect(rCalc.rows[0].facts.size()).toBe(1);
+
+        expect(rCalc.rows[1].concept.name).toBe("eg:Item2");
+        expect(rCalc.rows[1].weight).toBe(-1);
+        expect(rCalc.rows[1].weightSign).toBe("-");
+        expect(rCalc.rows[1].facts.size()).toBe(2);
+
+    });
+
+    test("Calc contributor", () => {
+        const calc11 = new Calculation(getFact(reportSet, "f2"), true);
+        expect(calc11.hasCalculations()).toBe(false);
+        const calc10 = new Calculation(getFact(reportSet, "f2"), false);
+        expect(calc10.hasCalculations()).toBe(false);
+    });
+
+    test("Calc 1.0 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), false);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotal()).toEqual(new Decimal(10000));
+        expect(rCalc.unchecked()).toBe(true);
+    });
+
+});
+
+
+describe("Single contributor", () => {
+    const reportSet = testReportSet({
+        "f1": testFact({"c": "eg:Total", "u": "iso2417:GBP"}, 10000, -3),
+        "f2": testFact({"c": "eg:Item1", "u": "iso2417:GBP"}, 9990, -1),
+    });
+
+    test("Calc 1.1 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), true);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotalInterval()).toEqual(new Interval(9985, 9995));
+        expect(Interval.fromFact(rCalc.totalFact)).toEqual(new Interval(9500, 10500));
+        expect(rCalc.isConsistent()).toBe(true);
+
+    });
+
+    test("Calc 1.0 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), false);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotal()).toEqual(new Decimal(9990));
+        expect(rCalc.unchecked()).toBe(false);
+        expect(rCalc.isConsistent()).toBe(false);
+    });
+});
+
+describe("Weights", () => {
+    const reportSet = testReportSet({
+        "f1": testFact({"c": "eg:Total2", "u": "iso2417:GBP"}, 4000, -3),
+        "f2": testFact({"c": "eg:Item1", "u": "iso2417:GBP"}, 3000, -3),
+        "f3": testFact({"c": "eg:Item2", "u": "iso2417:GBP"}, 1000, -3),
+    });
+
+    test("Calc 1.1 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), true);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotalInterval()).toEqual(new Interval(2000, 6000));
+        expect(Interval.fromFact(rCalc.totalFact)).toEqual(new Interval(3500, 4500));
+        expect(rCalc.isConsistent()).toBe(true);
+
+        expect(rCalc.rows[0].concept.name).toBe("eg:Item1");
+        expect(rCalc.rows[0].weight).toBe(2);
+        expect(rCalc.rows[0].weightSign).toBe("2");
+
+        expect(rCalc.rows[1].concept.name).toBe("eg:Item2");
+        expect(rCalc.rows[1].weight).toBe(-2);
+        expect(rCalc.rows[1].weightSign).toBe("-2");
+
+    });
+
+    test("Calc contributor", () => {
+        const calc11 = new Calculation(getFact(reportSet, "f2"), true);
+        expect(calc11.hasCalculations()).toBe(false);
+        const calc10 = new Calculation(getFact(reportSet, "f2"), false);
+        expect(calc10.hasCalculations()).toBe(false);
+    });
+
+    test("Calc 1.0 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), false);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotal()).toEqual(new Decimal(4000));
+        expect(rCalc.unchecked()).toBe(false);
+        expect(rCalc.isConsistent()).toBe(true);
+    });
+});