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

arelle/plugin/OimTaxonomy/XbrlCube.py

@@ -0,0 +1,91 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional, Union
+
+from arelle.ModelValue import qname, QName, DateTime, YearMonthDayTimeDuration
+from arelle.PythonUtil import OrderedSet
+from .XbrlConst import xbrl
+from .XbrlProperty import XbrlProperty
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType, DefaultTrue, DefaultFalse
+from .ModelValueMore import QNameAt, SQName
+from .XbrlTaxonomyObject import XbrlTaxonomyObject, XbrlReferencableTaxonomyObject
+
+class XbrlDateResolution(XbrlTaxonomyObject):
+    conceptName: Optional[QName] # (optional) Identifies the QName of a concept object that has a date fact value. The values of the concept object resolves to a set of dates. If no value exists in the report then the property is ignored, and no date constraint is enforced on the cube.
+    context: Optional[QNameAt] # (optional) Identifies the QName of a concept object that has a value. The context of the fact values resolves to a set of dates. If no value exists in the report then the property is ignored. The context suffix must be either @end or @start. If an @ value is not provided then the suffix defaults to @end.
+    value: Optional[DateTime] # (optional) A literal date value representing the end date.
+    timeShift: Optional[YearMonthDayTimeDuration] # (optional) Defines a time duration shift from the date derived form either the value, context or name properties. The duration of the time shift is defined using the XML duration type to define a duration of time. A negative operator is used to deduct the timeShift from the resolved date.
+
+class XbrlPeriodConstraint(XbrlTaxonomyObject):
+    periodType: str # (required) Used to indicate if the period is an instant or a duration.
+    timeSpan: Optional[str] # (optional) Defines a duration of time using the XML duration type to define a duration of time. The duration of the time span maps to facts with the same duration.
+    periodFormat: Optional[str] # (optional) Defines a a duration of time with an end date. The period value defined in the taxonomy must resolve to a valid period format as defined in xbrl-csv specification.
+    monthDay: Optional[XbrlDateResolution] # (optional) Represents a Gregorian date that recurs such as 04-16. The date resolution object when used with this property returns the date without the year. The conceptName property of the dateResolution object can also use a datatype of monthDay.
+    endDate: Optional[XbrlDateResolution] # (optional) Defines an end date for a duration fact and the date of an instant fact. Values can be provided as a literal date value, a fact with a date value, or the date context value of a date. A suffix of @start or @end may be added to any of the date formats, specifying the instant at the start or end end of the duration, respectively.
+    startDate: Optional[XbrlDateResolution] # (optional) Defines a start date for a duration fact and the date of an instant fact. Values can be provided as a literal date value, a fact with a date value, or the date context value of a date. A suffix of @start or @end may be added to any of the date formats, specifying the instant at the start or end end of the duration, respectively.
+    onOrAfter: Optional[XbrlDateResolution] # (optional) Defines a date where all instant facts on or after the date are included in the cube. For a duration fact any periods after or on the end date of the duration are included in the cube.
+    onOrBefore: Optional[XbrlDateResolution] # (optional) Defines a date where all instant facts before or on the date are included in the cube. For a duration fact any periods before or on the end date are included in the cube.
+
+class XbrlCubeDimension(XbrlTaxonomyObject):
+    dimensionName: QName # (required) The QName of the dimension object that is used to identify the dimension. For the core dimensions of concept, period, entity and unit, the core dimension QNames of xbrl:concept, xbrl:period, xbrl:entity, xbrl:unit and xbrl:language are used. The dimension object indicates if the dimension is typed or explicit.
+    domainName: Optional[QName] # (required if explicit dimension) The QName of the domain object that is used to identify the domain associated with the dimension. Only one domain can be associated with a dimension. The domain name cannot be provided for a typed dimension or the period core dimension.
+    domainSort: Optional[str] # (optional if typed dimension) A string value that indicates the sort order of the typed dimension. The values can be either asc or desc. The values are case insensitive. This indicates if the cube is viewed the order of the values shown on the typed dimension. This cannot be used on an explicit dimension.
+    allowDomainFacts: Union[bool, DefaultFalse] # (optional    ) A boolean value that indicates if facts not identified with the dimension are included in the cube. For typed and explicit dimensions the value defaults to false. A value of true for a typed or explicit dimension will include facts that don't use the dimension in the cube. For the period core dimension, forever facts or facts with no period dimension are included when this value is set to true. For units, this is a unit with no units such as a string or date. For the entity core dimension, it is fact values with no entity. This property cannot be used on the concept core dimension.
+    periodConstraints: set[XbrlPeriodConstraint] # (optional only for period core dimension) Defines an ordered set of periodConstraint objects to restrict fact values in a cube to fact values with a specified period.
+
+class XbrlCube(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name property is a QName that uniquely identifies the cube object.
+    cubeType: Optional[QName] # (optional) The cubeType property identifies the type of data cube being represented. This must match a defined cubeType object or specification defined cube types of xbrl:eventCube, xbrl:positionCube, xbrl:referenceCube, xbrl:reportCube, xbrl:journalCube, xbrl:eventDetailsCube, xbrl:timeSeriesCube and xbrl:defaultCube. If no QName is provided the default is xbrl:reportCube.
+    cubeDimensions: OrderedSet[XbrlCubeDimension] # (required) An ordered set of cubeDimension objects that identify the dimensions and associated domains used on the cube.
+    cubeNetworks: OrderedSet[QName] # (optional) An ordered set of network object QNames that reference network objects that are directly related to the cube.
+    excludeCubes: OrderedSet[QName] # (optional) An ordered set of cube object QNames that remove the facts of the constraint cube from the facts of the defined cube.
+    cubeComplete: Optional[bool] # (optional) A boolean flag that indicates if all cells in the cube are required to have a value. If true then all cube cells must include a fact value. If a value is not provided for the cubeComplete property then the default is false.
+    properties: OrderedSet[XbrlProperty] # (optional) An ordered set of property objects Used to specify additional properties associated with the cube using the property object. Only immutable properties as defined in the propertyType object can be added to a cube.
+
+class XbrlAllowedCubeDimension(XbrlTaxonomyObject):
+    dimensionName: Optional[QName] # (optional) The dimension QName that identifies the taxonomy defined dimension.
+    dimensionType: Optional[str] # (optional) The dimension QName that identifies the taxonomy defined dimension.
+    dimensionDataType: Optional[QName] # (optional) The dimension QName that identifies the taxonomy defined dimension.
+    required: Union[bool, DefaultFalse] # (optional) The dimension QName that identifies the taxonomy defined dimension.
+
+class XbrlRequiredCubeRelationship(XbrlTaxonomyObject):
+    relationshipTypeName: QName # (required) The relationship type QName of a relationship. This requires that at lease one of these relationship types exist on the cube.
+    source: Optional[QName] # (optional) The QName of the source object type in the relationship.
+    target: Optional[QName] # (optional) The QName of the target object type in the relationship.
+
+class XbrlCubeType(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the cube type object.
+    baseCubeType: Union[bool, DefaultTrue] # (optional) Base cube type that the cube object is based on. Uses the QName of a cubeType object. The property only allows restriction rather than expansion of the baseCubeTape.
+    periodDimension: Union[bool, DefaultTrue] # (optional) boolean to indicate if the period core dimension is included in the cube. Defaults to true.
+    entityDimension: Union[bool, DefaultTrue] # (optional) boolean to indicate if the entity core dimension is included in the cube. Defaults to true.
+    unitDimension: Union[bool, DefaultTrue] # (optional) boolean to indicate if the unit core dimension is included in the cube. Defaults to true.
+    taxonomyDefinedDimension: Union[bool, DefaultTrue] # (optional) boolean to indicate if taxonomy defined dimensions are included in the cube. Defaults to true.
+    allowedCubeDimensions: OrderedSet[XbrlAllowedCubeDimension] # (optional) An ordered set of allowedCubeDimension objects that are permitted to be used on the cube. If the property is not defined then any dimensions can be associated with the cube.
+    requiredCubeRelationships: OrderedSet[XbrlRequiredCubeRelationship] # (optional) An ordered set of requiredCubeRelationship objects that at a minimum must be associated with the cube.
+
+baseCubeTypes = {
+    qname(xbrl, "xbrl:eventCube"),
+    qname(xbrl, "xbrl:positionCube"),
+    qname(xbrl, "xbrl:referenceCube"),
+    qname(xbrl, "xbrl:reportCube"),
+    qname(xbrl, "xbrl:journalCube"),
+    qname(xbrl, "xbrl:eventDetailsCube"),
+    qname(xbrl, "xbrl:timeSeriesCube"),
+    qname(xbrl, "xbrl:defaultCube")
+    }
+
+periodCoreDim = qname(xbrl, "xbrl:period")
+conceptCoreDim = qname(xbrl, "xbrl:concept")
+entityCoreDim = qname(xbrl, "xbrl:entity")
+unitCoreDim = qname(xbrl, "xbrl:unit")
+languageCoreDim = qname(xbrl, "xbrl:language")
+
+coreDimensions = {periodCoreDim, conceptCoreDim, entityCoreDim, unitCoreDim, languageCoreDim}
+
+conceptDomainRoot = qname(xbrl, "xbrl:conceptDomain")
+entityDomainRoot = qname(xbrl, "xbrl:entityDomain")
+unitDomainRoot = qname(xbrl, "xbrl:unitDomain")

arelle/plugin/OimTaxonomy/XbrlDimension.py

@@ -0,0 +1,38 @@
+"""
+See COPYRIGHT.md Optional[for]copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional
+
+from arelle.ModelValue import QName
+from arelle.PythonUtil import OrderedSet
+from .XbrlNetwork import XbrlRelationship, XbrlRelationshipSet
+from .XbrlProperty import XbrlProperty
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType
+from .XbrlTaxonomyObject import XbrlReferencableTaxonomyObject
+
+class XbrlDimension(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) Optional[The]QName Optional[of]the Optional[dimension]object.
+    domainDataType: Optional[QName] #  (required Optional[for]typed dimension) Optional[The]QName Optional[of]the Optional[datatype]for Optional[a]typed dimension.
+    domainRoot: Optional[QName] # (required for explicit dimension) The QName of of the domain root object for the dimension.
+    cubeTypes: OrderedSet[QName] # (optional) Optional[an]ordered Optional[set]of Optional[QNames]that Optional[indicate]the Optional[cube]type Optional[the]dimension Optional[can]only Optional[apply]to. Optional[Must]be Optional[a]QName Optional[value]defined Optional[by]built Optional[in]cube Optional[types]or Optional[taxonomy]defined Optional[cube]types. Optional[For]example xbrl:eventCube, xbrl:referenceCube etc. Optional[If]not Optional[defined]the Optional[dimension]can Optional[be]applied Optional[to]any Optional[cube]type.
+    properties: OrderedSet[XbrlProperty] # (optional) Optional[an]ordered Optional[set]of Optional[property]objects Optional[used]to Optional[specify]additional Optional[properties]associated Optional[with]the Optional[dimension]using Optional[the]property object. Optional[Only]immutable Optional[properties]as Optional[defined]in Optional[the]propertyType Optional[object]can Optional[be]added Optional[to]a dimension.
+
+class XbrlDomain(XbrlReferencableTaxonomyObject, XbrlRelationshipSet):
+    taxonomy: XbrlTaxonomyType
+    name: Optional[QNameKeyType] # (required Optional[if]no extendedTargetName) Optional[The]name Optional[is]a Optional[QName]that Optional[uniquely]identifies Optional[the]domain object. Optional[The]QName Optional[is]used Optional[to]reference Optional[the]domain Optional[from]extensible Optional[enumeration]concepts Optional[and]dimensions Optional[that]use Optional[the]domain.
+    root: Optional[QName] # (required if no extendedTargetName) The QName that uniquely identifies the root of the domain object. This must be a domain root object.
+    relationships: OrderedSet[XbrlRelationship] # (optional) Optional[This]is Optional[an]ordered Optional[set]of Optional[relationship]objects Optional[that]associate Optional[concepts]with Optional[the]domain. Optional[A]list Optional[of]relationships Optional[can]be Optional[organized]into Optional[a]domain hierarchy.
+    extendTargetName: Optional[QName] # (required Optional[if]no name) Optional[Names]the Optional[domain]object Optional[that]the Optional[defined]domain Optional[relationships]should Optional[be]appended to. Optional[The]items Optional[in]the Optional[domain]with Optional[this]property Optional[are]appended Optional[to]the Optional[end]of Optional[the]relationships Optional[defined]in Optional[the]target Optional[domain]object. Optional[This]property Optional[cannot]be Optional[used]in Optional[conjunction]with Optional[the]name property.
+    properties: OrderedSet[XbrlProperty] # (optional) Optional[an]ordered Optional[set]of Optional[property]objects Optional[used]to Optional[specify]additional Optional[properties]associated Optional[with]the Optional[domain]using Optional[the]property object. Optional[Only]immutable Optional[properties]as Optional[defined]in Optional[the]propertyType Optional[object]can Optional[be]added Optional[to]a domain.
+
+class XbrlDomainRoot(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The QName that uniquely identifies the domain root object.
+    properties: OrderedSet[XbrlProperty] # (optional) an ordered set of property objects used to specify additional properties associated with the domain root object using the property object.
+
+class XbrlMember(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) Optional[The]name Optional[is]a Optional[QName]that Optional[uniquely]identifies Optional[the]member object.
+    properties: OrderedSet[XbrlProperty] # (optional) Optional[an]ordered Optional[set]of Optional[property]objects Optional[used]to Optional[specify]additional Optional[properties]associated Optional[with]the Optional[member]object Optional[using]the Optional[property]object. Optional[Only]immutable Optional[properties]as Optional[defined]in Optional[the]propertyType Optional[object]can Optional[be]added Optional[to]a member.

arelle/plugin/OimTaxonomy/XbrlDts.py

@@ -0,0 +1,152 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional, Union, cast, Any, ClassVar
+from collections import OrderedDict, defaultdict # OrderedDict is not same as dict, has additional key order features
+import sys, traceback
+from arelle.ModelValue import QName, AnyURI
+from arelle.ModelXbrl import ModelXbrl, create as modelXbrlCreate, XbrlConst
+from arelle.oim.Load import EMPTY_DICT
+from arelle.PythonUtil import OrderedSet
+from .XbrlConcept import XbrlConcept, XbrlDataType
+from .XbrlGroup import XbrlGroupContent
+from .XbrlReport import addReportProperties, XbrlFact, XbrlReportObject
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType, XbrlLabelType, XbrlPropertyType
+from .XbrlTaxonomyObject import XbrlObject, XbrlReferencableTaxonomyObject, XbrlTaxonomyTagObject
+
+def castToDts(modelXbrl, isReport=False):
+    if not isinstance(modelXbrl, XbrlDts) and isinstance(modelXbrl, ModelXbrl):
+        modelXbrl.__class__ = XbrlDts
+        modelXbrl.taxonomies: OrderedDict[QNameKeyType, XbrlTaxonomyType] = OrderedDict()
+        modelXbrl.dtsObjectIndex = 0
+        modelXbrl.xbrlObjects: list[XbrlObject] = []
+        modelXbrl.namedObjects: OrderedDict[QNameKeyType, XbrlReferencableTaxonomyObject] = OrderedDict() # not visible metadata
+        modelXbrl.tagObjects: defaultdict[QName, list[XbrlReferencableTaxonomyObject]] = defaultdict(list) # labels and references
+        if isReport:
+            addReportProperties(modelXbrl)
+    return modelXbrl
+
+
+class XbrlDts(ModelXbrl): # complete wrapper for ModelXbrl
+    taxonomies: OrderedDict[QNameKeyType, XbrlTaxonomyType]
+    xbrlObjects: list[XbrlObject] # not visible metadata
+    # objects only present for XbrlReports
+    linkTypes: dict[str, AnyURI]
+    linkGroups: dict[str, AnyURI]
+    facts: dict[str, XbrlFact]
+
+    def __init__(self, isReport:bool = False, *args: Any, **kwargs: Any) -> None:
+        super(XbrlDts, self).__init__(*args, **kwargs)
+        self.dtsObjectIndex = 0
+        self.xbrlObjects: list[XbrlObject] = []
+        self.namedObjects: OrderedDict[QNameKeyType, XbrlReferencableTaxonomyObject] = OrderedDict() # not visible metadata
+        self.tagObjects: defaultdict[QName, list[XbrlReferencableTaxonomyObject]] = defaultdict(list) # labels and references
+        if isReport:
+            addReportProperties(self)
+
+
+    @property
+    def xbrlTaxonomy(self):
+        return cast(XbrlTaxonomy, self.modelDocument)
+
+    @property
+    def labelTypes(self):
+        return set(obj.labelType for l in self.tagObjects.values() for obj in l if hasattr(obj, "labelType"))
+
+    @property
+    def referenceTypes(self):
+        return set(obj.referenceType for l in self.tagObjects.values() for obj in l if hasattr(obj, "referenceType"))
+
+    def labelValue(self, name: QName, labelType: QName, lang: Optional[str] = None, fallbackToName: bool = True) -> Optional[str]:
+        if labelType == XbrlConst.conceptNameLabelRole:
+            return str(name)
+        if lang is None:
+            lang = self.modelXbrl.modelManager.defaultLang
+        for tagObj in self.tagObjects.get(name, ()):
+            tagLang = getattr(tagObj, "language", lang)
+            if (getattr(tagObj, "labelType", None) == labelType and # causes skipping of reference objects
+                (not lang or tagLang.startswith(lang) or lang.startswith(tagLang))): # TBD replace with 2.1 language detection
+                if hasattr(tagObj, "value"):
+                    return tagObj.value
+                elif len(getattr(tagObj, "properties", ())) > 0:
+                    return tagObj.propertyView
+        # give up
+        if fallbackToName:
+            return str(name)
+        return None
+
+    def referenceProperties(self, name: QName, referenceType: Optional[QName], lang: Optional[str] = None) -> list[XbrlPropertyType]:
+        refProperties = defaultdict(list)
+        if lang is None:
+            lang = self.modelXbrl.modelManager.defaultLang
+        for tagObj in self.tagObjects.get(name, ()):
+            tagLang = getattr(tagObj, "language", None) or lang
+            refType = getattr(tagObj, "referenceType", None)
+            if (refType is not None and (not referenceType or referenceType == refType) and # causes skipping of label objects
+                (not lang or tagLang.startswith(lang) or lang.startswith(tagLang))): # TBD replace with 2.1 language detection
+                refProperties[refType].extend(getattr(tagObj, "properties", []))
+        return refProperties
+
+
+    # UI thread viewTaxonomyObject
+    def viewTaxonomyObject(self, objectId: Union[str, int]) -> None:
+        """Finds taxonomy object, if any, and synchronizes any views displaying it to bring the model object into scrollable view region and highlight it
+        :param objectId: string which includes _ordinalNumber, produced by ModelObject.objectId(), or integer object index
+        """
+        xbrlObj: Union[XbrlObject, str, int] = ""
+        try:
+            if isinstance(objectId, XbrlObject):
+                xbrlObj = objectId
+            elif isinstance(objectId, str) and objectId.startswith("_"):
+                xbrlObj = cast('XbrlObject', self.xbrlObjects[int(objectId.rpartition("_")[2])])
+            if xbrlObj is not None:
+                for view in self.views:
+                    view.viewModelObject(xbrlObj)
+        except (IndexError, ValueError, AttributeError)as err:
+            self.modelManager.addToLog(_("Exception viewing properties {0} {1} at {2}").format(
+                            xbrlObj,
+                            err, traceback.format_tb(sys.exc_info()[2])))
+
+    # dts-wide object accumulator properties
+    def filterNamedObjects(self, _class, _type=None, _lang=None):
+        if issubclass(_class, XbrlReferencableTaxonomyObject):
+            for obj in self.namedObjects.values():
+                if isinstance(obj, _class):
+                    yield obj
+        elif issubclass(_class, XbrlTaxonomyTagObject):
+            for objs in self.tagObjects.values():
+                for obj in objs:
+                    if (isinstance(obj, _class) and
+                        (not _type or _type == obj._type) and
+                        (not _lang or not obj.language or _lang.startswith(obj.language) or obj.language.startswith(lang))):
+                        yield obj
+        elif issubclass(_class, XbrlReportObject):
+            for obj in getattr(self, "facts", EMPTY_DICT).values():
+                yield obj
+
+    def error(self, *args, **kwargs):
+        if "xbrlObject" in kwargs:
+            argValue = kwargs["xbrlObject"]
+            if isinstance(argValue, (tuple,list,set,OrderedSet)):
+                kwargs["sourceFileLines"] = [a.entryLoadingUrl for a in argValue]
+            else:
+                kwargs["sourceFileLine"] = argValue.entryLoadingUrl
+        elif "modelObject" in kwargs:
+            modelObject = kwargs["modelObject"]
+            if hasattr(modelObject, "entryLoadingUrl"):
+                kwargs["sourceFileLine"] = modelObject.entryLoadingUrl
+        super(XbrlDts, self).error(*args, **kwargs)
+
+    def warning(self, *args, **kwargs):
+        if "xbrlObject" in kwargs:
+            argValue = kwargs["xbrlObject"]
+            if isinstance(argValue, (tuple,list)):
+                kwargs["sourceFileLines"] = [a.entryLoadingUrl for a in argValue]
+            else:
+                kwargs["sourceFileLine"] = argValue.entryLoadingUrl
+        super(XbrlDts, self).warning(*args, **kwargs)
+
+
+def create(*args: Any, **kwargs: Any) -> XbrlDts:
+    return cast(XbrlDts, modelXbrlCreate(*args, **kwargs))

arelle/plugin/OimTaxonomy/XbrlEntity.py

@@ -0,0 +1,16 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING
+
+from arelle.PythonUtil import OrderedSet
+from .XbrlProperty import XbrlProperty
+from .XbrlTypes import XbrlTaxonomyType, SQNameKeyType
+from .ModelValueMore import SQName
+from .XbrlTaxonomyObject import XbrlReferencableTaxonomyObject
+
+class XbrlEntity(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: SQNameKeyType # (required) The entity SQName that identifies the entity so it can be referenced by other objects.
+    properties: OrderedSet[XbrlProperty] # (optional) ordered set of property objects used to specify additional properties associated with the concept using the property object. Only immutable properties as defined in the propertyType object can be added to a concept.

arelle/plugin/OimTaxonomy/XbrlGroup.py

@@ -0,0 +1,22 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional
+
+from arelle.ModelValue import QName, AnyURI
+from arelle.PythonUtil import OrderedSet
+from .XbrlProperty import XbrlProperty
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType
+from .XbrlTaxonomyObject import XbrlTaxonomyObject, XbrlReferencableTaxonomyObject
+
+class XbrlGroup(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The group object QName that identifies the group so it can be referenced by other objects.
+    groupURI:Optional[AnyURI] # (optional) The group URI that uniquely identifies the group and id used for backward compatibility with roles.
+    properties: OrderedSet[XbrlProperty] # (optional) an ordered set of property objects used to specify additional properties associated with the group using the property object. Only immutable properties as defined in the propertyType object can be added to a group.
+
+class XbrlGroupContent(XbrlTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    groupName: QName # (required) The QName of the group object.
+    relatedNames: OrderedSet[QName] # (required) An ordered set of network object or cube object QNames that are included in the group object. The order of the set determines the order they appear in the group. The set cannot be empty. The set can only include the QNames of network and cube objects.

arelle/plugin/OimTaxonomy/XbrlImportedTaxonomy.py

@@ -0,0 +1,22 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Union
+
+from arelle.ModelValue import QName, AnyURI
+from arelle.PythonUtil import OrderedSet
+from .XbrlDts import XbrlDts
+from .XbrlAbstract import XbrlAbstract
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType, DefaultTrue, DefaultFalse
+from .XbrlTaxonomyObject import XbrlTaxonomyObject
+
+class XbrlImportedTaxonomy(XbrlTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    importedTaxonomies: OrderedSet # 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.
+    taxonomyName: QNameKeyType # (required) The QName of the taxonomy to import. The location of the taxonomy QName is resolved by referencing the namespace map which includes the url of the namespace. When importing XBRL 2.1 taxonomies a QName comprising the namespace of the taxonomy to import and a local name of taxonomy is defined. i.e. ifrs:Taxonomy.
+    includeObjects: set[QName] # (optional) A set of object QNames that should be imported from the taxonomyName location property. Only the objects defined in the include and any dependent objects are added to the dts. This property can only be used for taxonomy files using the OIM specification. The dependents of each object are defined in this specification.
+    includeObjectTypes: set[QName] # (optional) A set of object type QNames that should be imported from the taxonomyName location property. Examples include xbrl:conceptObject and xbrl:memberObject. All objects of the specified object types from the taxonomyName and any dependent objects will be imported. This property can only be used for taxonomy files using the OIM specification. The includeObjectTypes cannot include the label object.
+    excludeLabels: Union[bool, DefaultTrue] # (optional) If set to true any labels attached to the objects comprising the dts deriving from the taxonomyName property will be excluded from the dts. The default value is false.
+    followImport: Union[bool, DefaultFalse] # (optional) If set to false the dts resolution will not import taxonomies defined in descendant ImportedTaxonomyObjects. These imports will be excluded from the dts. The default value is true. This means if a taxonomy QName is provided all imprtedTaxonomy objects will be brought into the dts.

arelle/plugin/OimTaxonomy/XbrlLabel.py

@@ -0,0 +1,31 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional
+
+from arelle.ModelValue import QName, AnyURI
+from arelle.PythonUtil import OrderedSet
+from .ModelValueMore import SQName
+from .XbrlProperty import XbrlProperty
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType
+from .XbrlTaxonomyObject import XbrlTaxonomyObject, XbrlReferencableTaxonomyObject, XbrlTaxonomyTagObject
+
+class XbrlLabel(XbrlTaxonomyTagObject):
+    taxonomy: XbrlTaxonomyType
+    relatedName: QName # (required) Defines a QName that the label is associated with.
+    labelType: QName # (required) A QName representing the label type of the label. This can be a taxonomy defined label type or a standard XBRL label type defined in specification.
+    language: str # (required) Defines the language of the label using a valid BCP 47 [BCP47] language code.
+    value: str # (required) The text of the label.
+    properties: OrderedSet[XbrlProperty] # (optional) ordered set of property objects used to specify additional properties associated with the concept using the property object. Only immutable properties as defined in the propertyType object can be added to a concept.
+
+    @property
+    def _type(self):
+        return self.labelType
+
+class XbrlLabelType(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the label type object.
+    uri: Optional[AnyURI] # (optional) A uri used to identify the label type of label objects for backward compatability with XBRL 2.1 taxonomies.
+    dataType: Optional[AnyURI] # (optional) Indicates the dataType of the label object value property. This allows the value of the label to be constrained if required.
+    allowedObjects: OrderedSet[QName] # (optional) Defines an ordered set of object types that can use the labelType.

arelle/plugin/OimTaxonomy/XbrlNetwork.py

@@ -0,0 +1,100 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional, Any
+from collections import defaultdict
+
+from arelle.ModelValue import QName, AnyURI
+from arelle.PythonUtil import OrderedSet
+from .XbrlProperty import XbrlProperty
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType
+from .XbrlTaxonomyObject import XbrlTaxonomyObject, XbrlReferencableTaxonomyObject
+
+class XbrlRelationship(XbrlTaxonomyObject):
+    source: QName # (required) This attribute identifies the source concept of the relationship type. The value of the attribute must be a QName.
+    target: QName # (required) This attribute identifies the target concept of the relationship type. The value of the attribute must be a QName.
+    order: Optional[int] # (optional) This is used to order the relationships if the order is different than the order that the relationship appears in the list of relationships. The order property can be used on any relationship type.
+    weight: Optional[int] # (required on summation-item) Weight of a summation-item relationship type.
+    preferredLabel: Optional[QName] # (optional on parent-child) The preferred label QName of a parent-child relationship type.
+    usable: Optional[bool] # (optional on domain-member) Indicates if the member value is useable on a domain-member relationship.
+    properties: OrderedSet[XbrlProperty] # (optional) ordered set of property objects used to specify additional properties associated with the concept using the property object. Only immutable properties as defined in the propertyType object can be added to a concept.
+
+    @property
+    def propertyView(self):
+        nestedProperties = [("source",str(self.source)), ("target",str(self.target))]
+        if hasattr(self, "order"):
+            nestedProperties.append( ("order", str(self.order)) )
+        if hasattr(self, "weight"):
+            nestedProperties.append( ("weight", str(self.weight)) )
+        if hasattr(self, "preferredLabel"):
+            nestedProperties.append( ("preferredLabel", str(self.preferredLabel)) )
+        if hasattr(self, "useable"):
+            nestedProperties.append( ("useable", str(self.useable)) )
+        if getattr(self, "properties", None):
+            for propObj in self.properties:
+                nestedProperties.append( (str(propObj.propertyTypeName), str(propObj.propertyValue)) )
+        return ("relationship", f"{str(self.source)}\u2192{self.target}", tuple(nestedProperties))
+
+class XbrlRelationshipSet:
+    _relationshipsFrom: Optional[dict[QName, list[XbrlRelationship]]]
+    _relationshipsTo: Optional[dict[QName, list[XbrlRelationship]]]
+    _roots: Optional[OrderedSet[QName]]
+
+    def __init__(self):
+        self._relationshipsFrom = self._relationshipsTo = self._roots = None
+        if hasattr(self, "roots") and len(getattr(self, "roots")) > 1:
+            self._roots = getattr(self, "roots")
+
+    @property
+    def relationshipsFrom(self):
+        if not hasattr(self, "_relationshipsFrom"):
+            self._relationshipsFrom = defaultdict(list)
+            for relObj in self.relationships:
+                if relObj.source is not None:
+                    self._relationshipsFrom[relObj.source].append(relObj)
+        return self._relationshipsFrom
+
+    @property
+    def relationshipsTo(self):
+        if not hasattr(self, "_relationshipsTo"):
+            self._relationshipsTo = defaultdict(list)
+            for relObj in self.relationships:
+                if relObj.target is not None:
+                    self._relationshipsTo[relObj.target].append(relObj)
+        return self._relationshipsTo
+
+    @property
+    def relationshipRoots(self):
+        if not hasattr(self, "_roots"):
+            if hasattr(self, "roots") and len(getattr(self, "roots")) > 1:
+                self._roots = getattr(self, "roots")
+            else:
+                relsFrom = self.relationshipsFrom
+                relsTo = self.relationshipsTo
+                self._roots = [qnFrom
+                               for qnFrom, relsFrom in relsFrom.items()
+                               if qnFrom not in relsTo or
+                               (len(relsFrom) == 1 and # root-level self-looping ar
+                                len(relsTo[qnFrom]) == 1 and
+                                relsFrom[0].source == relsFrom[0].target)]
+        return self._roots
+
+class XbrlNetwork(XbrlReferencableTaxonomyObject, XbrlRelationshipSet):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required if no extendedTargetName) The name is a QName that uniquely identifies the network object.
+    relationshipTypeName: QName # (required if no extendedTargetName) The relationshipType object of the network expressed as a QName such as xbrl:parent-child
+    roots: OrderedSet[QName] # (optional) A list of the root objects of the network object. This allows a single object to be associated with a network without the need for a relationship. The order of roots in the list indicates the order in which the roots should appear. If no root is specified for a list of relationships the roots property is inferred from the relationships defined.
+    relationships: OrderedSet[XbrlRelationship] # (optional) A set of the relationship objects comprising the network.
+    extendTargetName: Optional[QName] # (required if no name) Names the network object that the defined network relationships should be appended to. The items in the network with this property are appended to the end of the relationships or roots defined in the target network object. This property cannot be used in conjunction with the relationshipTypeName and name property.
+    properties: OrderedSet[XbrlProperty] # (optional) ordered set of property objects used to specify additional properties associated with the concept using the property object. Only immutable properties as defined in the propertyType object can be added to a concept.
+
+class XbrlRelationshipType(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the relationshipType object.
+    uri: AnyURI # (optional) The URI identifies the uri of the relationship type for historical and backward compatibility purposes.
+    cycles: QName # (required) The cycles attribute indicates if the relationship when used in a hierarchy can include cycles. Possible values are any, none, and undirected. Any means cycles are allowed in the relationships, undirected means cycles are allowed, but they must be undirected, and none means cycles are not allowed in the relationships.
+    allowedLinkProperties: OrderedSet[QName] # (optional) Defines an ordered set of property QNames that can be included on the relationship type. Each property is represented as the QName defined in the propertyType object. Only properties defined in this list can be added to the specific relationship type.
+    requiredLinkProperties: OrderedSet[QName] # (optional) Defines an ordered set of property QNames that MUST be included on the relationship type. Each property is represented as the QName defined in the propertyType object.
+    sourceObjects: set[QName] # (optional) Defines a list of source object types that can be used as the source for the relationship. The only permitted values are referenceable taxonomy objects
+    targetObjects: set[QName] # (optional) Defines a list of target object types that can be used as the source for the relationship. The only permitted values are referenceable taxonomy objects

arelle/plugin/OimTaxonomy/XbrlProperty.py

@@ -0,0 +1,28 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Any, Optional, Union
+
+from arelle.ModelValue import QName
+from arelle.PythonUtil import OrderedSet
+from .XbrlTaxonomyObject import XbrlReferencableTaxonomyObject
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType, DefaultFalse
+
+class XbrlProperty:
+    property: QName # (required) The name is a QName that uniquely identifies the property type object.
+    value: Any # (required) The value of the property, that must be consistent with the datatype of the property.
+
+    @property
+    def propertyView(self):
+        return ( str(getattr(self, "property", "")), str(getattr(self, "value", "")) )
+
+
+class XbrlPropertyType(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the property type object.
+    dataType: QName # (required) Indicates the dataType of the property value. 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.
+    enumerationDomain: Optional[QName] # (optional) Used to specify the QName of a domain object that is used to derive enumerated domain members QNames that can be used for the property.
+    definitional: Union[bool, DefaultFalse] # (optional) Indicates if the property is definitional. If changes to the property change the meaning of the object it is definitional, if the property provides extra information about the object it is not definitional. If no value is provided the attribute defaults to false.
+    allowedObjects: set[QName] # (optional) List of allowable objects that the property can be used with. For example the balance property can only be used with concept objects.
+    allowedAsLinkProperty: Union[bool, DefaultFalse] # (optional) Indicates if the property can be used a a properton the link between two objects in a relationship. If no value is provided the attribute defaults to false.

arelle/plugin/OimTaxonomy/XbrlReference.py

@@ -0,0 +1,33 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional
+
+from arelle.ModelValue import QName, AnyURI
+from arelle.PythonUtil import OrderedSet
+from .XbrlProperty import XbrlProperty
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType
+from .ModelValueMore import SQName
+from .XbrlTaxonomyObject import XbrlReferencableTaxonomyObject, XbrlTaxonomyTagObject
+
+class XbrlReference(XbrlTaxonomyTagObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required if no extendTargetame) The name is a QName that uniquely identifies the reference object.
+    extendTargetName: Optional[QName] # (required if no name) Names the reference object that the defined relatedNames property should be appended to. The relatedNames property in the reference with this property are appended to the end of the relatedName property defined in the target reference object. This property cannot be used in conjunction with the name property.
+    relatedNames: OrderedSet[QName] # (optional) Defines a set of ordered QNames that the reference is associated with.
+    referenceType: QName # (required) A QName representing the reference type of the reference. This can be a taxonomy defined reference or a standard XBRL reference included in the specification.
+    language: Optional[str] # (optional) Defines the language of the reference using a valid BCP 47 [BCP47] language code.
+    properties: OrderedSet[XbrlProperty] # (optional) an ordered set of property objects used to identify the properties of the reference.
+
+    @property
+    def _type(self):
+        return self.referenceType
+
+class XbrlReferenceType(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the reference type object.
+    uri: Optional[AnyURI] # (optional) A uri used to identify the reference type of reference objects for backward compatability with XBRL 2.1 taxonomies.
+    allowedObjects: OrderedSet[QName] # (optional) Defines an ordered set of object types that can use the referenceType.
+    orderedPropertiesproperties: OrderedSet[XbrlProperty] # (optional) Defines an ordered set of property QNames that can be used with the reference.
+    requiredProperties: OrderedSet[QName] # (optional) Defines an ordered set of property QNames that must be included within a defined reference type.

arelle/plugin/OimTaxonomy/XbrlReport.py

@@ -0,0 +1,24 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional, Any, Union
+from collections import OrderedDict
+from arelle.ModelValue import QName, AnyURI
+from arelle.PythonUtil import OrderedSet
+from .XbrlTypes import XbrlDtsType, QNameKeyType
+from .XbrlTaxonomyObject import XbrlReportObject
+
+class XbrlFact(XbrlReportObject):
+    report: XbrlDtsType
+    id: Optional[str] # synthesized id (from fact key in JSON), marked Optional because it's a key, not value, in json source.
+    value: Optional[str] # (required) The value of the {value} property of the fact. The value MUST be represented as (xbrlje:invalidFactValue):
+    decimals: Optional[int] # An integer providing the value of the {decimals} property, or absent if the value is infinitely precise or not applicable (for nil or non-numeric facts).
+    dimensions: dict[Union[QName, str], str] # (required) A dimensions object with properties corresponding to the members of the {dimensions} property.
+    links: dict[str, dict[str, list[str]]] # A links object, cormesponding to the link groups associated with the fact. This member MAY be absent if there are no link groups associated with the fact.
+
+
+def addReportProperties(dts: XbrlDtsType):
+    dts.linkTypes: dict[str, AnyURI] = OrderedDict()
+    dts.linkGroups: dict[str, AnyURI] = OrderedDict()
+    dts.facts: dict[str, XbrlFact] = OrderedDict()

arelle/plugin/OimTaxonomy/XbrlTableTemplate.py

@@ -0,0 +1,35 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional, Union
+from decimal import Decimal
+
+from arelle.ModelValue import QName
+from arelle.PythonUtil import OrderedSet
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType, DefaultFalse
+from .XbrlTaxonomyObject import XbrlTaxonomyObject, XbrlReferencableTaxonomyObject
+
+class XbrlTableTemplate(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the transform object.
+    rowIdColumn: Optional[str] # (optional) An identifier specifying the name of the row ID column.
+    columns: dict # (required) A columns object. (See xbrl-csv specification)
+    dimensions: dict # (required) A dimensions object that defines table dimensions. (See xbrl-csv specification)
+    decimals: Optional[Decimal] # (optional) A decimals value
+
+class XbrlAxisDimensions(XbrlTaxonomyObject):
+    dimensionName: QName # (required) The QName of a dimension defined by the cubeName property.
+    showTotal: Union[bool, DefaultFalse] # (optional) Indicates if the total of the dimension is shown in the axis. This is the value associated with the dimension absent. If no value is provided the default is false. The concept dimension defaults to false and cannot be set to true.
+    showAncestorColumns: Union[bool, DefaultFalse] # (optional) Define members on an explicit dimension that are not leaf values that are included on the axis. If not provided only leaf members on the axis will show.
+    totalLocation: Optional[str] # (optional) Indicates if the total is at the start or at the end when shown on the axis. The default value is end. The totalLocation attribute can only have a value of start or end.
+    periodAlign: OrderedSet[str] # (optional) the period align attribute can only be used with the period dimension. This attribute is used to align time values of facts in a dimension rather than being created as seperate columns or rows. The values @start and @end are used to indicate if instant values are aligned with duration values. These values are used to support roll-forwards in a datatgrid and will align duration values and instant values with the same start and end dates.
+
+class XbrlDataTable(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the data table object.
+    cubeName: QName # (required) The name is a QName that identifies the cube associated with the data table.
+    xAxis: XbrlAxisDimensions # (required) Identifies the axis and the behaviour of dimensions when mapped to the X axis of the table.
+    yAxis: XbrlAxisDimensions # (required) Identifies the axis and the behaviour of dimensions when mapped to the Y axis of the table.
+    zAxis: XbrlAxisDimensions # (optional) Identifies the axis and the behaviour of dimensions when mapped to the Z axis of the table.
+    showRefs: Optional[bool] # (optional) Identifies if col and row references are shown on the table, such as C010 and R010.