`arelle.ValidateXbrlCalcs`¶

See COPYRIGHT.md for copyright information.

Module Contents¶

Classes¶

`ValidateCalcsMode`
`ValidateXbrlCalcs`

Functions¶

`init`
`rangeToStr`
`validate`
`roundFact`
`decimalRound`
`inferredPrecision`
`inferredDecimals`
`roundValue`
`rangeValue`
`insignificantDigits`
`wrappedFactWithWeight`
`wrappedSummationAndItems`	ARELLE-281, replace: faster python-based hash (replace with hashlib for fewer collisions) itemValuesHash = hash( tuple(( hash(b.modelObject.qname), hash(b.extraProperties[1][1]) ) # sort by qname so we don’t care about reordering of summation terms for b in sorted(boundSummationItems, key=lambda b: b.modelObject.qname)) ) sumValueHash = hash( (hash(fact.qname), hash(roundedSum)) )

Data¶

`oimXbrlxeBlockingErrorCodes`
`numberPattern`
`ZERO`
`ONE`
`TWO`
`TEN`
`NaN`
`floatNaN`
`floatINF`
`INCONSISTENT`
`NIL_FACT_SET`
`ZERO_RANGE`
`EMPTY_SET`
`FactsType`
`ConceptType`

API¶

arelle.ValidateXbrlCalcs.init() → None¶

class arelle.ValidateXbrlCalcs.ValidateCalcsMode¶

NONE¶: 0

XBRL_v2_1_INFER_PRECISION¶: 1

XBRL_v2_1¶: 2

XBRL_v2_1_DEDUPLICATE¶: 3

ROUND_TO_NEAREST¶: 4

TRUNCATION¶: 5

static label(enum: int) → str | None¶

static menu() → collections.OrderedDict[str, int]¶

arelle.ValidateXbrlCalcs.oimXbrlxeBlockingErrorCodes¶: None

arelle.ValidateXbrlCalcs.numberPattern¶: ‘re_compile(…)’

arelle.ValidateXbrlCalcs.ZERO¶: ‘Decimal(…)’

arelle.ValidateXbrlCalcs.ONE¶: ‘Decimal(…)’

arelle.ValidateXbrlCalcs.TWO¶: ‘Decimal(…)’

arelle.ValidateXbrlCalcs.TEN¶: ‘Decimal(…)’

arelle.ValidateXbrlCalcs.NaN¶: ‘Decimal(…)’

arelle.ValidateXbrlCalcs.floatNaN¶: ‘float(…)’

arelle.ValidateXbrlCalcs.floatINF¶: ‘float(…)’

arelle.ValidateXbrlCalcs.INCONSISTENT¶: ‘inconsistent’

arelle.ValidateXbrlCalcs.NIL_FACT_SET¶: ‘nilFactSet’

arelle.ValidateXbrlCalcs.ZERO_RANGE¶: (0, 0, True, True)

arelle.ValidateXbrlCalcs.EMPTY_SET: set[str]¶: ‘set(…)’

arelle.ValidateXbrlCalcs.rangeToStr(a: decimal.Decimal | str, b: decimal.Decimal | str, inclA: bool, inclB: bool) → str¶

arelle.ValidateXbrlCalcs.validate(modelXbrl: arelle.ModelXbrl.ModelXbrl, validateCalcs: int) → Iterable[arelle.utils.validate.Validation.Validation]¶

arelle.ValidateXbrlCalcs.FactsType: TypeAlias¶: None

arelle.ValidateXbrlCalcs.ConceptType: TypeAlias¶: None

class arelle.ValidateXbrlCalcs.ValidateXbrlCalcs(modelXbrl: arelle.ModelXbrl.ModelXbrl, validateCalcs: int)¶

Initialization

validate() → Iterable[arelle.utils.validate.Validation.Validation]¶

bindFacts(facts: Iterable[arelle.ModelInstanceObject.ModelFact], ancestors: list[arelle.ModelObject.ModelObject]) → None¶

consistentFactValueInterval(fList: list[arelle.ModelInstanceObject.ModelFact], truncate: bool = False) → tuple[arelle.utils.validate.Validation.Validation | None, tuple[str | decimal.Decimal | None, str | decimal.Decimal | None, bool, bool]]¶

arelle.ValidateXbrlCalcs.roundFact(fact: arelle.ModelInstanceObject.ModelFact, inferDecimals: bool = False, vDecimal: decimal.Decimal | None = None) → decimal.Decimal¶

arelle.ValidateXbrlCalcs.decimalRound(x: decimal.Decimal, d: int | float, rounding: str) → decimal.Decimal¶

arelle.ValidateXbrlCalcs.inferredPrecision(fact: arelle.ModelInstanceObject.ModelFact) → float | int¶

arelle.ValidateXbrlCalcs.inferredDecimals(fact: arelle.ModelInstanceObject.ModelFact) → float | int¶

arelle.ValidateXbrlCalcs.roundValue(value: str | decimal.Decimal, precision: int | float | str | None = None, decimals: int | float | str | None = None, scale: str | None = None) → decimal.Decimal¶

arelle.ValidateXbrlCalcs.rangeValue(value: decimal._DecimalNew | arelle.ModelInstanceObject.ModelFact | list[arelle.ModelInstanceObject.ModelFact], decimals: int | float | str | None = None, truncate: bool = False) → tuple[decimal.Decimal, decimal.Decimal, bool, bool]¶

arelle.ValidateXbrlCalcs.insignificantDigits(value: decimal._DecimalNew, decimals: int | float | decimal.Decimal | str) → tuple[decimal.Decimal, decimal.Decimal] | None¶

arelle.ValidateXbrlCalcs.wrappedFactWithWeight(fact: arelle.ModelInstanceObject.ModelFact, weight: decimal.Decimal, roundedValue: decimal.Decimal) → arelle.ModelObject.ObjectPropertyViewWrapper¶

arelle.ValidateXbrlCalcs.wrappedSummationAndItems(fact: arelle.ModelInstanceObject.ModelFact, roundedSum: decimal.Decimal, boundSummationItems: list[arelle.ModelObject.ObjectPropertyViewWrapper]) → list[arelle.ModelObject.ObjectPropertyViewWrapper]¶: ARELLE-281, replace: faster python-based hash (replace with hashlib for fewer collisions) itemValuesHash = hash( tuple(( hash(b.modelObject.qname), hash(b.extraProperties[1][1]) ) # sort by qname so we don’t care about reordering of summation terms for b in sorted(boundSummationItems, key=lambda b: b.modelObject.qname)) ) sumValueHash = hash( (hash(fact.qname), hash(roundedSum)) )

arelle.ValidateXbrlCalcs¶