`arelle.formula.XPathParser`¶

See COPYRIGHT.md for copyright information.

Module Contents¶

Classes¶

`ProgHeader`
`QNameDef`
`OpDef`
`OperationDef`
`VariableRef`
`RangeDecl`
`Expr`

Data¶

`_`
`FormulaToken`
`RecursiveFormulaTokens`
`ExpressionStack`
`ixtFunctionNamespaces`
`debug_flag`
`exprStack`
`xmlElement`
`modelXbrl`
`pluginCustomFunctionQNames`
`defaultNsmap`
`axesSupported`
`variableRef`
`qName`
`ncName`
`prefixOp`
`exponentLiteralStr`
`plusorminusLiteralStr`
`digitsStr`
`optionalDigitsStr`
`decimalPointStr`
`nanLiteralStr`
`integerLiteralStr`
`decimalFractionLiteralStr`
`infLiteralStr`
`decimalPoint`
`exponentLiteral`
`plusorminusLiteral`
`digits`
`integerLiteral`
`decimalFractionLiteral`
`infLiteral`
`nanLiteral`
`floatLiteral`
`decimalLiteral`
`lParen`
`rParen`
`lPred`
`rPred`
`expOp`
`commaOp`
`forOp`
`someOp`
`everyOp`
`quantifiedOp`
`inOp`
`returnOp`
`satisfiesOp`
`ifOp`
`thenOp`
`elseOp`
`andOp`
`orOp`
`eqValueOp`
`neValueOp`
`ltValueOp`
`leValueOp`
`gtValueOp`
`geValueOp`
`valueCompOp`
`isNodeOp`
`precedesNodeOp`
`followsNodeOp`
`nodeCompOp`
`neGeneralOp`
`leGeneralOp`
`ltGeneralOp`
`geGeneralOp`
`gtGeneralOp`
`eqGeneralOp`
`generalCompOp`
`comparisonOp`
`toOp`
`plusOp`
`minusOp`
`plusMinusOp`
`multOp`
`divOp`
`idivOp`
`modOp`
`multDivOp`
`unionWordOp`
`unionSymbOp`
`unionOp`
`intersectOp`
`exceptOp`
`intersectExceptOp`
`instanceOp`
`ofOp`
`treatOp`
`asOp`
`castableOp`
`castOp`
`unaryOp`
`occurOptionalOp`
`occurAnyOp`
`occurAtLeastOnceOp`
`occurrenceOp`
`wildOp`
`typeName`
`elementName`
`attributeName`
`elementDeclaration`
`schemaElementTest`
`elementNameOrWildcard`
`elementTest`
`attributeDeclaration`
`schemaAttributeTest`
`attribNameOrWildcard`
`attributeTest`
`PITest`
`commentTest`
`textTest`
`documentTest`
`anyKindTest`
`kindTest`
`wildcard`
`nameTest`
`nodeTest`
`abbrevForwardStep`
`atomicType`
`itemType`
`occurrenceIndicator`
`sequenceType`
`singleType`
`contextItem`
`pathDescOp`
`pathStepOp`
`pathOp`
`pathRootOp`
`axisOp`
`forwardAxis`
`forwardStep`
`reverseAxis`
`abbrevReverseStep`
`reverseStep`
`step`
`expr`
`atom`
`stepExpr`
`relativePathExpr`
`pathExpr`
`valueExpr`
`unaryExpr`
`castExpr`
`castableExpr`
`treatExpr`
`instanceOfExpr`
`intersectExceptExpr`
`unionExpr`
`multiplicitaveExpr`
`additiveExpr`
`rangeExpr`
`comparisonExpr`
`andExpr`
`orExpr`
`xpathExpr`
`opn`	def evaluateStack( self, s ): op = s.pop() if isinstance(op,FunctionDef): f = op args = [] for i in range(f.argcount): args.insert(0, self.evaluateStack( s )) if f.name == “sum”: return sum(args) elif f.name == “concat”: return “”.join(str(arg) for arg in args) elif isinstance(op,VariableRef): v = op if v.name in variables: return variables[v.name] else: return None else: if op in (“+”,”-“,”*”,”div”,”idiv”,”^”): op2 = self.evaluateStack( s ) op1 = self.evaluateStack( s ) if op1 and op2: return self.opn[op]( op1, op2 ) else: return None elif op == “(“: return self.evaluateStack( s ) else: return op
`isInitialized`
`_staticExpressionFunctionContext`

API¶

arelle.formula.XPathParser._: arelle.typing.TypeGetText¶: None

arelle.formula.XPathParser.FormulaToken¶: None

arelle.formula.XPathParser.RecursiveFormulaTokens¶: None

arelle.formula.XPathParser.ExpressionStack¶: None

arelle.formula.XPathParser.ixtFunctionNamespaces: set[str]¶: ‘set(…)’

arelle.formula.XPathParser.debug_flag¶: True

arelle.formula.XPathParser.exprStack: arelle.formula.XPathParser.ExpressionStack¶: []

arelle.formula.XPathParser.xmlElement: arelle.ModelObject.ModelObject | None¶: None

arelle.formula.XPathParser.modelXbrl: arelle.ModelXbrl.ModelXbrl | None¶: None

arelle.formula.XPathParser.pluginCustomFunctionQNames: set[arelle.ModelValue.QName] | None¶: None

class arelle.formula.XPathParser.ProgHeader(modelObject: arelle.ModelFormulaObject.ModelFormulaResource, name: str, element: arelle.ModelObject.ModelObject, sourceStr: str, traceType: int)¶

Initialization

__repr__() → str¶

arelle.formula.XPathParser.exprStackToksRIndex(toks: pyparsing.ParseResults) → int¶

arelle.formula.XPathParser.exprStackTokRIndex(tok: arelle.formula.XPathParser.FormulaToken) → int¶

arelle.formula.XPathParser.pushFirst(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → None¶

arelle.formula.XPathParser.pushFloat(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → float¶

arelle.formula.XPathParser.pushInt(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → int¶

arelle.formula.XPathParser.pushDecimal(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → decimal.Decimal¶

arelle.formula.XPathParser.pushQuotedString(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → str¶

class arelle.formula.XPathParser.QNameDef(loc: int, prefix: str | None, namespaceURI: str | None, localName: str, isAttribute: bool = False, axis: str | None = None)¶

Bases: arelle.ModelValue.QName

Initialization

__hash__() → int¶

__repr__() → str¶

__eq__(other: Any) → bool¶

__ne__(other: Any) → bool¶

arelle.formula.XPathParser.defaultNsmap¶: None

arelle.formula.XPathParser.axesSupported¶: None

arelle.formula.XPathParser.pushQName(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.QNameDef | None¶

arelle.formula.XPathParser.pushAttr(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.QNameDef¶

class arelle.formula.XPathParser.OpDef(loc: int, toks: pyparsing.ParseResults)¶

Initialization

__repr__() → str¶

__eq__(other: Any) → bool¶

__ne__(other: Any) → bool¶

arelle.formula.XPathParser.pushOp(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.OpDef¶

class arelle.formula.XPathParser.OperationDef(sourceStr: str, loc: int, name: str | arelle.formula.XPathParser.QNameDef, toks: pyparsing.ParseResults | list[arelle.formula.XPathParser.FormulaToken], skipFirstTok: bool)¶

Initialization

args: list[arelle.formula.XPathParser.FormulaToken]¶: None

__repr__() → str¶

arelle.formula.XPathParser.pushOperation(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.OperationDef¶

arelle.formula.XPathParser.pushUnaryOperation(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.OperationDef¶

arelle.formula.XPathParser.pushFunction(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.OperationDef¶

arelle.formula.XPathParser.pushSequence(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.OperationDef¶

arelle.formula.XPathParser.pushPredicate(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.OperationDef¶

arelle.formula.XPathParser.pushRootStep(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.OperationDef | None¶

class arelle.formula.XPathParser.VariableRef(loc: int, qname: arelle.ModelValue.QName)¶

Initialization

__repr__() → str¶

arelle.formula.XPathParser.pushVarRef(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.VariableRef¶

class arelle.formula.XPathParser.RangeDecl(loc: int, toks: pyparsing.ParseResults)¶

Initialization

__repr__() → str¶

arelle.formula.XPathParser.pushRangeVar(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.RangeDecl¶

class arelle.formula.XPathParser.Expr(loc: int, toks: pyparsing.ParseResults)¶

Initialization

__repr__() → str¶

arelle.formula.XPathParser.pushExpr(sourceStr: str, loc: int, toks: pyparsing.ParseResults) → arelle.formula.XPathParser.Expr¶

arelle.formula.XPathParser.variableRef¶: ‘Regex(…)’

arelle.formula.XPathParser.qName¶: ‘Regex(…)’

arelle.formula.XPathParser.ncName¶: ‘Word(…)’

arelle.formula.XPathParser.prefixOp¶: ‘Literal(…)’

arelle.formula.XPathParser.exponentLiteralStr¶: ‘[eE]’

arelle.formula.XPathParser.plusorminusLiteralStr¶: ‘[+-]’

arelle.formula.XPathParser.digitsStr¶: ‘\d+’

arelle.formula.XPathParser.optionalDigitsStr¶: ‘\d*’

arelle.formula.XPathParser.decimalPointStr¶: ‘.’

arelle.formula.XPathParser.nanLiteralStr¶: ‘NaN’

arelle.formula.XPathParser.integerLiteralStr¶: None

arelle.formula.XPathParser.decimalFractionLiteralStr¶: None

arelle.formula.XPathParser.infLiteralStr¶: None

arelle.formula.XPathParser.decimalPoint¶: ‘Literal(…)’

arelle.formula.XPathParser.exponentLiteral¶: ‘Regex(…)’

arelle.formula.XPathParser.plusorminusLiteral¶: None

arelle.formula.XPathParser.digits¶: ‘Word(…)’

arelle.formula.XPathParser.integerLiteral¶: ‘Regex(…)’

arelle.formula.XPathParser.decimalFractionLiteral¶: ‘Regex(…)’

arelle.formula.XPathParser.infLiteral¶: ‘Regex(…)’

arelle.formula.XPathParser.nanLiteral¶: ‘Regex(…)’

arelle.formula.XPathParser.floatLiteral¶: ‘Regex(…)’

arelle.formula.XPathParser.decimalLiteral¶: ‘Regex(…)’

arelle.formula.XPathParser.lParen¶: ‘Literal(…)’

arelle.formula.XPathParser.rParen¶: ‘Literal(…)’

arelle.formula.XPathParser.lPred¶: ‘Literal(…)’

arelle.formula.XPathParser.rPred¶: ‘Literal(…)’

arelle.formula.XPathParser.expOp¶: ‘Literal(…)’

arelle.formula.XPathParser.commaOp¶: ‘Literal(…)’

arelle.formula.XPathParser.forOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.someOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.everyOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.quantifiedOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.inOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.returnOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.satisfiesOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.ifOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.thenOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.elseOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.andOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.orOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.eqValueOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.neValueOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.ltValueOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.leValueOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.gtValueOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.geValueOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.valueCompOp¶: None

arelle.formula.XPathParser.isNodeOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.precedesNodeOp¶: ‘Literal(…)’

arelle.formula.XPathParser.followsNodeOp¶: ‘Literal(…)’

arelle.formula.XPathParser.nodeCompOp¶: None

arelle.formula.XPathParser.neGeneralOp¶: ‘Literal(…)’

arelle.formula.XPathParser.leGeneralOp¶: ‘Literal(…)’

arelle.formula.XPathParser.ltGeneralOp¶: ‘Literal(…)’

arelle.formula.XPathParser.geGeneralOp¶: ‘Literal(…)’

arelle.formula.XPathParser.gtGeneralOp¶: ‘Literal(…)’

arelle.formula.XPathParser.eqGeneralOp¶: ‘Literal(…)’

arelle.formula.XPathParser.generalCompOp¶: None

arelle.formula.XPathParser.comparisonOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.toOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.plusOp¶: ‘Literal(…)’

arelle.formula.XPathParser.minusOp¶: ‘Literal(…)’

arelle.formula.XPathParser.plusMinusOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.multOp¶: ‘Literal(…)’

arelle.formula.XPathParser.divOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.idivOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.modOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.multDivOp¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.unionWordOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.unionSymbOp¶: ‘Literal(…)’

arelle.formula.XPathParser.unionOp¶: None

arelle.formula.XPathParser.intersectOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.exceptOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.intersectExceptOp¶: None

arelle.formula.XPathParser.instanceOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.ofOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.treatOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.asOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.castableOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.castOp¶: ‘Keyword(…)’

arelle.formula.XPathParser.unaryOp¶: None

arelle.formula.XPathParser.occurOptionalOp¶: ‘Literal(…)’

arelle.formula.XPathParser.occurAnyOp¶: None

arelle.formula.XPathParser.occurAtLeastOnceOp¶: None

arelle.formula.XPathParser.occurrenceOp¶: None

arelle.formula.XPathParser.wildOp¶: None

arelle.formula.XPathParser.typeName¶: None

arelle.formula.XPathParser.elementName¶: None

arelle.formula.XPathParser.attributeName¶: None

arelle.formula.XPathParser.elementDeclaration¶: None

arelle.formula.XPathParser.schemaElementTest¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.elementNameOrWildcard¶: None

arelle.formula.XPathParser.elementTest¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.attributeDeclaration¶: None

arelle.formula.XPathParser.schemaAttributeTest¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.attribNameOrWildcard¶: None

arelle.formula.XPathParser.attributeTest¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.PITest¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.commentTest¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.textTest¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.documentTest¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.anyKindTest¶: ‘set_parse_action(…)’

arelle.formula.XPathParser.kindTest¶: None

arelle.formula.XPathParser.wildcard¶: None

arelle.formula.XPathParser.nameTest¶: None

arelle.formula.XPathParser.nodeTest¶: None

arelle.formula.XPathParser.abbrevForwardStep¶: None

arelle.formula.XPathParser.atomicType¶: None

arelle.formula.XPathParser.itemType¶: None

arelle.formula.XPathParser.occurrenceIndicator¶: None

arelle.formula.XPathParser.sequenceType¶: None

arelle.formula.XPathParser.singleType¶: None

arelle.formula.XPathParser.contextItem¶: None

arelle.formula.XPathParser.pathDescOp¶: ‘Literal(…)’

arelle.formula.XPathParser.pathStepOp¶: ‘Literal(…)’

arelle.formula.XPathParser.pathOp¶: None

arelle.formula.XPathParser.pathRootOp¶: ‘Regex(…)’

arelle.formula.XPathParser.axisOp¶: ‘Literal(…)’

arelle.formula.XPathParser.forwardAxis¶: None

arelle.formula.XPathParser.forwardStep¶: None

arelle.formula.XPathParser.reverseAxis¶: None

arelle.formula.XPathParser.abbrevReverseStep¶: ‘Literal(…)’

arelle.formula.XPathParser.reverseStep¶: None

arelle.formula.XPathParser.step¶: None

arelle.formula.XPathParser.expr¶: ‘Forward(…)’

arelle.formula.XPathParser.atom¶: None

arelle.formula.XPathParser.stepExpr¶: None

arelle.formula.XPathParser.relativePathExpr¶: None

arelle.formula.XPathParser.pathExpr¶: None

arelle.formula.XPathParser.valueExpr¶: None

arelle.formula.XPathParser.unaryExpr¶: None

arelle.formula.XPathParser.castExpr¶: None

arelle.formula.XPathParser.castableExpr¶: None

arelle.formula.XPathParser.treatExpr¶: None

arelle.formula.XPathParser.instanceOfExpr¶: None

arelle.formula.XPathParser.intersectExceptExpr¶: None

arelle.formula.XPathParser.unionExpr¶: None

arelle.formula.XPathParser.multiplicitaveExpr¶: None

arelle.formula.XPathParser.additiveExpr¶: None

arelle.formula.XPathParser.rangeExpr¶: None

arelle.formula.XPathParser.comparisonExpr¶: None

arelle.formula.XPathParser.andExpr¶: None

arelle.formula.XPathParser.orExpr¶: None

arelle.formula.XPathParser.xpathExpr¶: None

arelle.formula.XPathParser.opn¶

None

def evaluateStack( self, s ): op = s.pop() if isinstance(op,FunctionDef): f = op args = [] for i in range(f.argcount): args.insert(0, self.evaluateStack( s )) if f.name == “sum”: return sum(args) elif f.name == “concat”: return “”.join(str(arg) for arg in args) elif isinstance(op,VariableRef): v = op if v.name in variables: return variables[v.name] else: return None else: if op in (“+”,”-“,”*”,”div”,”idiv”,”^”): op2 = self.evaluateStack( s ) op1 = self.evaluateStack( s ) if op1 and op2: return self.opn[op]( op1, op2 ) else: return None elif op == “(“: return self.evaluateStack( s ) else: return op

arelle.formula.XPathParser.normalizeExpr(expr: str) → str¶

arelle.formula.XPathParser.isInitialized¶: False

arelle.formula.XPathParser.initializeParser(modelManager: arelle.ModelManager.ModelManager) → bool¶

arelle.formula.XPathParser.exceptionErrorIndication(exception: arelle.formula.XPathContext.XPathException | pyparsing.ParseBaseException) → str¶

arelle.formula.XPathParser._staticExpressionFunctionContext: xml.dom.minidom.Element | None¶: None

arelle.formula.XPathParser.staticExpressionFunctionContext() → xml.dom.minidom.Element¶

arelle.formula.XPathParser.parse(modelObject: arelle.ModelFormulaObject.ModelFormulaResource, xpathExpression: str | None, element: arelle.ModelObject.ModelObject | None, name: str, traceType: int) → arelle.formula.XPathParser.ExpressionStack | None¶

arelle.formula.XPathParser.variableReferencesSet(exprStack: arelle.formula.XPathParser.ExpressionStack | None, element: arelle.ModelFormulaObject.ModelFormulaResource) → set[arelle.ModelValue.QName]¶

arelle.formula.XPathParser.variableReferences(exprStack: arelle.formula.XPathParser.RecursiveFormulaTokens, varRefSet: set[arelle.ModelValue.QName], element: arelle.ModelObject.ModelObject, rangeVars: list[arelle.ModelValue.QName] | None = None) → None¶

arelle.formula.XPathParser.prefixDeclarations(exprStack: arelle.formula.XPathParser.RecursiveFormulaTokens, xmlnsDict: dict[str, str | None], element: arelle.ModelObject.ModelObject) → None¶

arelle.formula.XPathParser.clearProg(exprStack: arelle.formula.XPathParser.ExpressionStack | None) → None¶

arelle.formula.XPathParser.clearNamedProg(ownerObject: arelle.ModelFormulaObject.ModelFormulaResource, progName: str) → None¶

arelle.formula.XPathParser.clearNamedProgs(ownerObject: arelle.ModelFormulaObject.ModelFormulaResource, progsListName: str) → None¶

arelle.formula.XPathParser.codeModule(code: collections.abc.Iterable[Any]) → str¶

arelle.formula.XPathParser.parser_unit_test() → None¶

`exprStackToksRIndex`
`exprStackTokRIndex`
`pushFirst`
`pushFloat`
`pushInt`
`pushDecimal`
`pushQuotedString`
`pushQName`
`pushAttr`
`pushOp`
`pushOperation`
`pushUnaryOperation`
`pushFunction`
`pushSequence`
`pushPredicate`
`pushRootStep`
`pushVarRef`
`pushRangeVar`
`pushExpr`
`normalizeExpr`
`initializeParser`
`exceptionErrorIndication`
`staticExpressionFunctionContext`
`parse`
`variableReferencesSet`
`variableReferences`
`prefixDeclarations`
`clearProg`
`clearNamedProg`
`clearNamedProgs`
`codeModule`
`parser_unit_test`

arelle.formula.XPathParser¶

Module Contents¶

Classes¶

Functions¶

Data¶

API¶

`arelle.formula.XPathParser`¶