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

arelle/FunctionFn.py

@@ -193,10 +193,14 @@ def string_length(xc, p, contextItem, args):
     if len(args) > 1: raise XPathContext.FunctionNumArgs()
     return len( stringArg(xc, args, 0, "xs:string", missingArgFallback=contextItem) )
 
-nonSpacePattern = re.compile(r"\S+")
+
 def normalize_space(xc, p, contextItem, args):
+    # https://www.w3.org/TR/xpath-functions/#func-normalize-space
+    # Defined to be the same as whitespace = collapse in XML schema
+    # So we use the same implementation
     if len(args) > 1: raise XPathContext.FunctionNumArgs()
-    return ' '.join( nonSpacePattern.findall( stringArg(xc, args, 0, "xs:string", missingArgFallback=contextItem) ) )
+    return XmlUtil.collapseWhitespace(stringArg(xc, args, 0, "xs:string", missingArgFallback=contextItem))
+
 
 def normalize_unicode(xc, p, contextItem, args):
     raise fnFunctionNotAvailable()
@@ -307,8 +311,38 @@ def replace(xc, p, contextItem, args):
     except re.error as err:
         raise XPathContext.XPathException(p, 'err:FORX0002', _('fn:replace regular expression pattern error: {0}').format(err))
 
+
 def tokenize(xc, p, contextItem, args):
-    raise fnFunctionNotAvailable()
+    # See https://www.w3.org/TR/xpath-functions/#func-tokenize
+    if not 1 <= len(args) <= 3:
+        raise XPathContext.FunctionNumArgs()
+
+    if 1 == len(args):
+        input = normalize_space(xc, p, contextItem, args)
+        pattern = ' '
+    else:
+        input = stringArg(xc, args, 0, "xs:string?", emptyFallback="")  # empty string is default
+        pattern = stringArg(xc, args, 1, "xs:string", emptyFallback="")
+
+    if "" == input:
+        return []
+
+    m_flags = "" if len(args) < 3 else args[2]
+    if matches(xc, p, contextItem, ["", pattern, m_flags]):
+        raise XPathContext.XPathException(p, 'err:FORX0003', _('fn:tokenize $pattern matches a zero-length string: {0}').format(pattern))
+
+    try:
+        result = []
+        lastEnd = 0
+        for match in re.finditer(pattern, input, flags=regexFlags(xc, p, args, 2)):
+            start, end = match.span()
+            result.append(input[lastEnd:start])
+            lastEnd = end
+        result.append(input[lastEnd:])
+        return result
+    except re.error as err:
+        raise XPathContext.XPathException(p, 'err:FORX0002', _('fn:tokenize regular expression pattern error: {0}').format(err))
+
 
 def resolve_uri(xc, p, contextItem, args):
     if len(args) != 2: raise XPathContext.FunctionNumArgs()
@@ -488,7 +522,12 @@ def adjust_time_to_timezone(xc, p, contextItem, args):
     raise fnFunctionNotAvailable()
 
 def resolve_QName(xc, p, contextItem, args):
-    raise fnFunctionNotAvailable()
+    if len(args) != 2: raise XPathContext.FunctionNumArgs()
+    strQn = stringArg(xc, args, 0, "xs:string?")
+    node = nodeArg(xc, args, 1, 'element()', emptyFallback=())
+    if node is not None and isinstance(node,ModelObject):
+        return node.prefixedNameQname(strQn)
+    return ()
 
 def QName(xc, p, contextItem, args):
     if len(args) != 2: raise XPathContext.FunctionNumArgs()
@@ -810,7 +849,7 @@ def static_base_uri(xc, p, contextItem, args):
     raise fnFunctionNotAvailable()
 
 # added in XPATH 3
-def  format_number(xc, p, args):
+def format_number(xc, p, contextItem, args):
     if len(args) != 2: raise XPathContext.FunctionNumArgs()
     value = numericArg(xc, p, args, 0, missingArgFallback='NaN', emptyFallback='NaN')
     picture = stringArg(xc, args, 1, "xs:string", missingArgFallback='', emptyFallback='')

arelle/FunctionIxt.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 '''
 See COPYRIGHT.md for copyright information.
 '''
@@ -1256,20 +1254,25 @@ tr5Functions.update ({
 })
 deprecatedNamespaceURI = 'http://www.xbrl.org/2008/inlineXBRL/transformation' # the CR/PR pre-REC namespace
 
+ixtNamespacesByVersion = {
+    1: 'http://www.xbrl.org/inlineXBRL/transformation/2010-04-20',
+    2: 'http://www.xbrl.org/inlineXBRL/transformation/2011-07-31',
+    3: 'http://www.xbrl.org/inlineXBRL/transformation/2015-02-26',
+    4: 'http://www.xbrl.org/inlineXBRL/transformation/2020-02-12',
+    5: 'http://www.xbrl.org/inlineXBRL/transformation/2022-02-16',
+}
+
 ixtNamespaces = {
-    "ixt v1": 'http://www.xbrl.org/inlineXBRL/transformation/2010-04-20',
-    "ixt v2": 'http://www.xbrl.org/inlineXBRL/transformation/2011-07-31',
-    "ixt v3": 'http://www.xbrl.org/inlineXBRL/transformation/2015-02-26',
-    "ixt v4": 'http://www.xbrl.org/inlineXBRL/transformation/2020-02-12',
-    "ixt v5": 'http://www.xbrl.org/inlineXBRL/transformation/2022-02-16',
-    }
+    f"ixt v{key}": val
+    for key, val in ixtNamespacesByVersion.items()
+}
 
 ixtNamespaceFunctions = {
-    ixtNamespaces["ixt v1"]: tr1Functions, # transformation registry v1
-    ixtNamespaces["ixt v2"]: tr2Functions, # transformation registry v2
-    ixtNamespaces["ixt v3"]: tr3Functions, # transformation registry v3
-    ixtNamespaces["ixt v4"]: tr4Functions, # transformation registry v4
-    ixtNamespaces["ixt v5"]: tr5Functions, # transformation registry v5
+    ixtNamespacesByVersion[1]: tr1Functions, # transformation registry v1
+    ixtNamespacesByVersion[2]: tr2Functions, # transformation registry v2
+    ixtNamespacesByVersion[3]: tr3Functions, # transformation registry v3
+    ixtNamespacesByVersion[4]: tr4Functions, # transformation registry v4
+    ixtNamespacesByVersion[5]: tr5Functions, # transformation registry v5
     "http://www.xbrl.org/inlineXBRL/transformation/WGWD/YYYY-MM-DD": tr5Functions, # transformation registry v4 draft
     'http://www.xbrl.org/2008/inlineXBRL/transformation': tr1Functions # the CR/PR pre-REC namespace
 }

arelle/FunctionUtil.py

@@ -30,7 +30,7 @@ def stringArg(xc, args, i, type, missingArgFallback=None, emptyFallback=''):
     item = anytypeArg(xc, args, i, type, missingArgFallback)
     if item == (): return emptyFallback
     if isinstance(item, (ModelObject,ModelAttribute)):
-        return item.text
+        return item.text or emptyFallback
     return str(item)
 
 def numericArg(xc, p, args, i=0, missingArgFallback=None, emptyFallback=0, convertFallback=None):

arelle/FunctionXfi.py

@@ -365,7 +365,7 @@ def uncovered_dimensional_aspects(xc, p, args):
     return uncovered_aspects(xc, p, args, dimensionAspects=True)
 
 def uncovered_aspects(xc, p, args, dimensionAspects=False):
-    from arelle.ModelFormulaObject import aspectToToken, Aspect
+    from arelle.Aspect import aspectToToken, Aspect
     from arelle.formula.FormulaEvaluator import uncoveredVariableSetAspects
     if len(args) != 0: raise XPathContext.FunctionNumArgs()
 
@@ -1026,7 +1026,7 @@ def fact_footnotes(xc, p, args):
         return relationshipSet.label(itemObj, footnoteroleURI, lang, returnMultiple=True) or ()
     return ()
 
-def concept_relationships(xc, p, args, nestResults=False):
+def concept_relationships(xc, p, args, nestResults=False, targetRole=False): # nestResults if for table linkbase relationships
     lenArgs = len(args)
     if not 4 <= lenArgs <= 8: raise XPathContext.FunctionNumArgs()
     inst = instance(xc, p, args, 7)
@@ -1038,18 +1038,25 @@ def concept_relationships(xc, p, args, nestResults=False):
         linkroleURI = None
     arcroleURI = stringArg(xc, args, 2, "xs:string")
     axis = stringArg(xc, args, 3, "xs:string")
-    if not axis in ('descendant', 'child', 'ancestor', 'parent', 'sibling', 'sibling-or-self'):
-        raise XPathContext.FunctionArgType(3, "'descendant', 'child', 'ancestor', 'parent', 'sibling' or 'sibling-or-self'",
-                                           errCode="xfie:InvalidConceptRelationParameters")
+    allowedAxes = {
+        False: ('descendant', 'child', 'ancestor', 'parent', 'sibling', 'sibling-or-descendant'),
+        True: ('descendant', 'child', 'ancestor', 'parent', 'sibling', 'sibling-or-descendant', 'sibling-or-self', 'sibling-or-descendant-or-self')
+        }[nestResults]
+    if not axis in allowedAxes:
+        raise XPathContext.FunctionArgType(3, ", ".join(allowedAxes),
+                                           errCode="xfie:InvalidConceptRelationParameters", value=axis)
     if qnSource != XbrlConst.qnXfiRoot:
         srcConcept = inst.qnameConcepts.get(qnSource)
         if srcConcept is None:
             return ()
     if lenArgs > 4:
-        generations = numericArg(xc, p, args, 4, "xs:integer", convertFallback=0)
+        generations = numericArg(xc, p, args, 4, "xs:integer", convertFallback=-1)
+        if generations < 0:
+            raise XPathContext.FunctionArgType(4, "generations must be a non-negative integer",
+                                               errCode="xfie:InvalidConceptRelationParameters", value=generations)
         if axis in ('child', 'parent', 'sibling', 'sibling-or-self') and generations != 1:
             raise XPathContext.FunctionArgType(4, "generations must be 1 for 'child', 'parent', 'sibling' or 'sibling-or-self' axis",
-                                               errCode="xfie:InvalidConceptRelationParameters")
+                                               errCode="xfie:InvalidConceptRelationParameters", value=generations)
     elif axis in ('child', 'parent', 'sibling', 'sibling-or-self'):
         generations = 1
     else:
@@ -1069,7 +1076,8 @@ def concept_relationships(xc, p, args, nestResults=False):
     else:
         qnArc = None
 
-    removeSelf = axis == 'sibling'
+    if arcroleURI == "XBRL-dimensions":
+        targetRole = True
     relationshipSet = inst.relationshipSet(arcroleURI, linkroleURI, qnLink, qnArc)
     if relationshipSet:
         result = []
@@ -1088,24 +1096,60 @@ def concept_relationships(xc, p, args, nestResults=False):
             rels = relationshipSet.fromModelObject(srcConcept)
         elif axis == 'ancestor': # includes first pass on parents of object to get sibling
             rels = relationshipSet.toModelObject(srcConcept)
-        elif axis in ('sibling', 'sibling-or-self'):
+        elif axis in ('sibling', 'sibling-or-descendant', 'sibling-or-self', 'sibling-or-descendant-or-self'):
             rels = relationshipSet.toModelObject(srcConcept)
             if rels:
-                rels = relationshipSet.fromModelObject(rels[0].fromModelObject)
-                axis = 'descendant'
+                relToSelf = rels[0]
+                rels = relationshipSet.fromModelObject(relToSelf.fromModelObject)
+                if axis == 'sibling-or-self':
+                    return rels
+                if axis == 'sibling':
+                    return [rel for rel in rels if rel.toModelObject != srcConcept]
+                # get descendants
+                if 0 <= generations <= 1:
+                    g = 0
+                    visited = set()
+                else:
+                    g += 2
+                indexOfSelfInRels = rels.index(relToSelf)
+                if indexOfSelfInRels >= 0:
+                    concept_relationships_step(xc, inst, relationshipSet, [relToSelf], 'descendant', g, result, visited, nestResults, targetRole)
+                    if len(result) >= 2 and isinstance(result[1], list): # contains [self, [descendants...]
+                        if axis == 'sibling-or-descendant':
+                            return rels[:indexOfSelfInRels] + result[1] + rels[indexOfSelfInRels+1:]
+                        if axis == 'sibling-or-descendant-or-self':
+                            return rels[:indexOfSelfInRels] + result + rels[indexOfSelfInRels+1:]
+            elif nestResults: # roots for table linkbase have the roots as siblings
+                rootQNs = [c.qname for c in relationshipSet.rootConcepts]
+                if qnSource in rootQNs:
+                    if axis == 'sibling-or-self':
+                        return rootQNs
+                    if axis == 'sibling':
+                        return [c for c in rootQNs if c != qnSource]
+                    rels = relationshipSet.fromModelObject(srcConcept)
+                    # get descendants
+                    if 0 <= generations <= 1:
+                        g = 0
+                        visited = set()
+                    else:
+                        g += 2
+                    indexOfSelfInRoots = rootQNs.index(qnSource)
+                    if indexOfSelfInRels >= 0:
+                        concept_relationships_step(xc, inst, relationshipSet, [relToSelf], 'descendant', g, result, visited, nestResults, targetRole)
+                        if len(result) >= 2 and isinstance(result[1], list): # contains [self, [descendants...]
+                            if axis == 'sibling-or-descendant':
+                                return rootQNs[:indexOfSelfInRoots] + result[1] + rootQNs[indexOfSelfInRoots+1:]
+                            if axis == 'sibling-or-descendant-or-self':
+                                return rootQNs[:indexOfSelfInRoots] + result + rootQNs[indexOfSelfInRoots+1:]
+                return []
             else: # must be a root, never has any siblings
                 return []
         if rels:
-            concept_relationships_step(xc, inst, relationshipSet, rels, axis, generations, result, visited, nestResults)
-            if removeSelf:
-                for i, rel in enumerate(result):
-                    if rel.toModelObject == srcConcept:
-                        result.pop(i)
-                        break
+            concept_relationships_step(xc, inst, relationshipSet, rels, axis, generations, result, visited, nestResults, targetRole)
             return result
     return ()
 
-def concept_relationships_step(xc, inst, relationshipSet, rels, axis, generations, result, visited, nestResults):
+def concept_relationships_step(xc, inst, relationshipSet, rels, axis, generations, result, visited, nestResults, targetRole):
     if rels:
         for modelRel in rels:
             concept = modelRel.toModelObject if axis == 'descendant' else modelRel.fromModelObject
@@ -1116,18 +1160,18 @@ def concept_relationships_step(xc, inst, relationshipSet, rels, axis, generation
                 if generations == 0:
                     visited.add(conceptQname)
                 if axis == 'descendant':
-                    if relationshipSet.arcrole == "XBRL-dimensions":
-                        stepRelationshipSet = inst.relationshipSet("XBRL-dimensions", modelRel.consecutiveLinkrole)
+                    if targetRole:
+                        stepRelationshipSet = inst.relationshipSet(relationshipSet.arcrole, modelRel.consecutiveLinkrole)
                     else:
                         stepRelationshipSet = relationshipSet
                     stepRels = stepRelationshipSet.fromModelObject(concept)
                 else:
-                    if relationshipSet.arcrole == "XBRL-dimensions":
-                        stepRelationshipSet = inst.relationshipSet("XBRL-dimensions")
+                    if targetRole:
+                        stepRelationshipSet = inst.relationshipSet(relationshipSet.arcrole)
                         # search all incoming relationships for those with right consecutiveLinkrole
                         stepRels = [rel
                                     for rel in stepRelationshipSet.toModelObject(concept)
-                                    if rel.consectuiveLinkrole == modelRel.linkrole]
+                                    if rel.consecutiveLinkrole == modelRel.linkrole]
                     else:
                         stepRelationshipSet = relationshipSet
                         stepRels = stepRelationshipSet.toModelObject(concept)
@@ -1135,7 +1179,7 @@ def concept_relationships_step(xc, inst, relationshipSet, rels, axis, generation
                     nestedList = []
                 else: # nested results flattened in top level results
                     nestedList = result
-                concept_relationships_step(xc, inst, stepRelationshipSet, stepRels, axis, nextGen, nestedList, visited, nestResults)
+                concept_relationships_step(xc, inst, stepRelationshipSet, stepRels, axis, nextGen, nestedList, visited, nestResults, targetRole)
                 if nestResults and nestedList:  # don't append empty nested results
                     result.append(nestedList)
                 if generations == 0:

arelle/FunctionXs.py

@@ -399,7 +399,7 @@ def hexBinary(xc, p, source):
     raise xsFunctionNotAvailable()
 
 def anyURI(xc, p, source):
-    return ModelValue.anyURI(source)
+    return ModelValue.anyURI(source, castException=FORG0001)
 
 def QName(xc, p, source):
     if isinstance(p, ProgHeader):

arelle/HtmlUtil.py

@@ -1,12 +1,13 @@
 '''
 See COPYRIGHT.md for copyright information.
 '''
-import regex as re
+from __future__ import annotations
 
-def attrValue(str, name):
+
+def attrValue(attr: str) -> str:
     # retrieves attribute in a string, such as xyz="abc" or xyz='abc' or xyz=abc;
-    prestuff, matchedName, valuePart = str.lower().partition("charset")
-    value = []
+    prestuff, matchedName, valuePart = attr.lower().partition("charset")
+    value: list[str] = []
     endSep = None
     beforeEquals = True
     for c in valuePart:

arelle/LeiUtil.py

@@ -1,55 +1,75 @@
-'''
+"""
 See COPYRIGHT.md for copyright information.
 
 Implementation of ISO 17442:2012(E) Appendix A
 
-'''
+"""
+
+import string
+from enum import Enum, auto
+
 import regex as re
 
-LEI_VALID = 0
-LEI_INVALID_LEXICAL = 1
-LEI_INVALID_CHECKSUM = 2
 
-LEI_RESULTS = ("valid", "invalid lexical", "invalid checksum")
+class LEIValidationResult(Enum):
+    VALID = auto()
+    INVALID_LEXICAL = auto()
+    INVALID_CHECKSUM = auto()
+
+    def description(self) -> str:
+        return self.name.lower().replace("_", " ")
+
+
+LEI_VALID = LEIValidationResult.VALID
+LEI_INVALID_LEXICAL = LEIValidationResult.INVALID_LEXICAL
+LEI_INVALID_CHECKSUM = LEIValidationResult.INVALID_CHECKSUM
+
+_leiLexicalPattern = re.compile(r"[0-9A-Z]{18}[0-9]{2}", re.ASCII)
+_requiredLEILength = 20
+
+_leiToDigitTable = str.maketrans(
+    dict(
+        (ord(char), str(index))
+        for index, char in enumerate(string.ascii_uppercase, start=len(string.digits))
+    )
+)
+
+# The pattern comes from Solvency II documentation here https://dev.eiopa.europa.eu/Taxonomy/Full/2.3.0/PF/EIOPA_PensionFunds_Validations_2.3.0_PWD2.xlsx
+_validLeiDespiteChecksumFailPatternString = r"^(029200720E3M3A4D6D01|029200758D5M0AI3F601|315700X8JQ3IU0NGK501|3157007SCCESQAUH5Z01|315700TCC9NTEP7J8Z01|13250000000000000301|315700ADOXDR5PCY5400|315700A0UB9Q7DOQIZ00|315700BM9Z39TNTGQW00|315700BZ5F7DRYG2UM00|315700B8401GTFFY6X01|315700DJ07P6OX10FK01|315700DKCD4QSKLAMO01|315700D23JL5C1DZNT00|315700EIYO2TLSEGQ700|315700ET7M7VQ4C84R00|315700EZSEA51937KX01|315700GXBGM8DBYKHF01|315700GZA843JXKTJ400|315700G5G24XYL1TXH00|315700HS7WJ1B0SUWM01|315700HXOEOK58E58P01|315700HZU4SMI8LZTU00|315700I3W2AFHP8MNQ01|315700JICZ3SY5SAXX00|315700JKZH6I0067ND01|315700JO5E28SRE00Q01|315700JXUHL9H2C3P700|315700LDDN3RM7Y2MP00|315700LWYOZNQ7V1T100|315700MBYPT6PGKO7M01|315700MW2F0KFR45QW01|315700M5843O6DU83901|315700NNMGS8F3P2CN00|315700N0VEIBHP0NPQ01|315700OASRCM664PAW01|315700OFW4YCOBNX4U01|315700OVW93X0T3HP200|315700O666JVNCQU9X00|315700PLI0I7W8IOV400|315700PN3J57ZUNF1V00|315700PXKOSX7WQV4N00|315700P4N9VSLK5QZV01|315700P40OV6BT045900|315700P6TZOLP92KN801|315700P89WR82VNB8Z00|315700QGM4XWZE1I5N01|315700Q1S8O1UORF9700|315700RK8M4FAHMYAP01|315700RTEHY362KXWJ00|315700SNUXK41WMW5J00|315700S22RGYRIEEOT00|315700S3TF79ALV82F01|315700TF5Z7T28HZJK01|315700TWGZ89LLSRS000|315700TXNX10N8XH4K00|315700T2EEQAPBO0C301|315700T6T49EDM16YO01|315700UJ6N4LGKLNPB00|315700UKZXWXEO126601|315700UYFD5GF9R13F01|315700VG7PTE9EJJRX01|315700VITYR7AL4M9S01|315700VMAJZ9JZTXNQ00|315700WH3YMKHCVYW201|315700WKCDF4QGRRO200|315700WR4IHOO1M5LP00|315700WYOZ6994UATN00|315700WZPEIS41QDKE00|315700XEFYMA5EZ0P500|315700XE21UYOA3GAC01|315700XI4Z8GF5BDUJ01|315700XSCP1S8WOD8E01|315700X40GNCOUWJYR00|315700YS6RQ5TF3VBP01|315700Y1W7W1JHAUBW00|315700Y5JNQMMUF5ID01|3157000VAJWZ3P8ZED00|3157001KM8GOU7PXZY01|3157001K2LAL04D87901|3157001MLDD3SDFQA901|3157001TPR6K4GBTLN00|31570010000000006400|31570010000000009601|31570010000000019301|31570010000000025800|31570010000000029001|31570010000000035500|31570010000000038701|31570010000000045200|31570010000000048401|31570010000000054900|31570010000000064600|31570010000000067801|31570010000000077501|31570010000000084000|31570010000000087201|31570010000000096901|31570010000000103400|31570010000000106601|31570010000000116301|31570010000000122800|31570010000000126001|3157002CKDQOCIHE5H01|31570020000000005900|31570029808HJVCNFA01|3157003FQSSGS9OZ9E01|3157004PTVTDOKB46401|3157004R6CH6C1P4KX00|3157005RUI28M8FANK00|3157005VJE7A3MBUS201|3157005WT1SENAE17R00|31570058O0Z320C4GZ00|3157006B6JVZ5DFMSN00|3157006DE3SPNIUY9K01|3157006FR3JBBOLOMX01|3157006I3B6RSTPQLI00|3157006KT1EZ15OIXW00|315700659AALVVLVIO01|31570067WSCDST0S3F01|3157008VKYORMUNC5O01|3157008ZY7CW6LVU5J00|3157009FTHFDDK7FHW01|3157009OVCV07O4HXM00|315700T8U7IU4W8J3A01|315700BBRQHDWX6SHZ00|3157008KD17KROO7UT01)$"
 
-leiLexicalPattern = re.compile(r"^[0-9A-Z]{18}[0-9]{2}$")
+# Turn the _validLeiDespiteChecksumFailPattern in to an immutable set as that is much faster to check
+_validLeiDespiteChecksumFailSet = frozenset(
+    _validLeiDespiteChecksumFailPatternString[2:-2].split("|")
+)
 
-validInvalidLeiPattern = re.compile("^(029200720E3M3A4D6D01|029200758D5M0AI3F601|315700X8JQ3IU0NGK501|3157007SCCESQAUH5Z01|315700TCC9NTEP7J8Z01|13250000000000000301|315700ADOXDR5PCY5400|315700A0UB9Q7DOQIZ00|315700BM9Z39TNTGQW00|315700BZ5F7DRYG2UM00|315700B8401GTFFY6X01|315700DJ07P6OX10FK01|315700DKCD4QSKLAMO01|315700D23JL5C1DZNT00|315700EIYO2TLSEGQ700|315700ET7M7VQ4C84R00|315700EZSEA51937KX01|315700GXBGM8DBYKHF01|315700GZA843JXKTJ400|315700G5G24XYL1TXH00|315700HS7WJ1B0SUWM01|315700HXOEOK58E58P01|315700HZU4SMI8LZTU00|315700I3W2AFHP8MNQ01|315700JICZ3SY5SAXX00|315700JKZH6I0067ND01|315700JO5E28SRE00Q01|315700JXUHL9H2C3P700|315700LDDN3RM7Y2MP00|315700LWYOZNQ7V1T100|315700MBYPT6PGKO7M01|315700MW2F0KFR45QW01|315700M5843O6DU83901|315700NNMGS8F3P2CN00|315700N0VEIBHP0NPQ01|315700OASRCM664PAW01|315700OFW4YCOBNX4U01|315700OVW93X0T3HP200|315700O666JVNCQU9X00|315700PLI0I7W8IOV400|315700PN3J57ZUNF1V00|315700PXKOSX7WQV4N00|315700P4N9VSLK5QZV01|315700P40OV6BT045900|315700P6TZOLP92KN801|315700P89WR82VNB8Z00|315700QGM4XWZE1I5N01|315700Q1S8O1UORF9700|315700RK8M4FAHMYAP01|315700RTEHY362KXWJ00|315700SNUXK41WMW5J00|315700S22RGYRIEEOT00|315700S3TF79ALV82F01|315700TF5Z7T28HZJK01|315700TWGZ89LLSRS000|315700TXNX10N8XH4K00|315700T2EEQAPBO0C301|315700T6T49EDM16YO01|315700UJ6N4LGKLNPB00|315700UKZXWXEO126601|315700UYFD5GF9R13F01|315700VG7PTE9EJJRX01|315700VITYR7AL4M9S01|315700VMAJZ9JZTXNQ00|315700WH3YMKHCVYW201|315700WKCDF4QGRRO200|315700WR4IHOO1M5LP00|315700WYOZ6994UATN00|315700WZPEIS41QDKE00|315700XEFYMA5EZ0P500|315700XE21UYOA3GAC01|315700XI4Z8GF5BDUJ01|315700XSCP1S8WOD8E01|315700X40GNCOUWJYR00|315700YS6RQ5TF3VBP01|315700Y1W7W1JHAUBW00|315700Y5JNQMMUF5ID01|3157000VAJWZ3P8ZED00|3157001KM8GOU7PXZY01|3157001K2LAL04D87901|3157001MLDD3SDFQA901|3157001TPR6K4GBTLN00|31570010000000006400|31570010000000009601|31570010000000019301|31570010000000025800|31570010000000029001|31570010000000035500|31570010000000038701|31570010000000045200|31570010000000048401|31570010000000054900|31570010000000064600|31570010000000067801|31570010000000077501|31570010000000084000|31570010000000087201|31570010000000096901|31570010000000103400|31570010000000106601|31570010000000116301|31570010000000122800|31570010000000126001|3157002CKDQOCIHE5H01|31570020000000005900|31570029808HJVCNFA01|3157003FQSSGS9OZ9E01|3157004PTVTDOKB46401|3157004R6CH6C1P4KX00|3157005RUI28M8FANK00|3157005VJE7A3MBUS201|3157005WT1SENAE17R00|31570058O0Z320C4GZ00|3157006B6JVZ5DFMSN00|3157006DE3SPNIUY9K01|3157006FR3JBBOLOMX01|3157006I3B6RSTPQLI00|3157006KT1EZ15OIXW00|315700659AALVVLVIO01|31570067WSCDST0S3F01|3157008VKYORMUNC5O01|3157008ZY7CW6LVU5J00|3157009FTHFDDK7FHW01|3157009OVCV07O4HXM00|315700T8U7IU4W8J3A01|315700BBRQHDWX6SHZ00|3157008KD17KROO7UT01)$")
 
-def checkLei(lei: str) -> int:
-    if validInvalidLeiPattern.match(lei):
-        return LEI_VALID
-    if not leiLexicalPattern.match(lei):
-        return LEI_INVALID_LEXICAL
-    if not int(
-        "".join({"0":"0", "1":"1", "2":"2", "3":"3", "4":"4", "5":"5", "6":"6", "7":"7", "8":"8", "9":"9",
-                 "A":"10", "B":"11", "C":"12", "D":"13", "E":"14", "F":"15", "G":"16", "H":"17", "I":"18",
-                 "J":"19", "K":"20", "L":"21", "M":"22", "N":"23", "O":"24", "P":"25", "Q":"26", "R":"27",
-                 "S":"28", "T":"29", "U":"30", "V":"31", "W":"32", "X":"33", "Y":"34", "Z":"35"
-                 }[c] for c in lei)
-               ) % 97 == 1:
-        return LEI_INVALID_CHECKSUM
-    return LEI_VALID
+def checkLei(lei: str) -> LEIValidationResult:
+    if len(lei) != _requiredLEILength:
+        return LEIValidationResult.INVALID_LEXICAL
+
+    if not _leiLexicalPattern.fullmatch(lei):
+        return LEIValidationResult.INVALID_LEXICAL
+
+    result = LEIValidationResult.INVALID_CHECKSUM
+
+    if int(lei.translate(_leiToDigitTable)) % 97 == 1:
+        result = LEIValidationResult.VALID
+
+    if (
+        result is LEIValidationResult.INVALID_CHECKSUM
+        and lei in _validLeiDespiteChecksumFailSet
+    ):
+        result = LEIValidationResult.VALID
+
+    return result
+
 
 if __name__ == "__main__":
-    # test cases
-    for lei, name in (
-                        ("001GPB6A9XPE8XJICC14", "Fidelity Advisor Series I"),
-                        ("004L5FPTUREIWK9T2N63", "Hutchin Hill Capital, LP"),
-                        ("00EHHQ2ZHDCFXJCPCL46", "Vanguard Russell 1000 Growth Index Trust"),
-                        ("00GBW0Z2GYIER7DHDS71", "Aristeia Capital, L.L.C."),
-                        ("1S619D6B3ZQIH6MS6B47", "Barclays Vie SA"),
-                        ("21380014JAZAUFJRHC43", "BRE/OPERA HOLDINGS"),
-                        ("21380016W7GAG26FIJ74", "SOCIETE FRANCAISE ET SUISSE"),
-                        ("21380058ERUIT9H53T71", "TOTAN ICAP CO., LTD"),
-                        ("213800A9GT65GAES2V60", "BARCLAYS SECURITIES JAPAN LIMITED"),
-                        ("213800DELL1MWFDHVN53", "PIRELLI JAPAN"),
-                        ("213800A9GT65GAES2V60", "BARCLAYS SECURITIES JAPAN LIMITED"),
-                        ("214800A9GT65GAES2V60", "Error 1"),
-                        ("213800A9GT65GAE%2V60", "Error 2"),
-                        ("213800A9GT65GAES2V62", "Error 3"),
-                        ("1234", "Error 4"),
-                        ("""
-5299003M8JKHEFX58Y02""", "Error 4")
-                        ):
-            print ("LEI {} result {} name {}".format(lei, LEI_RESULTS[checkLei(lei)], name)  )
+    import sys
+
+    leis = sys.argv[1:]
+    if not leis:
+        raise SystemExit("Specify the LEI(s) you want to check as arguments.")
+
+    for arg in sys.argv[1:]:
+        print(f"{arg:20s} : {checkLei(arg).description()}")

arelle/LinkbaseType.py

@@ -0,0 +1,94 @@
+'''
+See COPYRIGHT.md for copyright information.
+'''
+from __future__ import annotations
+
+from enum import Enum
+
+from arelle import XbrlConst
+from arelle.ModelValue import QName
+
+
+class LinkbaseType(Enum):
+    CALCULATION = "calculation"
+    DEFINITION = "definition"
+    LABEL = "label"
+    PRESENTATION = "presentation"
+    REFERENCE = "reference"
+
+    @staticmethod
+    def fromRefUri(refUri: str | None) -> LinkbaseType | None:
+        """
+        Returns the LinkbaseType corresponding to the given ref URI.
+        If the URI does not match any known linkbase reference type, returns None.
+        """
+        if refUri is None:
+            return None
+        return LINKBASE_TYPE_BY_REF_URI.get(refUri, None)
+
+    def getArcQn(self) -> QName:
+        """
+        Returns the qname of the arc associated with this LinkbaseType.
+        """
+        return LINKBASE_ARC_QN[self]
+
+    def getArcroles(self) -> frozenset[str]:
+        """
+        Returns the standard arcrole URIs associated with this LinkbaseType.
+        """
+        return LINKBASE_ARCROLES[self]
+
+    def getLinkQn(self) -> QName:
+        """
+        Returns the qname of the link associated with this LinkbaseType.
+        """
+        return LINKBASE_LINK_QN[self]
+
+    def getLowerName(self) -> str:
+        """
+        Returns the lower-case name of this LinkbaseType.
+        """
+        return self.value.lower()
+
+    def getRefUri(self) -> str:
+        """
+        Returns the ref URI associated with this LinkbaseType.
+        """
+        return LINKBASE_REF_URIS[self]
+
+
+LINKBASE_ARC_QN = {
+    LinkbaseType.CALCULATION: XbrlConst.qnLinkCalculationArc,
+    LinkbaseType.DEFINITION: XbrlConst.qnLinkDefinitionArc,
+    LinkbaseType.LABEL: XbrlConst.qnLinkLabelArc,
+    LinkbaseType.PRESENTATION: XbrlConst.qnLinkPresentationArc,
+    LinkbaseType.REFERENCE: XbrlConst.qnLinkReferenceArc,
+}
+
+LINKBASE_ARCROLES = {
+    LinkbaseType.CALCULATION: frozenset({
+        XbrlConst.summationItem,
+        XbrlConst.summationItem11,
+    }),
+    LinkbaseType.DEFINITION: XbrlConst.standardDefinitionArcroles,
+    LinkbaseType.LABEL: frozenset({XbrlConst.conceptLabel}),
+    LinkbaseType.PRESENTATION: frozenset({XbrlConst.parentChild}),
+    LinkbaseType.REFERENCE: frozenset({XbrlConst.conceptReference}),
+}
+
+LINKBASE_LINK_QN = {
+    LinkbaseType.CALCULATION: XbrlConst.qnLinkCalculationLink,
+    LinkbaseType.DEFINITION: XbrlConst.qnLinkDefinitionLink,
+    LinkbaseType.LABEL: XbrlConst.qnLinkLabelLink,
+    LinkbaseType.PRESENTATION: XbrlConst.qnLinkPresentationLink,
+    LinkbaseType.REFERENCE: XbrlConst.qnLinkReferenceLink,
+}
+
+LINKBASE_REF_URIS = {
+    LinkbaseType.CALCULATION: "http://www.xbrl.org/2003/role/calculationLinkbaseRef",
+    LinkbaseType.DEFINITION: "http://www.xbrl.org/2003/role/definitionLinkbaseRef",
+    LinkbaseType.LABEL: "http://www.xbrl.org/2003/role/labelLinkbaseRef",
+    LinkbaseType.PRESENTATION: "http://www.xbrl.org/2003/role/presentationLinkbaseRef",
+    LinkbaseType.REFERENCE: "http://www.xbrl.org/2003/role/referenceLinkbaseRef",
+}
+LINKBASE_TYPE_BY_REF_URI = {v: k for k, v in LINKBASE_REF_URIS.items()}

arelle/LocalViewer.py

@@ -4,8 +4,14 @@ See COPYRIGHT.md for copyright information.
 Provides infrastructure for local viewers of GUI applications such as inline XBRL viewers
 
 '''
-from arelle.webserver.bottle import Bottle, request, static_file, HTTPResponse
-import threading, time, logging, sys, traceback
+import logging
+import sys
+import threading
+import time
+import traceback
+
+from bottle import Bottle, HTTPResponse, request
+
 
 class LocalViewer:
     noCacheHeaders = {'Cache-Control': 'no-cache, no-store, must-revalidate',