def __init__(self,
modelXbrl,
arcrole,
linkrole=None,
linkqname=None,
arcqname=None,
includeProhibits=False):
self.isChanged = False
self.modelXbrl = modelXbrl
self.arcrole = arcrole # may be str, tuple or frozenset
self.linkrole = linkrole # may be str, tuple or frozenset
self.linkqname = linkqname
self.arcqname = arcqname
relationshipSetKey = (arcrole, linkrole, linkqname, arcqname,
includeProhibits)
# base sets does not care about the #includeProhibits
if isinstance(arcrole,
(str, NoneType)) and isinstance(linkrole,
(str, NoneType)):
modelLinks = self.modelXbrl.baseSets.get(
(arcrole, linkrole, linkqname, arcqname), [])
else: # arcrole is a set of arcroles
modelLinks = []
for ar in (arcrole, ) if isinstance(arcrole,
(str, NoneType)) else arcrole:
for lr in (linkrole, ) if isinstance(linkrole,
(str,
NoneType)) else linkrole:
modelLinks.extend(
self.modelXbrl.baseSets.get(
(ar, lr, linkqname, arcqname), []))
# gather arcs
relationships = {}
isDimensionRel = self.arcrole == "XBRL-dimensions" # all dimensional relationship arcroles
isFormulaRel = self.arcrole == "XBRL-formulae" # all formula relationship arcroles
isTableRenderingRel = self.arcrole == "Table-rendering"
isFootnoteRel = self.arcrole == "XBRL-footnotes" # all footnote relationship arcroles
if not isinstance(arcrole, (tuple, frozenset)):
arcrole = (arcrole, )
for modelLink in modelLinks:
arcs = []
linkEltQname = modelLink.qname
for linkChild in modelLink:
linkChildArcrole = linkChild.get(
"{http://www.w3.org/1999/xlink}arcrole")
if linkChild.get("{http://www.w3.org/1999/xlink}type"
) == "arc" and linkChildArcrole:
if isFootnoteRel: # arcrole is fact-footnote or other custom footnote relationship
arcs.append(linkChild)
elif isDimensionRel:
if XbrlConst.isDimensionArcrole(linkChildArcrole):
arcs.append(linkChild)
elif isFormulaRel:
if XbrlConst.isFormulaArcrole(linkChildArcrole):
arcs.append(linkChild)
elif isTableRenderingRel:
if XbrlConst.isTableRenderingArcrole(linkChildArcrole):
arcs.append(linkChild)
elif (linkChildArcrole in arcrole
and (arcqname is None or arcqname == linkChild.qname)
and
(linkqname is None or linkqname == linkEltQname)):
arcs.append(linkChild)
# build network
for arcElement in arcs:
fromLabel = arcElement.get(
"{http://www.w3.org/1999/xlink}from")
toLabel = arcElement.get("{http://www.w3.org/1999/xlink}to")
for fromResource in modelLink.labeledResources[fromLabel]:
for toResource in modelLink.labeledResources[toLabel]:
if isinstance(
fromResource,
(ModelResource, LocPrototype)) and isinstance(
toResource, (ModelResource, LocPrototype)):
modelRel = ModelDtsObject.ModelRelationship(
modelLink.modelDocument, arcElement,
fromResource.dereference(),
toResource.dereference())
modelRelEquivalenceHash = modelRel.equivalenceHash
if modelRelEquivalenceHash not in relationships:
relationships[
modelRelEquivalenceHash] = modelRel
else: # use equivalenceKey instead of hash
otherRel = relationships[
modelRelEquivalenceHash]
if otherRel is not USING_EQUIVALENCE_KEY: # move equivalentRel to use key instead of hasn
if modelRel.isIdenticalTo(otherRel):
continue # skip identical arc
relationships[
otherRel.equivalenceKey] = otherRel
relationships[
modelRelEquivalenceHash] = USING_EQUIVALENCE_KEY
modelRelEquivalenceKey = modelRel.equivalenceKey # this is a complex tuple to compute, get once for below
if modelRelEquivalenceKey not in relationships or \
modelRel.priorityOver(relationships[modelRelEquivalenceKey]):
relationships[
modelRelEquivalenceKey] = modelRel
#reduce effective arcs and order relationships...
self.modelRelationshipsFrom = None
self.modelRelationshipsTo = None
self.modelConceptRoots = None
self.modellinkRoleUris = None
orderRels = defaultdict(list)
for modelRel in relationships.values():
if (modelRel is not USING_EQUIVALENCE_KEY
and (includeProhibits or not modelRel.isProhibited)):
orderRels[modelRel.order].append(modelRel)
self.modelRelationships = [
modelRel for order in sorted(orderRels.keys())
for modelRel in orderRels[order]
]
modelXbrl.relationshipSets[relationshipSetKey] = self
def __init__(self, modelXbrl, arcrole, linkrole=None, linkqname=None, arcqname=None, includeProhibits=False):
self.isChanged = False
self.modelXbrl = modelXbrl
self.arcrole = arcrole
self.linkrole = linkrole
self.linkqname = linkqname
self.arcqname = arcqname
relationshipSetKey = (arcrole, linkrole, linkqname, arcqname, includeProhibits)
# base sets does not care about the #includeProhibits
if not isinstance(arcrole,(tuple,frozenset)):
modelLinks = self.modelXbrl.baseSets.get((arcrole, linkrole, linkqname, arcqname), [])
else: # arcrole is a set of arcroles
modelLinks = []
for ar in arcrole:
modelLinks.extend(self.modelXbrl.baseSets.get((ar, linkrole, linkqname, arcqname), []))
# gather arcs
relationships = {}
isDimensionRel = self.arcrole == "XBRL-dimensions" # all dimensional relationship arcroles
isFormulaRel = self.arcrole == "XBRL-formulae" # all formula relationship arcroles
isTableRenderingRel = self.arcrole == "Table-rendering"
isFootnoteRel = self.arcrole == "XBRL-footnotes" # all footnote relationship arcroles
if not isinstance(arcrole,(tuple,frozenset)):
arcrole = (arcrole,)
for modelLink in modelLinks:
arcs = []
linkEltQname = modelLink.qname
for linkChild in modelLink:
linkChildArcrole = linkChild.get("{http://www.w3.org/1999/xlink}arcrole")
if linkChild.get("{http://www.w3.org/1999/xlink}type") == "arc" and linkChildArcrole:
linkChildQname = linkChild
if isFootnoteRel:
arcs.append(linkChild)
elif isDimensionRel:
if XbrlConst.isDimensionArcrole(linkChildArcrole):
arcs.append(linkChild)
elif isFormulaRel:
if XbrlConst.isFormulaArcrole(linkChildArcrole):
arcs.append(linkChild)
elif isTableRenderingRel:
if XbrlConst.isTableRenderingArcrole(linkChildArcrole):
arcs.append(linkChild)
elif (linkChildArcrole in arcrole and
(arcqname is None or arcqname == linkChildQname) and
(linkqname is None or linkqname == linkEltQname)):
arcs.append(linkChild)
# build network
for arcElement in arcs:
fromLabel = arcElement.get("{http://www.w3.org/1999/xlink}from")
toLabel = arcElement.get("{http://www.w3.org/1999/xlink}to")
for fromResource in modelLink.labeledResources[fromLabel]:
for toResource in modelLink.labeledResources[toLabel]:
if isinstance(fromResource,ModelResource) and isinstance(toResource,ModelResource):
modelRel = ModelDtsObject.ModelRelationship(modelLink.modelDocument, arcElement, fromResource.dereference(), toResource.dereference())
modelRelEquivalenceKey = modelRel.equivalenceKey # this is a complex tuple to compute, get once for below
if modelRelEquivalenceKey not in relationships or \
modelRel.priorityOver(relationships[modelRelEquivalenceKey]):
relationships[modelRelEquivalenceKey] = modelRel
#reduce effective arcs and order relationships...
self.modelRelationshipsFrom = None
self.modelRelationshipsTo = None
self.modelConceptRoots = None
self.modellinkRoleUris = None
orderRels = defaultdict(list)
for modelRel in relationships.values():
if includeProhibits or not modelRel.isProhibited:
orderRels[modelRel.order].append(modelRel)
self.modelRelationships = [modelRel
for order in sorted(orderRels.keys())
for modelRel in orderRels[order]]
modelXbrl.relationshipSets[relationshipSetKey] = self
def init(modelXbrl):
# setup modelXbrl for rendering evaluation
# dimension defaults required in advance of validation
from arelle import ValidateXbrlDimensions, ValidateFormula, ModelDocument
ValidateXbrlDimensions.loadDimensionDefaults(modelXbrl)
hasXbrlTables = False
# validate table linkbase dimensions
for baseSetKey in modelXbrl.baseSets.keys():
arcrole, ELR, linkqname, arcqname = baseSetKey
if ELR and linkqname and arcqname and XbrlConst.isTableRenderingArcrole(arcrole):
ValidateFormula.checkBaseSet(modelXbrl, arcrole, ELR, modelXbrl.relationshipSet(arcrole,ELR,linkqname,arcqname))
if arcrole in (XbrlConst.tableBreakdown, XbrlConst.tableBreakdownMMDD, XbrlConst.tableBreakdown201305, XbrlConst.tableBreakdown201301, XbrlConst.tableAxis2011):
hasXbrlTables = True
# provide context for view
if modelXbrl.modelDocument.type == ModelDocument.Type.INSTANCE:
instance = None # use instance of the entry pont
else: # need dummy instance
instance = ModelDocument.create(modelXbrl, ModelDocument.Type.INSTANCE,
"dummy.xml", # fake URI and fake schemaRef
("http://www.xbrl.org/2003/xbrl-instance-2003-12-31.xsd",))
if hasXbrlTables:
# formula processor is needed for 2011 XBRL tables but not for 2010 Eurofiling tables
modelXbrl.rendrCntx = XPathContext.create(modelXbrl, instance)
modelXbrl.profileStat(None)
# setup fresh parameters from formula options
modelXbrl.parameters = modelXbrl.modelManager.formulaOptions.typedParameters()
# validate parameters and custom function signatures
ValidateFormula.validate(modelXbrl, xpathContext=modelXbrl.rendrCntx, parametersOnly=True, statusMsg=_("compiling rendering tables"))
# deprecated as of 2013-05-17
# check and extract message expressions into compilable programs
for msgArcrole in (XbrlConst.tableDefinitionNodeMessage201301, XbrlConst.tableDefinitionNodeSelectionMessage201301,
XbrlConst.tableAxisMessage2011, XbrlConst.tableAxisSelectionMessage2011):
for msgRel in modelXbrl.relationshipSet(msgArcrole).modelRelationships:
ValidateFormula.checkMessageExpressions(modelXbrl, msgRel.toModelObject)
# compile and validate tables
for modelTable in modelXbrl.modelRenderingTables:
modelTable.fromInstanceQnames = None # required if referred to by variables scope chaining
modelTable.compile()
hasNsWithAspectModel = modelTable.namespaceURI in (XbrlConst.euRend, XbrlConst.table2011, XbrlConst.table201301, XbrlConst.table201305)
# check aspectModel (attribute removed 2013-06, now always dimensional)
if modelTable.aspectModel not in ("non-dimensional", "dimensional") and hasNsWithAspectModel:
modelXbrl.error("xbrlte:unknownAspectModel",
_("Table %(xlinkLabel)s, aspect model %(aspectModel)s not recognized"),
modelObject=modelTable, xlinkLabel=modelTable.xlinkLabel, aspectModel=modelTable.aspectModel)
else:
modelTable.priorAspectAxisDisposition = {}
# check ordinate aspects against aspectModel
oppositeAspectModel = (_DICT_SET({'dimensional','non-dimensional'}) - _DICT_SET({modelTable.aspectModel})).pop()
if hasNsWithAspectModel:
uncoverableAspects = aspectModels[oppositeAspectModel] - aspectModels[modelTable.aspectModel]
else:
uncoverableAspects = ()
aspectsCovered = set()
for tblAxisRel in modelXbrl.relationshipSet((XbrlConst.tableBreakdown, XbrlConst.tableBreakdownMMDD, XbrlConst.tableBreakdown201305, XbrlConst.tableBreakdown201301,XbrlConst.tableAxis2011)).fromModelObject(modelTable):
breakdownAspectsCovered = set()
hasCoveredAspect = checkBreakdownDefinitionNode(modelXbrl, modelTable, tblAxisRel, tblAxisRel.axisDisposition, uncoverableAspects, breakdownAspectsCovered)
''' removed 2013-10
if not hasCoveredAspect:
definitionNode = tblAxisRel.toModelObject
modelXbrl.error("xbrlte:breakdownDefinesNoAspects",
_("Breakdown %(xlinkLabel)s has no participating aspects"),
modelObject=(modelTable,definitionNode), xlinkLabel=definitionNode.xlinkLabel, axis=definitionNode.localName)
'''
aspectsCovered |= breakdownAspectsCovered
checkBreakdownLeafNodeAspects(modelXbrl, modelTable, tblAxisRel, set(), breakdownAspectsCovered)
if Aspect.CONCEPT not in aspectsCovered and not hasNsWithAspectModel:
modelXbrl.error("xbrlte:tableMissingConceptAspect",
_("Table %(xlinkLabel)s does not include the concept aspect as one of its participating aspects"),
modelObject=modelTable, xlinkLabel=modelTable.xlinkLabel)
del modelTable.priorAspectAxisDisposition
# check for table-parameter name clash
parameterNames = {}
for tblParamRel in modelXbrl.relationshipSet((XbrlConst.tableParameter, XbrlConst.tableParameterMMDD)).fromModelObject(modelTable):
parameterName = tblParamRel.variableQname
if parameterName in parameterNames:
modelXbrl.error("xbrlte:tableParameterNameClash ",
_("Table %(xlinkLabel)s has parameter name clash for variable %(name)s"),
modelObject=(modelTable,tblParamRel,parameterNames[parameterName]), xlinkLabel=modelTable.xlinkLabel, name=parameterName)
else:
parameterNames[parameterName] = tblParamRel
modelXbrl.profileStat(_("compileTables"))
def init(modelXbrl):
# setup modelXbrl for rendering evaluation
# dimension defaults required in advance of validation
from arelle import ValidateXbrlDimensions, ValidateFormula, ModelDocument
ValidateXbrlDimensions.loadDimensionDefaults(modelXbrl)
hasXbrlTables = False
# validate table linkbase dimensions
for baseSetKey in modelXbrl.baseSets.keys():
arcrole, ELR, linkqname, arcqname = baseSetKey
if ELR and linkqname and arcqname and XbrlConst.isTableRenderingArcrole(
arcrole):
ValidateFormula.checkBaseSet(
modelXbrl, arcrole, ELR,
modelXbrl.relationshipSet(arcrole, ELR, linkqname, arcqname))
if arcrole in (XbrlConst.tableBreakdown,
XbrlConst.tableBreakdownMMDD,
XbrlConst.tableBreakdown201305,
XbrlConst.tableBreakdown201301,
XbrlConst.tableAxis2011):
hasXbrlTables = True
# provide context for view
if modelXbrl.modelDocument.type == ModelDocument.Type.INSTANCE:
instance = None # use instance of the entry pont
else: # need dummy instance
instance = ModelDocument.create(
modelXbrl,
ModelDocument.Type.INSTANCE,
"dummy.xml", # fake URI and fake schemaRef
("http://www.xbrl.org/2003/xbrl-instance-2003-12-31.xsd", ))
if hasXbrlTables:
# formula processor is needed for 2011 XBRL tables but not for 2010 Eurofiling tables
modelXbrl.rendrCntx = XPathContext.create(modelXbrl, instance)
modelXbrl.profileStat(None)
# setup fresh parameters from formula options
modelXbrl.parameters = modelXbrl.modelManager.formulaOptions.typedParameters(
)
# validate parameters and custom function signatures
ValidateFormula.validate(modelXbrl,
xpathContext=modelXbrl.rendrCntx,
parametersOnly=True,
statusMsg=_("compiling rendering tables"))
# deprecated as of 2013-05-17
# check and extract message expressions into compilable programs
for msgArcrole in (XbrlConst.tableDefinitionNodeMessage201301,
XbrlConst.tableDefinitionNodeSelectionMessage201301,
XbrlConst.tableAxisMessage2011,
XbrlConst.tableAxisSelectionMessage2011):
for msgRel in modelXbrl.relationshipSet(
msgArcrole).modelRelationships:
ValidateFormula.checkMessageExpressions(
modelXbrl, msgRel.toModelObject)
# compile and validate tables
for modelTable in modelXbrl.modelRenderingTables:
modelTable.fromInstanceQnames = None # required if referred to by variables scope chaining
modelTable.compile()
hasNsWithAspectModel = modelTable.namespaceURI in (
XbrlConst.euRend, XbrlConst.table2011, XbrlConst.table201301,
XbrlConst.table201305)
# check aspectModel (attribute removed 2013-06, now always dimensional)
if modelTable.aspectModel not in (
"non-dimensional", "dimensional") and hasNsWithAspectModel:
modelXbrl.error(
"xbrlte:unknownAspectModel",
_("Table %(xlinkLabel)s, aspect model %(aspectModel)s not recognized"
),
modelObject=modelTable,
xlinkLabel=modelTable.xlinkLabel,
aspectModel=modelTable.aspectModel)
else:
modelTable.priorAspectAxisDisposition = {}
# check ordinate aspects against aspectModel
oppositeAspectModel = (
_DICT_SET({'dimensional', 'non-dimensional'}) -
_DICT_SET({modelTable.aspectModel})).pop()
if hasNsWithAspectModel:
uncoverableAspects = aspectModels[
oppositeAspectModel] - aspectModels[
modelTable.aspectModel]
else:
uncoverableAspects = ()
aspectsCovered = set()
for tblAxisRel in modelXbrl.relationshipSet(
(XbrlConst.tableBreakdown, XbrlConst.tableBreakdownMMDD,
XbrlConst.tableBreakdown201305,
XbrlConst.tableBreakdown201301,
XbrlConst.tableAxis2011)).fromModelObject(modelTable):
breakdownAspectsCovered = set()
hasCoveredAspect = checkBreakdownDefinitionNode(
modelXbrl, modelTable, tblAxisRel,
tblAxisRel.axisDisposition, uncoverableAspects,
breakdownAspectsCovered)
''' removed 2013-10
if not hasCoveredAspect:
definitionNode = tblAxisRel.toModelObject
modelXbrl.error("xbrlte:breakdownDefinesNoAspects",
_("Breakdown %(xlinkLabel)s has no participating aspects"),
modelObject=(modelTable,definitionNode), xlinkLabel=definitionNode.xlinkLabel, axis=definitionNode.localName)
'''
aspectsCovered |= breakdownAspectsCovered
checkBreakdownLeafNodeAspects(modelXbrl, modelTable,
tblAxisRel, set(),
breakdownAspectsCovered)
if Aspect.CONCEPT not in aspectsCovered and not hasNsWithAspectModel:
modelXbrl.error(
"xbrlte:tableMissingConceptAspect",
_("Table %(xlinkLabel)s does not include the concept aspect as one of its participating aspects"
),
modelObject=modelTable,
xlinkLabel=modelTable.xlinkLabel)
del modelTable.priorAspectAxisDisposition
# check for table-parameter name clash
parameterNames = {}
for tblParamRel in modelXbrl.relationshipSet(
(XbrlConst.tableParameter, XbrlConst.tableParameterMMDD
)).fromModelObject(modelTable):
parameterName = tblParamRel.variableQname
if parameterName in parameterNames:
modelXbrl.error(
"xbrlte:tableParameterNameClash ",
_("Table %(xlinkLabel)s has parameter name clash for variable %(name)s"
),
modelObject=(modelTable, tblParamRel,
parameterNames[parameterName]),
xlinkLabel=modelTable.xlinkLabel,
name=parameterName)
else:
parameterNames[parameterName] = tblParamRel
modelXbrl.profileStat(_("compileTables"))
def linkbaseDiscover(self, linkbaseElement, inInstance=False):
for lbElement in linkbaseElement.iterchildren():
if isinstance(lbElement,ModelObject):
lbLn = lbElement.localName
lbNs = lbElement.namespaceURI
if lbNs == XbrlConst.link:
if lbLn == "roleRef" or lbLn == "arcroleRef":
href = self.discoverHref(lbElement)
if href is None:
self.modelXbrl.error("xbrl:hrefMissing",
_("Linkbase reference for %(linkbaseRefElement)s href attribute missing or malformed"),
modelObject=lbElement, linkbaseRefElement=lbLn)
else:
self.hrefObjects.append(href)
continue
if lbElement.get("{http://www.w3.org/1999/xlink}type") == "extended":
if isinstance(lbElement, ModelLink):
self.schemalocateElementNamespace(lbElement)
arcrolesFound = set()
dimensionArcFound = False
formulaArcFound = False
tableRenderingArcFound = False
linkQn = qname(lbElement)
linkrole = lbElement.get("{http://www.w3.org/1999/xlink}role")
isStandardExtLink = XbrlConst.isStandardResourceOrExtLinkElement(lbElement)
if inInstance:
#index footnote links even if no arc children
baseSetKeys = (("XBRL-footnotes",None,None,None),
("XBRL-footnotes",linkrole,None,None))
for baseSetKey in baseSetKeys:
self.modelXbrl.baseSets[baseSetKey].append(lbElement)
for linkElement in lbElement.iterchildren():
if isinstance(linkElement,ModelObject):
self.schemalocateElementNamespace(linkElement)
xlinkType = linkElement.get("{http://www.w3.org/1999/xlink}type")
modelResource = None
if xlinkType == "locator":
nonDTS = linkElement.namespaceURI != XbrlConst.link or linkElement.localName != "loc"
# only link:loc elements are discovered or processed
href = self.discoverHref(linkElement, nonDTS=nonDTS)
if href is None:
if isStandardExtLink:
self.modelXbrl.error("xbrl:hrefMissing",
_("Locator href attribute missing or malformed in standard extended link"),
modelObejct=linkElement)
else:
self.modelXbrl.warning("arelle:hrefWarning",
_("Locator href attribute missing or malformed in non-standard extended link"),
modelObejct=linkElement)
else:
linkElement.modelHref = href
modelResource = linkElement
elif xlinkType == "arc":
arcQn = qname(linkElement)
arcrole = linkElement.get("{http://www.w3.org/1999/xlink}arcrole")
if arcrole not in arcrolesFound:
if linkrole == "":
linkrole = XbrlConst.defaultLinkRole
#index by both arcrole and linkrole#arcrole and dimensionsions if applicable
baseSetKeys = [(arcrole, linkrole, linkQn, arcQn)]
baseSetKeys.append((arcrole, linkrole, None, None))
baseSetKeys.append((arcrole, None, None, None))
if XbrlConst.isDimensionArcrole(arcrole) and not dimensionArcFound:
baseSetKeys.append(("XBRL-dimensions", None, None, None))
baseSetKeys.append(("XBRL-dimensions", linkrole, None, None))
dimensionArcFound = True
if XbrlConst.isFormulaArcrole(arcrole) and not formulaArcFound:
baseSetKeys.append(("XBRL-formulae", None, None, None))
baseSetKeys.append(("XBRL-formulae", linkrole, None, None))
formulaArcFound = True
if XbrlConst.isTableRenderingArcrole(arcrole) and not tableRenderingArcFound:
baseSetKeys.append(("Table-rendering", None, None, None))
baseSetKeys.append(("Table-rendering", linkrole, None, None))
tableRenderingArcFound = True
self.modelXbrl.hasTableRendering = True
for baseSetKey in baseSetKeys:
self.modelXbrl.baseSets[baseSetKey].append(lbElement)
arcrolesFound.add(arcrole)
elif xlinkType == "resource":
# create resource and make accessible by id for document
modelResource = linkElement
if modelResource is not None:
lbElement.labeledResources[linkElement.get("{http://www.w3.org/1999/xlink}label")] \
.append(modelResource)
else:
self.modelXbrl.error("xbrl:schemaDefinitionMissing",
_("Linkbase extended link %(element)s missing schema definition"),
modelObject=lbElement, element=lbElement.prefixedName)
def __init__(self,
modelXbrl,
arcrole,
linkrole=None,
linkqname=None,
arcqname=None,
includeProhibits=False):
self.isChanged = False
self.modelXbrl = modelXbrl
self.arcrole = arcrole
self.linkrole = linkrole
self.linkqname = linkqname
self.arcqname = arcqname
baseSetKey = (arcrole, linkrole, linkqname, arcqname)
relationshipSetKey = (arcrole, linkrole, linkqname, arcqname,
includeProhibits)
# base sets does not care about the #includeProhibits
if baseSetKey in self.modelXbrl.baseSets:
modelLinks = self.modelXbrl.baseSets[baseSetKey]
else:
modelLinks = []
# gather arcs
relationships = {}
isDimensionRel = self.arcrole == "XBRL-dimensions" # all dimensional relationship arcroles
isFormulaRel = self.arcrole == "XBRL-formulae" # all formula relationship arcroles
isTableRenderingRel = self.arcrole == "Table-rendering"
isFootnoteRel = self.arcrole == "XBRL-footnotes" # all footnote relationship arcroles
for modelLink in modelLinks:
arcs = []
linkEltQname = modelLink.qname
for linkChild in modelLink:
linkChildArcrole = linkChild.get(
"{http://www.w3.org/1999/xlink}arcrole")
if linkChild.get("{http://www.w3.org/1999/xlink}type"
) == "arc" and linkChildArcrole:
linkChildQname = linkChild
if isFootnoteRel:
arcs.append(linkChild)
elif isDimensionRel:
if XbrlConst.isDimensionArcrole(linkChildArcrole):
arcs.append(linkChild)
elif isFormulaRel:
if XbrlConst.isFormulaArcrole(linkChildArcrole):
arcs.append(linkChild)
elif isTableRenderingRel:
if XbrlConst.isTableRenderingArcrole(linkChildArcrole):
arcs.append(linkChild)
elif arcrole == linkChildArcrole and \
(arcqname is None or arcqname == linkChildQname) and \
(linkqname is None or linkqname == linkEltQname):
arcs.append(linkChild)
# build network
for arcElement in arcs:
arcrole = arcElement.get(
"{http://www.w3.org/1999/xlink}arcrole")
fromLabel = arcElement.get(
"{http://www.w3.org/1999/xlink}from")
toLabel = arcElement.get("{http://www.w3.org/1999/xlink}to")
for fromResource in modelLink.labeledResources[fromLabel]:
for toResource in modelLink.labeledResources[toLabel]:
if isinstance(fromResource,
ModelResource) and isinstance(
toResource, ModelResource):
modelRel = ModelDtsObject.ModelRelationship(
modelLink.modelDocument, arcElement,
fromResource.dereference(),
toResource.dereference())
modelRelEquivalenceKey = modelRel.equivalenceKey # this is a complex tuple to compute, get once for below
if modelRelEquivalenceKey not in relationships or \
modelRel.priorityOver(relationships[modelRelEquivalenceKey]):
relationships[
modelRelEquivalenceKey] = modelRel
#reduce effective arcs and order relationships...
self.modelRelationshipsFrom = None
self.modelRelationshipsTo = None
self.modelConceptRoots = None
self.modellinkRoleUris = None
orderRels = defaultdict(list)
for modelRel in relationships.values():
if includeProhibits or not modelRel.isProhibited:
orderRels[modelRel.order].append(modelRel)
self.modelRelationships = [
modelRel for order in sorted(orderRels.keys())
for modelRel in orderRels[order]
]
modelXbrl.relationshipSets[relationshipSetKey] = self
def init(modelXbrl):
# setup modelXbrl for rendering evaluation
# dimension defaults required in advance of validation
from arelle import ValidateXbrlDimensions, ValidateFormula, ModelDocument
ValidateXbrlDimensions.loadDimensionDefaults(modelXbrl)
hasXbrlTables = False
# validate table linkbase dimensions
for baseSetKey in modelXbrl.baseSets.keys():
arcrole, ELR, linkqname, arcqname = baseSetKey
if ELR and linkqname and arcqname and XbrlConst.isTableRenderingArcrole(arcrole):
ValidateFormula.checkBaseSet(modelXbrl, arcrole, ELR, modelXbrl.relationshipSet(arcrole,ELR,linkqname,arcqname))
if arcrole in (XbrlConst.tableBreakdown, XbrlConst.tableAxis2011):
hasXbrlTables = True
# provide context for view
if modelXbrl.modelDocument.type == ModelDocument.Type.INSTANCE:
instance = None # use instance of the entry pont
else: # need dummy instance
instance = ModelDocument.create(modelXbrl, ModelDocument.Type.INSTANCE,
"dummy.xml", # fake URI and fake schemaRef
("http://www.xbrl.org/2003/xbrl-instance-2003-12-31.xsd",))
if hasXbrlTables:
# formula processor is needed for 2011 XBRL tables but not for 2010 Eurofiling tables
modelXbrl.rendrCntx = XPathContext.create(modelXbrl, instance)
modelXbrl.profileStat(None)
# setup fresh parameters from formula optoins
modelXbrl.parameters = modelXbrl.modelManager.formulaOptions.typedParameters()
# validate parameters and custom function signatures
ValidateFormula.validate(modelXbrl, xpathContext=modelXbrl.rendrCntx, parametersOnly=True, statusMsg=_("compiling rendering tables"))
# check and extract message expressions into compilable programs
for msgArcrole in (XbrlConst.tableDefinitionNodeMessage, XbrlConst.tableDefinitionNodeSelectionMessage,
XbrlConst.tableAxisMessage2011, XbrlConst.tableAxisSelectionMessage2011):
for msgRel in modelXbrl.relationshipSet(msgArcrole).modelRelationships:
ValidateFormula.checkMessageExpressions(modelXbrl, msgRel.toModelObject)
# compile and validate tables
for modelTable in modelXbrl.modelRenderingTables:
modelTable.fromInstanceQnames = None # required if referred to by variables scope chaining
modelTable.compile()
# check aspectModel
if modelTable.aspectModel not in ("non-dimensional", "dimensional"):
modelXbrl.error("xbrlte:unknownAspectModel",
_("Table %(xlinkLabel)s, aspect model %(aspectModel)s not recognized"),
modelObject=modelTable, xlinkLabel=modelTable.xlinkLabel, aspectModel=modelTable.aspectModel)
else:
modelTable.priorAspectAxisDisposition = {}
# check ordinate aspects against aspectModel
oppositeAspectModel = (_DICT_SET({'dimensional','non-dimensional'}) - _DICT_SET({modelTable.aspectModel})).pop()
uncoverableAspects = aspectModels[oppositeAspectModel] - aspectModels[modelTable.aspectModel]
for tblAxisRel in modelXbrl.relationshipSet((XbrlConst.tableBreakdown,XbrlConst.tableAxis2011)).fromModelObject(modelTable):
checkDefinitionNodeAspectModel(modelXbrl, modelTable, tblAxisRel, uncoverableAspects)
del modelTable.priorAspectAxisDisposition
modelXbrl.profileStat(_("compileTables"))
def init(modelXbrl):
# setup modelXbrl for rendering evaluation
# dimension defaults required in advance of validation
from arelle import ValidateXbrlDimensions, ValidateFormula, ModelDocument
ValidateXbrlDimensions.loadDimensionDefaults(modelXbrl)
hasXbrlTables = False
# validate table linkbase dimensions
for baseSetKey in modelXbrl.baseSets.keys():
arcrole, ELR, linkqname, arcqname = baseSetKey
if ELR and linkqname and arcqname and XbrlConst.isTableRenderingArcrole(
arcrole):
ValidateFormula.checkBaseSet(
modelXbrl, arcrole, ELR,
modelXbrl.relationshipSet(arcrole, ELR, linkqname, arcqname))
if arcrole in (XbrlConst.tableBreakdown,
XbrlConst.tableBreakdown201301,
XbrlConst.tableAxis2011):
hasXbrlTables = True
# provide context for view
if modelXbrl.modelDocument.type == ModelDocument.Type.INSTANCE:
instance = None # use instance of the entry pont
else: # need dummy instance
instance = ModelDocument.create(
modelXbrl,
ModelDocument.Type.INSTANCE,
"dummy.xml", # fake URI and fake schemaRef
("http://www.xbrl.org/2003/xbrl-instance-2003-12-31.xsd", ))
if hasXbrlTables:
# formula processor is needed for 2011 XBRL tables but not for 2010 Eurofiling tables
modelXbrl.rendrCntx = XPathContext.create(modelXbrl, instance)
modelXbrl.profileStat(None)
# setup fresh parameters from formula optoins
modelXbrl.parameters = modelXbrl.modelManager.formulaOptions.typedParameters(
)
# validate parameters and custom function signatures
ValidateFormula.validate(modelXbrl,
xpathContext=modelXbrl.rendrCntx,
parametersOnly=True,
statusMsg=_("compiling rendering tables"))
# deprecated as of 2013-05-17
# check and extract message expressions into compilable programs
for msgArcrole in (XbrlConst.tableDefinitionNodeMessage201301,
XbrlConst.tableDefinitionNodeSelectionMessage201301,
XbrlConst.tableAxisMessage2011,
XbrlConst.tableAxisSelectionMessage2011):
for msgRel in modelXbrl.relationshipSet(
msgArcrole).modelRelationships:
ValidateFormula.checkMessageExpressions(
modelXbrl, msgRel.toModelObject)
# compile and validate tables
for modelTable in modelXbrl.modelRenderingTables:
modelTable.fromInstanceQnames = None # required if referred to by variables scope chaining
modelTable.compile()
# check aspectModel
if modelTable.aspectModel not in ("non-dimensional",
"dimensional"):
modelXbrl.error(
"xbrlte:unknownAspectModel",
_("Table %(xlinkLabel)s, aspect model %(aspectModel)s not recognized"
),
modelObject=modelTable,
xlinkLabel=modelTable.xlinkLabel,
aspectModel=modelTable.aspectModel)
else:
modelTable.priorAspectAxisDisposition = {}
# check ordinate aspects against aspectModel
oppositeAspectModel = (
_DICT_SET({'dimensional', 'non-dimensional'}) -
_DICT_SET({modelTable.aspectModel})).pop()
uncoverableAspects = aspectModels[
oppositeAspectModel] - aspectModels[modelTable.aspectModel]
for tblAxisRel in modelXbrl.relationshipSet(
(XbrlConst.tableBreakdown, XbrlConst.tableBreakdown201301,
XbrlConst.tableAxis2011)).fromModelObject(modelTable):
checkDefinitionNodeAspectModel(modelXbrl, modelTable,
tblAxisRel,
uncoverableAspects)
del modelTable.priorAspectAxisDisposition
modelXbrl.profileStat(_("compileTables"))
def linkbaseDiscover(self, linkbaseElement, inInstance=False):
for lbElement in linkbaseElement.iterchildren():
if isinstance(lbElement, ModelObject):
lbLn = lbElement.localName
lbNs = lbElement.namespaceURI
if lbNs == XbrlConst.link:
if lbLn == "roleRef" or lbLn == "arcroleRef":
href = self.discoverHref(lbElement)
if href is None:
self.modelXbrl.error(
"xmlSchema:requiredAttribute",
_("Linkbase reference for %(linkbaseRefElement)s href attribute missing or malformed"
),
modelObject=lbElement,
linkbaseRefElement=lbLn)
else:
self.hrefObjects.append(href)
continue
if lbElement.get(
"{http://www.w3.org/1999/xlink}type") == "extended":
if isinstance(lbElement, ModelLink):
self.schemalocateElementNamespace(lbElement)
arcrolesFound = set()
dimensionArcFound = False
formulaArcFound = False
tableRenderingArcFound = False
linkQn = qname(lbElement)
linkrole = lbElement.get(
"{http://www.w3.org/1999/xlink}role")
isStandardExtLink = XbrlConst.isStandardResourceOrExtLinkElement(
lbElement)
if inInstance:
#index footnote links even if no arc children
baseSetKeys = (("XBRL-footnotes", None, None,
None), ("XBRL-footnotes", linkrole,
None, None))
for baseSetKey in baseSetKeys:
self.modelXbrl.baseSets[baseSetKey].append(
lbElement)
for linkElement in lbElement.iterchildren():
if isinstance(linkElement, ModelObject):
self.schemalocateElementNamespace(linkElement)
xlinkType = linkElement.get(
"{http://www.w3.org/1999/xlink}type")
modelResource = None
if xlinkType == "locator":
nonDTS = linkElement.namespaceURI != XbrlConst.link or linkElement.localName != "loc"
# only link:loc elements are discovered or processed
href = self.discoverHref(linkElement,
nonDTS=nonDTS)
if href is None:
if isStandardExtLink:
self.modelXbrl.error(
"xmlSchema:requiredAttribute",
_("Locator href attribute missing or malformed in standard extended link"
),
modelObejct=linkElement)
else:
self.modelXbrl.warning(
"arelle:hrefWarning",
_("Locator href attribute missing or malformed in non-standard extended link"
),
modelObejct=linkElement)
else:
linkElement.modelHref = href
modelResource = linkElement
elif xlinkType == "arc":
arcQn = qname(linkElement)
arcrole = linkElement.get(
"{http://www.w3.org/1999/xlink}arcrole"
)
if arcrole not in arcrolesFound:
if linkrole == "":
linkrole = XbrlConst.defaultLinkRole
#index by both arcrole and linkrole#arcrole and dimensionsions if applicable
baseSetKeys = [(arcrole, linkrole,
linkQn, arcQn)]
baseSetKeys.append(
(arcrole, linkrole, None, None))
baseSetKeys.append(
(arcrole, None, None, None))
if XbrlConst.isDimensionArcrole(
arcrole
) and not dimensionArcFound:
baseSetKeys.append(
("XBRL-dimensions", None, None,
None))
baseSetKeys.append(
("XBRL-dimensions", linkrole,
None, None))
dimensionArcFound = True
if XbrlConst.isFormulaArcrole(
arcrole
) and not formulaArcFound:
baseSetKeys.append(
("XBRL-formulae", None, None,
None))
baseSetKeys.append(
("XBRL-formulae", linkrole,
None, None))
formulaArcFound = True
if XbrlConst.isTableRenderingArcrole(
arcrole
) and not tableRenderingArcFound:
baseSetKeys.append(
("Table-rendering", None, None,
None))
baseSetKeys.append(
("Table-rendering", linkrole,
None, None))
tableRenderingArcFound = True
self.modelXbrl.hasTableRendering = True
for baseSetKey in baseSetKeys:
self.modelXbrl.baseSets[
baseSetKey].append(lbElement)
arcrolesFound.add(arcrole)
elif xlinkType == "resource":
# create resource and make accessible by id for document
modelResource = linkElement
if modelResource is not None:
lbElement.labeledResources[linkElement.get("{http://www.w3.org/1999/xlink}label")] \
.append(modelResource)
else:
self.modelXbrl.error(
"xbrl:schemaDefinitionMissing",
_("Linkbase extended link %(element)s missing schema definition"
),
modelObject=lbElement,
element=lbElement.prefixedName)
