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

arelle/ModelFormulaObject.py

@@ -25,6 +25,7 @@ class FormulaOptions():
         self.cacheSize = 10_000_000  # maximum number of fact aspect comparisons to cache
         self.compileOnly = False # compile but don't execute formulas
         self.formulaAction = None # none, validate, run
+        self.maximumMessageInterpolationLength = None
         self.traceParameterExpressionResult = False
         self.traceParameterInputValue = False
         self.traceCallExpressionSource = False
@@ -50,8 +51,10 @@ class FormulaOptions():
         self.traceVariableExpressionCode = False
         self.traceVariableExpressionEvaluation = False
         self.traceVariableExpressionResult = False
+        self.testcaseFilters = None
         self.testcaseResultsCaptureWarnings = False
         self.testcaseResultOptions = None
+        self.testcaseExpectedErrors = None
         if isinstance(savedValues, dict):
             self.__dict__.update(savedValues)
 
@@ -185,6 +188,7 @@ class ModelVariableSet(ModelFormulaResource):
 
 class ModelFormulaRules:
     def init(self, modelDocument):
+        self.isSubclassOfModelVariableSet = issubclass(type(self), ModelVariableSet)
         super(ModelFormulaRules, self).init(modelDocument)
 
     def clear(self):
@@ -315,7 +319,9 @@ class ModelFormulaRules:
             super(ModelFormulaRules, self).compile()
 
     def variableRefs(self, progs=[], varRefSet=None):
-        return super(ModelFormulaRules, self).variableRefs([self.valueProg] + [v for vl in self.aspectProgs.values() for v in vl], varRefSet)
+        if self.isSubclassOfModelVariableSet:
+            return super(ModelFormulaRules, self).variableRefs([self.valueProg] + [v for vl in self.aspectProgs.values() for v in vl], varRefSet)
+        return set()
 
     def evaluate(self, xpCtx):
         return xpCtx.atomize( xpCtx.progHeader, xpCtx.evaluate( self.valueProg ) )
@@ -579,7 +585,7 @@ class ModelParameter(ModelFormulaResource):
 
     def evaluate(self, xpCtx, typeQname):
         try:
-            return xpCtx.evaluateAtomicValue(self.selectProg, typeQname)
+            return xpCtx.evaluateAtomicValue(self.selectProg, typeQname, resultMayBeNode=True)
         except AttributeError:
             return None
 
@@ -1234,7 +1240,7 @@ class ModelConceptDataType(ModelConceptFilterWithQnameExpression):
         return set(fact for fact in facts
                    for qn in (self.evalQname(xpCtx,fact),)
                    for c in (fact.concept,)
-                   if cmplmt ^ (c.typeQname == qn or (notStrict and c.type.isDerivedFrom(qn))))
+                   if c is not None and cmplmt ^ (c.typeQname == qn or (notStrict and c.type is not None and c.type.isDerivedFrom(qn))))
 
     @property
     def propertyView(self):
@@ -1264,7 +1270,7 @@ class ModelConceptSubstitutionGroup(ModelConceptFilterWithQnameExpression):
             return set(fact for fact in facts
                        if cmplmt ^ (fact.concept.substitutionGroupQname == self.evalQname(xpCtx,fact)))
         return set(fact for fact in facts
-                   if cmplmt ^ fact.concept.substitutesForQname(self.evalQname(xpCtx,fact)))
+                   if fact.concept is not None and cmplmt ^ fact.concept.substitutesForQname(self.evalQname(xpCtx,fact)))
 
     @property
     def propertyView(self):
@@ -2601,8 +2607,10 @@ class ModelMessage(ModelFormulaResource):
             return set()    # no expressions
 
     def evaluate(self, xpCtx, contextItem=None):
-        return self.formatString.format([xpCtx.evaluateAtomicValue(p, 'xs:string', contextItem=contextItem)
-                                         for p in self.expressionProgs])
+        return self.formatString.format([
+            str(xpCtx.evaluateAtomicValue(p, 'xs:string', contextItem=contextItem))[:xpCtx.formulaOptions.maximumMessageInterpolationLength]
+            for p in self.expressionProgs
+        ])
 
     @property
     def propertyView(self):

arelle/ModelInstanceObject.py

@@ -32,6 +32,8 @@
     measure sets.
 """
 from __future__ import annotations
+
+import uuid
 from collections import defaultdict
 from typing import Any, TYPE_CHECKING
 from lxml import etree
@@ -40,6 +42,7 @@ from arelle.Aspect import Aspect
 from arelle.ValidateXbrlCalcs import inferredPrecision, inferredDecimals, roundValue, rangeValue, ValidateCalcsMode
 from arelle.XmlValidateConst import UNVALIDATED, INVALID, VALID
 from arelle.XmlValidate import validate as xmlValidate
+from arelle.XmlUtil import collapseWhitespace
 from arelle.PrototypeInstanceObject import DimValuePrototype
 from math import isnan, isinf
 from arelle.ModelObject import ModelObject
@@ -141,10 +144,12 @@ class ModelFact(ModelObject):
         ([ModelFact]) - List of child facts in source document order
     """
     modelTupleFacts: list['ModelFact']
+    uniqueUUID: uuid.UUID
 
     def init(self, modelDocument):
         super(ModelFact, self).init(modelDocument)
         self.modelTupleFacts = []
+        self.uniqueUUID = uuid.uuid4()
 
     @property
     def concept(self):
@@ -152,7 +157,7 @@ class ModelFact(ModelObject):
         return self.elementDeclaration()  # logical (fact) declaration in own modelXbrl, not physical element (if inline)
 
     @property
-    def contextID(self):
+    def contextID(self) -> str:
         """(str) -- contextRef attribute"""
         return self.get("contextRef")
 
@@ -172,7 +177,7 @@ class ModelFact(ModelObject):
         return self.modelXbrl.units.get(self.unitID)
 
     @property
-    def unitID(self):
+    def unitID(self) -> str:
         """(str) -- unitRef attribute"""
         return self.getStripped("unitRef")
 
@@ -420,8 +425,12 @@ class ModelFact(ModelObject):
                         return Locale.format(self.modelXbrl.locale, "{:.{}f}", (num,dec), True)
                 except ValueError:
                     return "(error)"
+            # non-numeric fact at this point
             if len(val) == 0: # zero length string for HMRC fixed fact
                 return "(reported)"
+            if self.xValid >= VALID and isinstance(self.xValue, str):
+                # Prefer the xs:whiteSpace normalized version of strings
+                return self.xValue
             return val
         except Exception as ex:
             return str(ex)  # could be transform value of inline fact
@@ -508,8 +517,8 @@ class ModelFact(ModelObject):
             # parent test can only be done if in same instauce
             if self.modelXbrl == other.modelXbrl and self.parentElement != other.parentElement:
                 return False
-            if not (self.context.isEqualTo(other.context,dimensionalAspectModel=False) and
-                    (not self.isNumeric or self.unit.isEqualTo(other.unit))):
+            if not (self.context is not None and self.context.isEqualTo(other.context,dimensionalAspectModel=False) and
+                    (not self.isNumeric or (self.unit is not None and self.unit.isEqualTo(other.unit)))):
                 return False
         elif self.isTuple:
             if (self == other or
@@ -572,7 +581,7 @@ class ModelFact(ModelObject):
                  ("decimals", self.decimals),
                  ("precision", self.precision),
                  ("xsi:nil", self.xsiNil),
-                 ("value", self.effectiveValue.strip()))
+                 ("value", self.effectiveValue))
                  if self.isItem else () ))
 
     def __repr__(self):
@@ -626,13 +635,21 @@ class ModelInlineValueObject:
     @property
     def rawValue(self):
         ixEscape = self.get("escape") in ("true", "1")
-        return XmlUtil.innerText(
+        raw = XmlUtil.innerText(
             self,
             ixExclude="tuple" if self.elementQname == XbrlConst.qnIXbrl11Tuple else "html",
             ixEscape=ixEscape,
             ixContinuation=(self.elementQname == XbrlConst.qnIXbrl11NonNumeric),
             ixResolveUris=ixEscape,
-            strip=(self.format is not None))  # transforms are whitespace-collapse, otherwise it is preserved.
+            strip = False)
+        if self.format is not None:
+            # Most transforms are whitespace-collapse, so do that now.
+            #
+            # TODO: this collapsing should be moved to the individual
+            # transformation functions in order to support non-collapsing
+            # transformations
+            raw = collapseWhitespace(raw)
+        return raw
 
     @property
     def value(self):
@@ -665,7 +682,10 @@ class ModelInlineValueObject:
                 self._ixValue = v
             else:
                 if self.localName == "nonNumeric":
-                    self._ixValue = v
+                    if self.xValid >= VALID:
+                        self._ixValue = str(self.xValue)
+                    else:
+                        self._ixValue = v
                 elif self.localName == "tuple":
                     self._ixValue = ""
                 elif self.localName == "fraction":
@@ -681,7 +701,7 @@ class ModelInlineValueObject:
                         num = Decimal(v)
                     except (ValueError, InvalidOperation):
                         self.setInvalid()
-                        raise ValueError("Invalid value for {} number: {}".format(self.localName, v))
+                        raise ValueError("Invalid value for {} number: '{}'".format(self.localName, v))
                     try:
                         scale = self.scale
                         if scale is not None:
@@ -697,7 +717,7 @@ class ModelInlineValueObject:
                             self._ixValue = "{:f}".format(num)
                     except (ValueError, InvalidOperation):
                         self.setInvalid()
-                        raise ValueError("Invalid value for {} scale {} for number {}".format(self.localName, scale, v))
+                        raise ValueError("Invalid value for {} scale '{}' for number '{}'".format(self.localName, scale, v))
             return self._ixValue
 
     @property
@@ -775,6 +795,15 @@ class ModelInlineFact(ModelInlineValueObject, ModelFact):
             for inline root element, the xbrli:xbrl element is substituted for by the inline root element"""
         return getattr(self, "_ixFactParent") # set by ModelDocument locateFactInTuple for the inline target's root element
 
+    @property
+    def isEscaped(self):
+        """(bool) -- if true, the fact is escaped"""
+        try:
+            return self._isEscaped
+        except AttributeError:
+            self._isEscaped = self.get("escape") in ("true", "1")
+            return self._isEscaped
+
     def ixIter(self, childOnly=False):
         """(ModelObject) -- child elements (tuple facts) of the inline target instance document"""
         for fact in self.modelTupleFacts:
@@ -1104,7 +1133,7 @@ class ModelContext(ModelObject):
             dimValue = self.modelXbrl.qnameDimensionDefaults.get(dimQname)
         return dimValue
 
-    def dimMemberQname(self, dimQname, includeDefaults=False):
+    def dimMemberQname(self, dimQname: ModelValue.QName, includeDefaults: bool = False) -> ModelValue.QName | None:
         """(QName) -- QName of explicit dimension if reported (or defaulted if includeDefaults is True), else None"""
         dimValue = self.dimValue(dimQname)
         if isinstance(dimValue, (ModelDimensionValue,DimValuePrototype)) and dimValue.isExplicit:
@@ -1130,7 +1159,7 @@ class ModelContext(ModelObject):
             self._dimsHash = hash( frozenset(self.qnameDims.values()) )
             return self._dimsHash
 
-    def nonDimValues(self, contextElement):
+    def nonDimValues(self, contextElement: str | int) -> list[ModelObject]:
         """([ModelObject]) -- ContextElement is either string or Aspect code for segment or scenario, returns nonXDT ModelObject children of context element.
 
         :param contextElement: one of 'segment', 'scenario', Aspect.NON_XDT_SEGMENT, Aspect.NON_XDT_SCENARIO, Aspect.COMPLETE_SEGMENT, Aspect.COMPLETE_SCENARIO
@@ -1237,9 +1266,9 @@ class ModelContext(ModelObject):
 
     def isEntityIdentifierEqualTo(self, cntx2):
         """(bool) -- True if entityIdentifier values are equal (scheme and text value)"""
-        return self.entityIdentifierHash == cntx2.entityIdentifierHash
+        return self.entityIdentifier == cntx2.entityIdentifier
 
-    def isEqualTo(self, cntx2, dimensionalAspectModel=None):
+    def isEqualTo(self, cntx2, dimensionalAspectModel=None) -> bool:
         if dimensionalAspectModel is None: dimensionalAspectModel = self.modelXbrl.hasXDT
         try:
             return self._isEqualTo[(cntx2,dimensionalAspectModel)]

arelle/ModelManager.py

@@ -6,9 +6,10 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import TYPE_CHECKING
 import gc, sys, traceback, logging
-from arelle import ModelXbrl, Validate, DisclosureSystem, PackageManager, ValidateXbrlCalcs
+from arelle import ModelXbrl, Validate, DisclosureSystem, PackageManager, ValidateXbrlCalcs, ValidateDuplicateFacts
 from arelle.ModelFormulaObject import FormulaOptions
 from arelle.PluginManager import pluginClassMethods
+from arelle.ValidateXbrlDTS import ValidateBaseTaxonomiesMode
 from arelle.typing import LocaleDict
 
 if TYPE_CHECKING:
@@ -67,6 +68,10 @@ class ModelManager:
         self.loadedModelXbrls = []
         self.customTransforms: dict[QName, Callable[[str], str]] | None = None
         self.isLocaleSet = False
+        self.baseTaxonomyValidationMode = ValidateBaseTaxonomiesMode.DISCLOSURE_SYSTEM
+        self.validateAllFilesAsReportPackages = False
+        self.validateDuplicateFacts = ValidateDuplicateFacts.DuplicateType.NONE
+        self.validateXmlOim = False
         self.setLocale()
         ValidateXbrlCalcs.init() # required due to circular dependencies in module
 

arelle/ModelObject.py

@@ -2,10 +2,11 @@
 See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
-from typing import TYPE_CHECKING, Any, Generator, cast, Union
+from collections.abc import Generator
+from typing import TYPE_CHECKING, Any, cast
 from lxml import etree
 from arelle import Locale
-from arelle.ModelValue import qname, qnameEltPfxName, QName
+from arelle import ModelValue
 from arelle.XmlValidateConst import VALID_NO_CONTENT
 from arelle.model import CommentBase, ElementBase, PIBase
 
@@ -20,7 +21,7 @@ if TYPE_CHECKING:
     from arelle.ModelInstanceObject import ModelInlineFootnote
     from arelle.ModelInstanceObject import ModelInlineFact
     from arelle.ModelInstanceObject import ModelDimensionValue
-    from arelle.ModelValue import TypeSValue, TypeXValue
+    from arelle.ModelValue import qname, qnameEltPfxName, QName, TypeSValue, TypeXValue
 
 XmlUtil: Any = None
 
@@ -116,6 +117,7 @@ class ModelObject(ElementBase):
     xValueError: Exception | None
     xValid: int
     xlinkLabel: str
+    targetModelXbrl: ModelXbrl
 
     def _init(self) -> None:
         self.isChanged = False
@@ -145,6 +147,8 @@ class ModelObject(ElementBase):
 
     @property
     def modelXbrl(self) -> ModelXbrl | None:
+        if hasattr(self, "targetModelXbrl"):
+            return self.targetModelXbrl
         modelDocument = getattr(self, "modelDocument", None)
         return modelDocument.modelXbrl if modelDocument is not None else None
 
@@ -210,7 +214,7 @@ class ModelObject(ElementBase):
         try:
             return self._elementQname
         except AttributeError:
-            self._elementQname = QName(self.prefix, self.namespaceURI, self.localName)
+            self._elementQname = ModelValue.QName(self.prefix, self.namespaceURI, self.localName)
             return self._elementQname
 
     # qname is overridden for concept, type, attribute, and formula parameter, elementQname is unambiguous
@@ -219,7 +223,7 @@ class ModelObject(ElementBase):
         try:
             return self._elementQname
         except AttributeError:
-            self._elementQname = qname(self)
+            self._elementQname = ModelValue.qname(self)
             return self._elementQname
 
     def vQname(self, validationModelXbrl: ModelXbrl | None = None) -> QName:
@@ -291,7 +295,7 @@ class ModelObject(ElementBase):
         :returns: QName -- the resolved prefixed name, or None if no prefixed name was provided
         """
         if prefixedName:    # passing None would return element qname, not prefixedName None Qname
-            return qnameEltPfxName(self, prefixedName)
+            return ModelValue.qnameEltPfxName(self, prefixedName)
         else:
             return None
 
@@ -322,7 +326,6 @@ class ModelObject(ElementBase):
         :type dtsModelXbrl: ModelXbrl
         :returns: ModelObject -- Document node corresponding to the href or resolved uri
         """
-        from arelle.ModelDocument import ModelDocument
         if dtsModelXbrl is None:
             dtsModelXbrl = self.modelXbrl
         doc = None
@@ -341,7 +344,8 @@ class ModelObject(ElementBase):
 
                 assert dtsModelXbrl is not None
                 doc = dtsModelXbrl.urlDocs.get(normalizedUrl)
-        if isinstance(doc, ModelDocument):
+        import arelle.ModelDocument
+        if isinstance(doc, arelle.ModelDocument.ModelDocument):
             if id is None:
                 return cast(ModelObject, doc)
             elif id in doc.idObjects:

arelle/ModelObjectFactory.py

@@ -68,6 +68,22 @@ LINKBASE = 2
 VERSIONINGREPORT = 3
 RSSFEED = 4
 
+LINK_LOCALNAME_TO_MODEL_CLASS = {
+    'loc': ModelLocator,
+    'label': ModelResource,
+    'reference': ModelResource,
+    'roleType': ModelRoleType,
+    'arcroleType': ModelRoleType,
+} | {
+    q.localName: ModelObject
+    for q in [
+        XbrlConst.qnLinkCalculationArc,
+        XbrlConst.qnLinkDefinitionArc,
+        XbrlConst.qnLinkPresentationArc,
+        XbrlConst.qnLinkReferenceArc,
+    ]
+}
+
 
 class KnownNamespacesModelObjectClassLookup(etree.CustomElementClassLookup):
     def __init__(self, modelXbrl: ModelXbrl, fallback: etree.ElementClassLookup | None = None) -> None:
@@ -106,8 +122,8 @@ class KnownNamespacesModelObjectClassLookup(etree.CustomElementClassLookup):
             elif ns == XbrlConst.link:
                 if self.type is None:
                     self.type = LINKBASE
-                if ln == "roleType" or ln == "arcroleType":
-                    return ModelRoleType
+                if modelObjectClass := LINK_LOCALNAME_TO_MODEL_CLASS.get(ln):
+                    return modelObjectClass
             elif ns == "http://edgar/2009/conformance":
                 # don't force loading of test schema
                 if ln == "variation":

arelle/ModelRelationshipSet.py

@@ -7,10 +7,11 @@ from __future__ import annotations
 from collections import defaultdict
 from dataclasses import dataclass
 from typing import Any
-from arelle import ModelDtsObject, XbrlConst, ModelValue
+from arelle import Locale, XbrlConst, ModelValue
 from arelle.ModelObject import ModelObject
 from arelle.ModelDtsObject import ModelRelationship, ModelResource
 from arelle.PrototypeDtsObject import LocPrototype, PrototypeObject
+from arelle.PythonUtil import OrderedSet
 from arelle.XbrlConst import consecutiveArcrole
 import sys
 
@@ -217,10 +218,15 @@ class ModelRelationshipSet:
     def __bool__(self):  # some modelRelationships exist
         return len(self.modelRelationships) > 0
 
+    def contains(self, modelObject: ModelObject) -> bool:
+        return bool(self.fromModelObject(modelObject) or self.toModelObject(modelObject))
+
     @property
     def linkRoleUris(self):
+        # order by document appearance of linkrole, required for Table Linkbase testcase 3220 v03
         if self.modellinkRoleUris is None:
-            self.modellinkRoleUris = set(modelRel.linkrole for modelRel in self.modelRelationships)
+            linkroleObjSeqs = set((modelRel.linkrole, getattr(modelRel.arcElement.getparent(), "objectIndex", sys.maxsize)) for modelRel in self.modelRelationships)
+            self.modellinkRoleUris = OrderedSet([lr[0] for lr in sorted(linkroleObjSeqs, key=lambda l: l[1])])
         return self.modellinkRoleUris
 
     def loadModelRelationshipsFrom(self) -> dict[Any, list[ModelRelationship]]:
@@ -249,12 +255,16 @@ class ModelRelationshipSet:
         return self.loadModelRelationshipsFrom()
 
     def fromModelObject(self, modelFrom) -> list[ModelRelationship]:
+        if getattr(self.modelXbrl, "isSupplementalIxdsTarget", False) and modelFrom is not None and modelFrom.modelXbrl != self.modelXbrl:
+            modelFrom = self.modelXbrl.qnameConcepts.get(modelFrom.qname, None)
         return self.loadModelRelationshipsFrom().get(modelFrom, [])
 
     def toModelObjects(self) -> dict[Any, list[ModelRelationship]]:
         return self.loadModelRelationshipsTo()
 
     def toModelObject(self, modelTo) -> list[ModelRelationship]:
+        if getattr(self.modelXbrl, "isSupplementalIxdsTarget", False) and modelTo is not None and modelTo.modelXbrl != self.modelXbrl:
+            modelFrom = self.modelXbrl.qnameConcepts.get(modelTo.qname, None)
         return self.loadModelRelationshipsTo().get(modelTo, [])
 
     def fromToModelObjects(self, modelFrom, modelTo, checkBothDirections=False) -> list[ModelRelationship]:
@@ -278,8 +288,13 @@ class ModelRelationshipSet:
 
     # if modelFrom and modelTo are provided determine that they have specified relationship
     # if only modelFrom, determine that there are relationships present of specified axis
-    def isRelated(self, modelFrom, axis, modelTo=None, visited=None, isDRS=False): # either model concept or qname
+    def isRelated(self, modelFrom, axis, modelTo=None, visited=None, isDRS=False, consecutiveLinkrole=False) -> bool: # either model concept or qname
         assert self.modelXbrl is not None
+        if getattr(self.modelXbrl, "isSupplementalIxdsTarget", False):
+            if modelFrom is not None and modelFrom.modelXbrl != self.modelXbrl:
+                modelFrom = modelFrom.qname
+            if modelTo is not None and modelTo.modelXbrl != self.modelXbrl:
+                modelTo = modelTo.qname
         if isinstance(modelFrom,ModelValue.QName):
             modelFrom = self.modelXbrl.qnameConcepts.get(modelFrom) # fails if None
         if isinstance(modelTo,ModelValue.QName):
@@ -288,6 +303,19 @@ class ModelRelationshipSet:
                 return False # if a QName and not existent then fails
         if axis.endswith("self") and (modelTo is None or modelFrom == modelTo):
             return True
+        if axis.startswith("ancestor"): # could be ancestor-or-self
+            assert isDRS == False # DRS is not possible
+            for modelRel in self.toModelObject(modelFrom):
+                toConcept = modelRel.fromModelObject
+                if modelTo is None or modelTo == toConcept:
+                    return True
+                if visited is None: visited = set()
+                if toConcept not in visited:
+                    visited.add(toConcept)
+                    if self.isRelated(toConcept, axis, modelTo, visited, isDRS):
+                        return True
+                    visited.discard(toConcept)
+            return False
         isDescendantAxis = "descendant" in axis
         if axis.startswith("ancestral-"): # allow ancestral-sibling...
             if self.isRelated(modelFrom, axis[10:], modelTo): # any current-level sibling?
@@ -317,6 +345,11 @@ class ModelRelationshipSet:
                                                            modelRel.consecutiveLinkrole, self.linkqname, self.arcqname)
                             .isRelated(toConcept, axis, modelTo, visited, isDRS)):
                             return True
+                    elif consecutiveLinkrole: # allows starting at relationship set with ELR None
+                        if (self.modelXbrl.relationshipSet(modelRel.arcrole,
+                                                           modelRel.consecutiveLinkrole, self.linkqname, self.arcqname)
+                            .isRelated(toConcept, axis, modelTo, visited, isDRS, consecutiveLinkrole)):
+                            return True
                     else:
                         if self.isRelated(toConcept, axis, modelTo, visited, isDRS):
                             return True
@@ -352,6 +385,8 @@ class ModelRelationshipSet:
             labels = sorted(labels, key=lambda rel: rel.priority, reverse=True)
         shorter: _LangLabels | None = None
         longer: _LangLabels | None = None
+        regionalVariant: _LangLabels | None = None
+        baseLang = _lang.partition(Locale.BCP47_LANGUAGE_REGION_SEPARATOR)[0] if _lang else None
         for modelLabelRel in labels:
             label = modelLabelRel.toModelObject
             if wildRole or role == label.role:
@@ -374,6 +409,11 @@ class ModelRelationshipSet:
                             shorter = _LangLabels(labelLang, [text])
                         else:
                             shorter.labels.append(text)
+                    elif baseLang and labelLang.startswith(baseLang):
+                        if not regionalVariant:
+                            regionalVariant = _LangLabels(labelLang, [text])
+                        else:
+                            regionalVariant.labels.append(text)
         if langLabels:
             if returnMultiple: return langLabels
             else: return langLabels[0]
@@ -383,4 +423,7 @@ class ModelRelationshipSet:
         if longer:
             if returnMultiple: return longer.labels
             else: return longer.labels[0]
+        if regionalVariant:
+            if returnMultiple: return regionalVariant.labels
+            else: return regionalVariant.labels[0]
         return None