arelle-release 2.17.1__py3-none-any.whl → 2.37.71__py3-none-any.whl

arelle/plugin/OimTaxonomy/XbrlTaxonomy.py

@@ -0,0 +1,93 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional, Union
+from collections import OrderedDict
+
+from arelle.ModelValue import qname, QName, AnyURI
+from arelle.PythonUtil import OrderedSet
+from .ModelValueMore import SQName
+from .XbrlDts import XbrlDts
+from .XbrlImportedTaxonomy import XbrlImportedTaxonomy
+from .XbrlProperty import XbrlProperty
+from .XbrlAbstract import XbrlAbstract
+from .XbrlConcept import XbrlConcept, XbrlDataType, XbrlUnitType
+from .XbrlCube import XbrlCube, XbrlCubeType, XbrlCubeDimension, XbrlPeriodConstraint, XbrlDateResolution
+from .XbrlDimension import XbrlDimension, XbrlDomain, XbrlDomainRoot, XbrlMember
+from .XbrlEntity import XbrlEntity
+from .XbrlGroup import XbrlGroup, XbrlGroupContent
+from .XbrlLabel import XbrlLabel, XbrlLabelType
+from .XbrlNetwork import XbrlNetwork, XbrlRelationship, XbrlRelationshipType
+from .XbrlProperty import XbrlProperty, XbrlPropertyType
+from .XbrlReference import XbrlReference, XbrlReferenceType
+from .XbrlTransform import XbrlTransform
+from .XbrlUnit import XbrlUnit
+from .XbrlTypes import QNameKeyType, XbrlTaxonomyType
+from .XbrlTaxonomyObject import XbrlTaxonomyObject
+from .XbrlTableTemplate import XbrlTableTemplate, XbrlDataTable
+
+class XbrlTaxonomy(XbrlTaxonomyObject):
+    dts: XbrlDts
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the taxonomy object.
+    frameworkName: Optional[str] # (optional) The framework name of the taxonomy such as "US-GAAP" that indicates the taxonomy broad taxonomy family. The framework name stays consistent between regular taxonomy releases of the same taxonomy domain.
+    version: Optional[str] # (optional) Used to identify the version of the taxonomy such as the year of release.
+    resolved: bool # (required) Used to indicate if the taxonomy is in a resolved form. Allowable values are true or false. True indicates that the taxonomy is a complete model including all objects post dts processing that has resolved all importedTaxonomy objects, extendTargetName attributes and domain filters. False indicates that the taxonomy is pre dts processing and is not in resolved form.
+    importedTaxonomies: OrderedSet[XbrlImportedTaxonomy] # ordered set of importedTaxonomy objects that can comprise QName of the taxonomy to be imported, an object type or a taxonomy object referenced by its QName.
+    abstracts: OrderedSet[XbrlAbstract] # ordered set of abstract objects.
+    concepts: OrderedSet[XbrlConcept] # ordered set of concept objects.
+    cubes: OrderedSet[XbrlCube] # ordered set of cube objects.
+    cubeTypes: OrderedSet[XbrlCubeType] # ordered set of cubeType objects.
+    dataTypes: OrderedSet[XbrlDataType] # ordered set of dataType objects.
+    dimensions: OrderedSet[XbrlDimension] # ordered set of dimension objects.
+    domains: OrderedSet[XbrlDomain] # (optional) ordered set of domain objects.
+    domainRoots: OrderedSet[XbrlDomainRoot] # (optional) ordered set of domain root objects.
+    entities: OrderedSet[XbrlEntity] # (optional) ordered set of entity objects.
+    groups: OrderedSet[XbrlGroup] #  ordered set of group objects.
+    groupContents: OrderedSet[XbrlGroupContent] # ordered set of groupContent objects that link a group QName to a list of network or cube objects.
+    labels: OrderedSet[XbrlLabel] # ordered set of label objects.
+    members: OrderedSet[XbrlMember] #  ordered set of member objects.
+    networks: OrderedSet[XbrlNetwork] # ordered set of network objects.
+    propertyTypes: OrderedSet[XbrlPropertyType] # ordered set of propertyType objects.
+    references: OrderedSet[XbrlReference] # ordered set of reference objects.
+    labelTypes: OrderedSet[XbrlLabelType] # rdered set of labelType objects.
+    referenceTypes: OrderedSet[XbrlReferenceType] # ordered set of referenceType objects.
+    relationshipTypes: OrderedSet[XbrlRelationshipType] # ordered set of relationshipType objects.
+    tableTemplates: OrderedSet[XbrlTableTemplate] # ordered set of tableTemplate objects.
+    dataTables: OrderedSet[XbrlDataTable] # (optional) ordered set of dataTable objects.
+    transforms: OrderedSet[XbrlTransform] # (optional) an ordered set of transform objects.
+    units: OrderedSet[XbrlUnit] # ordered set of unit objects.
+    properties: OrderedSet[XbrlProperty] # ordered set of property objects used to specify additional properties associated with the taxonomy. Only immutable properties as defined in the propertyType object can be added to a taxonom
+
+xbrlObjectTypes = {
+        qname("{https://xbrl.org/2025}xbrl:taxonomyObject"): XbrlTaxonomy,
+        qname("{https://xbrl.org/2025}xbrl:importTaxonomyObject"): XbrlImportedTaxonomy,
+        qname("{https://xbrl.org/2025}xbrl:conceptObject"): XbrlConcept,
+        qname("{https://xbrl.org/2025}xbrl:abstractObject"): XbrlAbstract,
+        qname("{https://xbrl.org/2025}xbrl:cubeObject"): XbrlCube,
+        qname("{https://xbrl.org/2025}xbrl:cubeDimensionObject"): XbrlCubeDimension,
+        qname("{https://xbrl.org/2025}xbrl:periodConstraintObject"): XbrlPeriodConstraint,
+        qname("{https://xbrl.org/2025}xbrl:dateResolutionObject"): XbrlDateResolution,
+        qname("{https://xbrl.org/2025}xbrl:dimensionObject"): XbrlDimension,
+        qname("{https://xbrl.org/2025}xbrl:domainObject"): XbrlDomain,
+        qname("{https://xbrl.org/2025}xbrl:entityObject"): XbrlEntity,
+        qname("{https://xbrl.org/2025}xbrl:groupObject"): XbrlGroup,
+        qname("{https://xbrl.org/2025}xbrl:groupContentObject"): XbrlGroupContent,
+        qname("{https://xbrl.org/2025}xbrl:networkObject"): XbrlNetwork,
+        qname("{https://xbrl.org/2025}xbrl:relationshipObject"): XbrlRelationship,
+        qname("{https://xbrl.org/2025}xbrl:relationshipTypeObject"): XbrlRelationshipType,
+        qname("{https://xbrl.org/2025}xbrl:labelObject"): XbrlLabel,
+        qname("{https://xbrl.org/2025}xbrl:memberObject"): XbrlMember,
+        qname("{https://xbrl.org/2025}xbrl:propertyObject"): XbrlProperty,
+        qname("{https://xbrl.org/2025}xbrl:referenceObject"): XbrlReference,
+        qname("{https://xbrl.org/2025}xbrl:dataTypeObject"): XbrlDataType,
+        qname("{https://xbrl.org/2025}xbrl:propertyTypeObject"): XbrlPropertyType,
+        qname("{https://xbrl.org/2025}xbrl:labelTypeObject"): XbrlLabelType,
+        qname("{https://xbrl.org/2025}xbrl:referenceTypeObject"): XbrlReferenceType,
+        qname("{https://xbrl.org/2025}xbrl:cubeTypeObject"): XbrlCubeType,
+        qname("{https://xbrl.org/2025}xbrl:tableTemplateObject"): XbrlTableTemplate,
+        qname("{https://xbrl.org/2025}xbrl:transformObject"): XbrlTransform,
+        qname("{https://xbrl.org/2025}xbrl:unitObject"): XbrlUnit,
+        qname("{https://xbrl.org/2025}xbrl:unitTypeObject"): XbrlUnitType,
+    }
+xbrlObjectQNames = dict((v,k) for k,v in xbrlObjectTypes.items())

arelle/plugin/OimTaxonomy/XbrlTaxonomyObject.py

@@ -0,0 +1,154 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from typing import GenericAlias, _UnionGenericAlias, Any
+import os
+from .XbrlConst import qnStdLabel
+XbrlTaxonomyObject = None # class forward reference
+
+EMPTY_DICT = {}
+
+class XbrlObject:
+
+    def __init__(self, dtsObjectIndex=0, **kwargs):
+        self.dtsObjectIndex = dtsObjectIndex
+
+    @property
+    def xbrlDts(self):
+        return None
+
+    @property
+    def entryLoadingUrl(self):
+        href = str(getattr(getattr(self, 'taxonomy', None), 'name', '(none)'))
+        className = type(self).__name__
+        if className.startswith("Xbrl"):
+            classIndex = getattr(self, "_classIndex", None)
+            if classIndex is not None:
+                href = f"{href}/{className[4].lower()}{className[5:]}[{classIndex}]"
+        return href
+
+    def getProperty(self, propertyName, propertyClass=None, propertyType=None, language=None, defaultValue=None):
+        return getattr(self, propertyName, defaultValue)
+
+    @property
+    def propertyView(self):
+        objClass = type(self)
+        isTaxonomyObject = isinstance(self, XbrlTaxonomyObject)
+        objName = objClass.__name__[0].lower() + objClass.__name__[1:]
+        propVals = []
+        initialParentObjProp = True
+        referenceProperties = None
+        for propName, propType in getattr(objClass, "__annotations__", EMPTY_DICT).items():
+            if initialParentObjProp:
+                initialParentObjProp = False
+                if isinstance(propType, str) or propType.__name__.startswith("Xbrl"): # skip taxonomy alias type
+                    continue
+            if hasattr(self, propName):
+                val = getattr(self, propName)
+                if isTaxonomyObject: # for Taxonomy objects, not used by OIM Instance objects
+                    if propName == "properties":
+                        for propObj in val:
+                            propVals.append( (str(getattr(propObj, "property", "")), str(getattr(propObj, "value", ""))) )
+                        continue
+                    if propName in ("name", "groupName") and val and issubclass(objClass, XbrlReferencableTaxonomyObject):
+                        # insert label first if any
+                        label = self.xbrlDts.labelValue(val, qnStdLabel, fallbackToName=False)
+                        if label:
+                            propVals.append( ("label", label) )
+                        referenceProperties = self.xbrlDts.referenceProperties(val, None)
+                elif propName == "dimensions" and isinstance(val, dict):
+                    for propKey, propVal in val.items():
+                        propVals.append( (str(propKey), str(propVal) ) )
+                    continue
+                if isinstance(propType, GenericAlias): # set, dict, etc
+                    propValueClass = propType.__args__[-1]
+                    if hasattr(propValueClass, "propertyView"):
+                        # skip empty sets of XBRL objects
+                        if isinstance(val, (set,list)) and propValueClass.__name__.startswith("Xbrl"):
+                            continue
+                        propVal = [propName, f"({len(val)})"]
+                        nestedPropvals = [o.propertyView for o in val]
+                        if isinstance(nestedPropvals, (list, tuple)):
+                            l = len(nestedPropvals)
+                            if l == 1:
+                                if isinstance(nestedPropvals[0], (list, tuple)):
+                                    nestedPropvals = nestedPropvals[0]
+                            elif l > 1:
+                                if isinstance(nestedPropvals[0], (list, tuple)) and isinstance(nestedPropvals[0][0], (list, tuple)) and len(nestedPropvals[0][0]) == 2:
+                                    # flatten properties
+                                    flatPropvals = []
+                                    for i,subPropval in enumerate(nestedPropvals):
+                                        for subPropEnt in subPropval:
+                                            flatPropvals.append([f"[{i}] {subPropEnt[0]}"]+[s for s in subPropEnt[1:]])
+                                    nestedPropvals = flatPropvals
+                        if nestedPropvals:
+                            propVal.extend([nestedPropvals])
+                    elif len(val) > 0:
+                        propVal = ", ".join(str(v) for v in val)
+                    else:
+                        continue # omit this property
+                elif val is None and isinstance(propType, _UnionGenericAlias) and propType.__args__[-1] == type(None):
+                    continue # skip showing absent Optional[...] properties
+                else:
+                    propVal = (propName, f"{val}")
+                propVals.append(propVal)
+        if referenceProperties:
+            for refType, refObjs in sorted(referenceProperties.items(), key=lambda a: str(a[0])):
+                propVals.append(
+                    ("references", str(refType), tuple(
+                    (getattr(rp, "propertyTypeName", ""), getattr(rp, "value", "")) for rp in refObjs)))
+        return tuple(propVals)
+
+    def __repr__(self):
+        # print object generic string based on class declaration
+        objClass = type(self)
+        objName = objClass.__name__[0].lower() + objClass.__name__[1:]
+        propVals = [f"{self.dtsObjectIndex}"]
+        initialParentObjProp = True
+        for propName, propType in getattr(objClass, "__annotations__", EMPTY_DICT).items():
+            if initialParentObjProp:
+                initialParentProp = False
+                if isinstance(propType, str) or getattr(propType, "__name__", "").startswith("Xbrl"): # skip taxonomy alias type
+                    continue
+            if hasattr(self, propName):
+                val = getattr(self, propName)
+                if isinstance(propType, GenericAlias): # set, dict, etc
+                    val = f"({len(val)})"
+                propVals.append(f"{propName}: {val}")
+        return f"{objName}[{', '.join(propVals)}]"
+
+class XbrlTaxonomyObject(XbrlObject):
+    pass
+
+class XbrlReportObject(XbrlObject):
+    pass
+
+class XbrlReferencableTaxonomyObject(XbrlTaxonomyObject):
+
+    def __init__(self,  *args: Any, **kwargs: Any) -> None:
+        super(XbrlReferencableTaxonomyObject, self).__init__(*args, **kwargs)
+
+    @property
+    def xbrlDts(self):
+        if hasattr(self, "taxonomy"):
+            return self.taxonomy.dts
+        return None
+
+    def getProperty(self, propertyName, propertyType=None, language=None, defaultValue=None):
+        if propertyName == "label" and hasattr(self, "name"):
+            return self.xbrlDts.labelValue(self.name, propertyType or qnStdLabel, language)
+        return getattr(self, propertyName, defaultValue)
+
+class XbrlTaxonomyTagObject(XbrlTaxonomyObject):
+
+    def __init__(self,  *args: Any, **kwargs: Any) -> None:
+        super(XbrlTaxonomyTagObject, self).__init__(*args, **kwargs)
+
+    @property
+    def xbrlDts(self):
+        if hasattr(self, "taxonomy"):
+            return self.taxonomy.dts
+        return None
+
+    def getProperty(self, propertyName, propertyType=None, language=None, defaultValue=None):
+        return getattr(self, propertyName, defaultValue)

arelle/plugin/OimTaxonomy/XbrlTransform.py

@@ -0,0 +1,17 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING
+
+from arelle.ModelValue import QName, YearMonthDayTimeDuration
+from arelle.PythonUtil import OrderedSet
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType
+from .ModelValueMore import QNameAt, SQName
+from .XbrlTaxonomyObject import XbrlReferencableTaxonomyObject
+
+class XbrlTransform(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the transform object.
+    inputDataType: QName # (required) Indicates the datatype of the input to be transformed.
+    outputDataType: QName # (required) Indicates the datatype of the input to be transformed.

arelle/plugin/OimTaxonomy/XbrlTypes.py

@@ -0,0 +1,23 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing_extensions import TypeAlias
+from arelle.ModelValue import QName
+
+XbrlDtsType: TypeAlias = "XbrlDts"
+XbrlLabelType: TypeAlias = "XbrlLabel"
+XbrlPropertyType: TypeAlias = "XbrlProperty"
+XbrlTaxonomyType: TypeAlias = "XbrlTaxonomy"
+class QNameKeyType(QName): # a QName which is also the primary key for parent collection object
+    pass
+class SQNameKeyType(QName): # an SQName which is also the primary key for parent collection object
+    pass
+class strKeyType(str): # a str which is also the primary key for parent collection object
+    pass
+class DefaultTrue: # a bool which if absent defaults to true
+    pass
+class DefaultFalse: # a bool which if absent defaults to false
+    pass
+class DefaultZero: # a number which if absent defaults to zero
+    pass

arelle/plugin/OimTaxonomy/XbrlUnit.py

@@ -0,0 +1,17 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional
+
+from arelle.ModelValue import QName
+from arelle.PythonUtil import OrderedSet
+from .XbrlTypes import XbrlTaxonomyType, SQNameKeyType
+from .XbrlTaxonomyObject import XbrlReferencableTaxonomyObject
+
+class XbrlUnit(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: SQNameKeyType # (required) The unitQName that identifies the unit so it can be referenced by other objects.
+    dataType: QName # (required) Indicates the dataType of the unit. These are provided as a QName based on the datatypes specified in the XBRL 2.1 specification and any custom datatype defined in the taxonomy.
+    dataTypeNumerator: Optional[QName] # (optional) Indicates the dataType of the unit numerator when the unit is comprised of a division of two datatypes. This is an optional property and must be used with dataTypeDenominator
+    dataTypeDenominator: Optional[QName] # (optional) Indicates the dataType of the unit denominator when the unit is comprised of a division of two datatypes. This is an optional property and must be used with dataTypeNumerator