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

arelle/plugin/validate/ESEF/Const.py

@@ -10,7 +10,6 @@ from arelle.FunctionIxt import ixtNamespaces
 from arelle.ModelValue import QName, qname
 from arelle.XmlValidate import lexicalPatterns
 
-styleIxHiddenPattern = re.compile(r"(.*[^\w]|^)-esef-ix-hidden\s*:\s*([\w.-]+).*")
 styleCssHiddenPattern = re.compile(r"(.*[^\w]|^)display\s*:\s*none([^\w].*|$)")
 datetimePattern = lexicalPatterns["XBRLI_DATEUNION"]
 docTypeXhtmlPattern = re.compile(r"^<!(?:DOCTYPE\s+)\s*html(?:PUBLIC\s+)?(?:.*-//W3C//DTD\s+(X?HTML)\s)?.*>$", re.IGNORECASE)
@@ -23,6 +22,14 @@ FOOTNOTE_LINK_CHILDREN = frozenset((
 ))
 
 PERCENT_TYPE = qname("{http://www.xbrl.org/dtr/type/numeric}num:percentItemType")
+PERCENT_TYPE_2020 = qname("{http://www.xbrl.org/dtr/type/2020-01-21}dtr-types:percentItemType")
+PERCENT_TYPE_2022 = qname("{http://www.xbrl.org/dtr/type/2022-03-31}dtr-types:percentItemType")
+PERCENT_TYPES = {
+    PERCENT_TYPE,
+    PERCENT_TYPE_2020,
+    PERCENT_TYPE_2022,
+}
+
 
 IXT_NAMESPACES = frozenset((
     ixtNamespaces["ixt v4"],  # only tr4 or newer REC is currently recommended
@@ -82,6 +89,10 @@ qnDomainItemTypes2023 = frozenset((
     qname("{http://www.xbrl.org/dtr/type/2020-01-21}nonnum:domainItemType"),
 ))
 
+qnDomainItemTypes2024 = frozenset((
+    qname("{http://www.xbrl.org/dtr/type/2022-03-31}nonnum:domainItemType"),
+))
+
 
 linkbaseRefTypes = {
     "http://www.xbrl.org/2003/role/calculationLinkbaseRef": "cal",
@@ -107,12 +118,16 @@ filenameRegexes = {
     "ref": r"(.{1,})-[0-9]{4}-[0-9]{2}-[0-9]{2}_ref[.]xml$",
 }
 
+reportBasenamePattern = "{base}-{date}-{version}-{lang}"
+reportBasenameRegex = re.compile(r"(.{1,})-[0-9]{4}-[0-9]{2}-[0-9]{2}-[1-9]-[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$")
+
 mandatory: set[QName] = set()  # mandatory element qnames
 
 # hidden references
 untransformableTypes = frozenset((
     "anyURI",
     "base64Binary",
+    "duration",
     "hexBinary",
     "NOTATION",
     "QName",
@@ -413,80 +428,6 @@ esefMandatoryElementNames2022 = (
     "StatementOfIFRSCompliance",
 )
 
-htmlEventHandlerAttributes = frozenset((
-    "onabort",
-    "onafterprint",
-    "onbeforeprint",
-    "onbeforeunload",
-    "onblur",
-    "oncanplay",
-    "oncanplaythrough",
-    "onchange",
-    "onclick",
-    "oncontextmenu",
-    "oncopy",
-    "oncuechange",
-    "oncut",
-    "ondblclick",
-    "ondrag",
-    "ondragend",
-    "ondragenter",
-    "ondragleave",
-    "ondragover",
-    "ondragstart",
-    "ondrop",
-    "ondurationchange",
-    "onemptied",
-    "onended",
-    "onerror",
-    "onfocus",
-    "onhashchange",
-    "oninput",
-    "oninvalid",
-    "onkeydown",
-    "onkeypress",
-    "onkeyup",
-    "onload",
-    "onloadeddata",
-    "onloadedmetadata",
-    "onloadstart",
-    "onmessage",
-    "onmousedown",
-    "onmousemove",
-    "onmouseout",
-    "onmouseover",
-    "onmouseup",
-    "onmousewheel",
-    "onoffline",
-    "ononline",
-    "onpagehide",
-    "onpageshow",
-    "onpaste",
-    "onpause",
-    "onplay",
-    "onplaying",
-    "onpopstate",
-    "onprogress",
-    "onratechange",
-    "onreset",
-    "onresize",
-    "onscroll",
-    "onsearch",
-    "onseeked",
-    "onseeking",
-    "onselect",
-    "onstalled",
-    "onstorage",
-    "onsubmit",
-    "onsuspend",
-    "ontimeupdate",
-    "ontoggle",
-    "onunload",
-    "onvolumechange",
-    "onwaiting",
-    "onwheel",
-))
-
 svgEventAttributes = frozenset((
     "onabort",
     "onactivate",

arelle/plugin/validate/ESEF/Dimensions.py

@@ -4,7 +4,7 @@ See COPYRIGHT.md for copyright information.
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Any, List, cast
+from typing import Any, cast
 
 import regex as re
 
@@ -134,7 +134,7 @@ def checkFilingDimensions(
                 modelObject=rels, anchoringDimensionalELR=ELR)
 
     # check base set dimension default overrides in extension taxonomies
-    for modelLink in cast(List[ModelLink], val.modelXbrl.baseSets[XbrlConst.dimensionDefault, None, None, None]):
+    for modelLink in cast(list[ModelLink], val.modelXbrl.baseSets[XbrlConst.dimensionDefault, None, None, None]):
         if isExtension(val, modelLink):
             for linkChild in modelLink:
                 if (isinstance(linkChild,(ModelObject,PrototypeObject)) and

arelle/plugin/validate/ESEF/ESEF_2021/DTS.py

@@ -348,6 +348,11 @@ def checkFilingDTS(
             val.modelXbrl.error("ESEF.3.1.1.linkbasesNotSeparateFiles",
                 _("Each linkbase type MUST be provided in a separate linkbase file, found: %(linkbasesFound)s."),
                 modelObject=modelDocument.xmlRootElement, linkbasesFound=", ".join(sorted(linkbasesFound)))
+            # As per ESEF conformance test case TC2_invalid, also output an extensionTaxonomyWrongFilesStructure error
+            val.modelXbrl.error("ESEF.3.1.1.extensionTaxonomyWrongFilesStructure",
+                                _("Each linkbase type MUST be provided in a separate linkbase file, please check file %(documentName)s."),
+                                modelObject=modelDocument.xmlRootElement,
+                                documentName=modelDocument.basename)
 
         # check for any prohibiting dimensionArc's
         for prohibitingArcElt in modelDocument.xmlRootElement.iterdescendants(tag="{http://www.xbrl.org/2003/linkbase}definitionArc"):
@@ -370,7 +375,7 @@ def checkFilingDTS(
                 _("Extension taxonomy document file name {base} component SHOULD be no longer than 20 characters, length is %(length)s:  %(documentName)s."),
                 modelObject=modelDocument.xmlRootElement, length=len(m.group(1)), documentName=modelDocument.basename)
 
-    if isExtensionDoc and val.authority == "UKFRC":
+    if isExtensionDoc and val.authority and val.authority.startswith("UKFRC"):
         if modelDocument.type == ModelDocumentFile.Type.INLINEXBRL:
             if modelDocument.documentEncoding.lower() != "utf-8":
                 val.modelXbrl.error("UKFRC.1.1.instanceDocumentEncoding",

arelle/plugin/validate/ESEF/ESEF_2021/Image.py

@@ -3,14 +3,14 @@ See COPYRIGHT.md for copyright information.
 """
 from __future__ import annotations
 
-from typing import Any, Union
+from typing import Any
 from urllib.parse import unquote
 
 from lxml.etree import XML, XMLSyntaxError
 
 from arelle.ModelObject import ModelObject
 from arelle.ModelXbrl import ModelXbrl
-from arelle.UrlUtil import scheme
+from arelle.UrlUtil import isExternalUrl
 from arelle.ValidateFilingText import validateGraphicHeaderType
 from arelle.typing import TypeGetText
 from ..Const import supportedImgTypes
@@ -68,7 +68,7 @@ def checkImageContents(
 def checkSVGContent(
     modelXbrl: ModelXbrl,
     imgElt: ModelObject,
-    data: Union[bytes, Any, str],
+    data: bytes | Any | str,
     guidance: str,
 ) -> None:
     rootElement = True
@@ -79,6 +79,9 @@ def checkSVGContent(
                                 _("Image SVG has root element which is not svg"),
                                 modelObject=imgElt)
             rootElement = False
+        # Comments, processing instructions, and maybe other special constructs don't have string tags.
+        if not isinstance(elt.tag, str):
+            continue
         eltTag = elt.tag.rpartition("}")[2] # strip namespace
         if eltTag in ("object", "script", "audio", "foreignObject", "iframe", "image", "use", "video"):
             href = elt.get("href","")
@@ -86,7 +89,7 @@ def checkSVGContent(
                 modelXbrl.error(f"{guidance}.executableCodePresent",
                                 _("Inline XBRL images MUST NOT contain executable code: %(element)s"),
                                 modelObject=imgElt, element=eltTag)
-            elif scheme(href) in ("http", "https", "ftp"):
+            elif isExternalUrl(href):
                 modelXbrl.error(f"{guidance}.referencesPointingOutsideOfTheReportingPackagePresent",
                                 _("Inline XBRL instance document [image] MUST NOT contain any reference pointing to resources outside the reporting package: %(element)s"),
                                 modelObject=imgElt, element=eltTag)

arelle/plugin/validate/ESEF/ESEF_2021/ValidateXbrlFinally.py

@@ -11,7 +11,7 @@ from math import isnan
 from typing import Any, cast
 
 import regex as re
-from lxml.etree import EntityBase, _Comment, _ElementTree, _ProcessingInstruction
+from lxml.etree import _Comment, _Element, _ElementTree, _Entity, _ProcessingInstruction
 
 from arelle import LeiUtil, ModelDocument, XbrlConst
 from arelle.ModelDtsObject import ModelConcept
@@ -22,8 +22,12 @@ from arelle.ModelInstanceObject import ModelInlineFootnote
 from arelle.ModelObject import ModelObject
 from arelle.ModelRelationshipSet import ModelRelationshipSet
 from arelle.ModelValue import QName, qname
-from arelle.PythonUtil import strTruncate
-from arelle.UrlUtil import decodeBase64DataImage, isHttpUrl, scheme
+from arelle.utils.validate.ValidationUtil import etreeIterWithDepth
+from arelle.PythonUtil import isLegacyAbs, strTruncate
+from arelle.utils.Contexts import partitionModelXbrlContexts
+from arelle.utils.Units import partitionModelXbrlUnits
+from arelle.utils.validate.DetectScriptsInXhtml import containsScriptMarkers
+from arelle.UrlUtil import decodeBase64DataImage, isHttpUrl, isExternalUrl
 from arelle.ValidateFilingText import parseImageDataURL
 from arelle.ValidateUtr import ValidateUtr
 from arelle.ValidateXbrl import ValidateXbrl
@@ -56,11 +60,11 @@ from ..Const import (
     esefStatementsOfMonetaryDeclarationNames,
     mandatory,
     styleCssHiddenPattern,
-    styleIxHiddenPattern,
     untransformableTypes,
 )
 from ..Dimensions import checkFilingDimensions
-from ..Util import etreeIterWithDepth, hasEventHandlerAttributes, isExtension
+from ..Util import isExtension
+
 
 _: TypeGetText  # Handle gettext
 
@@ -85,17 +89,30 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
     if reportPackageMaxMB is not None and modelXbrl.fileSource.fs: # must be a zip to be a report package
         assert isinstance(modelXbrl.fileSource.fs, zipfile.ZipFile)
         maxMB = float(reportPackageMaxMB)
+        _size: int | None = None
+        _sizeExact = True
         if val.authParam["reportPackageMeasurement"] == "unzipped":
             _size = sum(zi.file_size for zi in modelXbrl.fileSource.fs.infolist())
+            _sizeExact = False
         else:
-            _size = sum(zi.compress_size for zi in modelXbrl.fileSource.fs.infolist())
-            # not usable because zip may be posted or streamed: _size = os.path.getsize(modelXbrl.fileSource.basefile)
-        if _size > maxMB * 1048576:
+            try:
+                _size = modelXbrl.fileSource.getBytesSize()
+            except Exception:
+                pass
+            if _size is None:
+                _size = modelXbrl.fileSource.getBytesSizeEstimate()
+                _sizeExact = False
+        modelXbrl.info("arelle.ESEF.reportPackageSize",
+                       _("The %(estimated)s report package %(reportPackageMeasurement)s size is %(size)s bytes."),
+                       estimated=_("exact") if _sizeExact else _("estimated"),
+                       reportPackageMeasurement=_(val.authParam["reportPackageMeasurement"]) or _("zipped"),
+                       size=_size)
+        if _size is not None and _size > maxMB * 1048576:
             modelXbrl.error("arelle.ESEF.maximumReportPackageSize",
                             _("The authority %(authority)s requires a report package size under %(maxSize)s MB, size is %(size)s."),
                             modelObject=modelXbrl, authority=val.authority, maxSize=reportPackageMaxMB, size=_size)
 
-    if val.authority == "UKFRC":
+    if val.authority and val.authority.startswith("UKFRC"):
         if modelXbrl.fileSource and modelXbrl.fileSource.taxonomyPackage and modelXbrl.fileSource.taxonomyPackage["publisherCountry"] != "GB":
             modelXbrl.error("UKFRC.1.2.publisherCountrySetting",
                         _("The \"Publisher Country\" element of the report package metadata for a UKSEF report MUST be set to \"GB\" but was \"%(publisherCountry)s\"."),
@@ -185,12 +202,12 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 _baseName, _baseExt = os.path.splitext(doc.basename)
                 if _baseExt not in (".xhtml",".html"):
                     if val.consolidated:
-                        XHTMLExtensionGuidance = "2.6.1"
+                        errorCode = "ESEF.2.6.1.incorrectFileExtension"
                         reportType = _("Inline XBRL document included within a ESEF report package")
                     else:
-                        XHTMLExtensionGuidance = "4.1.1"
+                        errorCode = "ESEF.4.1.1.incorrectFileExtension"
                         reportType = _("Stand-alone XHTML document")
-                    modelXbrl.error(f"ESEF.{XHTMLExtensionGuidance}.incorrectFileExtension",
+                    modelXbrl.error(errorCode,
                                     _("%(reportType)s MUST have a .html or .xhtml extension: %(fileName)s"),
                                     modelObject=doc, fileName=doc.basename, reportType=reportType)
                 docinfo = doc.xmlRootElement.getroottree().docinfo
@@ -251,6 +268,9 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                        "%(documentSets)s (Document files appear to be in multiple document sets)"),
                 modelObject=doc, documentSets=", ".join(sorted(ixdsDocDirs)))
         ixTargetUsage = val.authParam["ixTargetUsage"]
+        styleIxHiddenProperty = val.authParam.get("styleIxHiddenProperty")
+        if styleIxHiddenProperty:
+            styleIxHiddenPattern = re.compile(rf"(.*[^\w]|^){styleIxHiddenProperty}\s*:\s*([\w.-]+).*")
         if modelDocument.type in (ModelDocument.Type.INLINEXBRL, ModelDocument.Type.INLINEXBRLDOCUMENTSET, ModelDocument.Type.UnknownXML):
             hiddenEltIds = {}
             presentedHiddenEltIds = defaultdict(list)
@@ -272,7 +292,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                     elt = cast(Any, uncast_elt)
 
                     eltTag = elt.tag
-                    if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction, EntityBase)):
+                    if isinstance(elt, (_Comment, _ElementTree, _Entity, _ProcessingInstruction)):
                         continue # comment or other non-parsed element
                     else:
                         eltTag = elt.tag
@@ -283,16 +303,13 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                                 if xmlLang:
                                     reportXmlLang = xmlLang
                                     firstRootmostXmlLangDepth = depth
-                        if ((eltTag in ("object", "script")) or
-                            (eltTag == "a" and "javascript:" in elt.get("href","")) or
-                            (eltTag == "img" and "javascript:" in elt.get("src","")) or
-                            (hasEventHandlerAttributes(elt))):
+                        if containsScriptMarkers(elt):
                             modelXbrl.error(f"{contentOtherThanXHTMLGuidance}.executableCodePresent",
                                 _("Inline XBRL documents MUST NOT contain executable code: %(element)s"),
                                 modelObject=elt, element=eltTag)
                         elif eltTag == "img":
                             src = elt.get("src","").strip()
-                            if scheme(src) in ("http", "https", "ftp"):
+                            if isExternalUrl(src):
                                 modelXbrl.error("ESEF.4.1.6.xHTMLDocumentContainsExternalReferences" if val.unconsolidated
                                                 else "ESEF.3.5.1.inlineXbrlDocumentContainsExternalReferences",
                                     _("Inline XBRL instance documents MUST NOT contain any reference pointing to resources outside the reporting package: %(element)s"),
@@ -350,7 +367,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                         #    or to other sections of the annual financial report.'''
                         #elif eltTag == "a":
                         #    href = elt.get("href","").strip()
-                        #    if scheme(href) in ("http", "https", "ftp"):
+                        #    if isExternalUrl(href):
                         #        modelXbrl.error("ESEF.4.1.6.xHTMLDocumentContainsExternalReferences" if val.unconsolidated
                         #                        else "ESEF.3.5.1.inlineXbrlDocumentContainsExternalReferences",
                         #            _("Inline XBRL instance documents MUST NOT contain any reference pointing to resources outside the reporting package: %(element)s"),
@@ -367,7 +384,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                                     modelObject=elt, element=eltTag)
                             elif len(modelXbrl.ixdsHtmlElements) > 1:
                                 _file = elt.get("href")
-                                if not _file or isHttpUrl(_file) or os.path.isabs(_file):
+                                if not _file or isHttpUrl(_file) or isLegacyAbs(_file):
                                     modelXbrl.warning("ESEF.2.5.4.externalCssReportPackage",
                                         _("The CSS file should be physically stored within the report package: %{file}s."),
                                         modelObject=elt, file=_file)
@@ -424,7 +441,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                                 hiddenEltIds[ixElt.id] = ixElt
                             ixHiddenFacts.add(ixElt)
                 # maliciously hidden facts
-                for cssHiddenElt in ixdsHtmlRootElt.getroottree().iterfind("//{http://www.w3.org/1999/xhtml}*[@style]"):
+                for cssHiddenElt in ixdsHtmlRootElt.getroottree().iterfind(".//{http://www.w3.org/1999/xhtml}*[@style]"):
                     if styleCssHiddenPattern.match(cssHiddenElt.get("style","")):
                         for tag in (ixNStag + "nonNumeric", ixNStag+"nonFraction"):
                             for ixElt in cssHiddenElt.iterdescendants(tag=tag):
@@ -446,17 +463,18 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                     modelObject=eligibleForTransformHiddenFacts,
                     countEligible=len(eligibleForTransformHiddenFacts),
                     elements=", ".join(sorted(set(str(f.qname) for f in eligibleForTransformHiddenFacts))))
-            for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
-                for ixElt in ixdsHtmlRootElt.getroottree().iterfind("//{http://www.w3.org/1999/xhtml}*[@style]"):
-                    hiddenFactRefMatch = styleIxHiddenPattern.match(ixElt.get("style",""))
-                    if hiddenFactRefMatch:
-                        hiddenFactRef = hiddenFactRefMatch.group(2)
-                        if hiddenFactRef not in hiddenEltIds:
-                            modelXbrl.error("ESEF.2.4.1.esefIxHiddenStyleNotLinkingFactInHiddenSection",
-                                _("\"-esef-ix-hidden\" style identifies id attribute of a fact that is not in ix:hidden section: %(factId)s"),
-                                modelObject=ixElt, factId=hiddenFactRef)
-                        else:
-                            presentedHiddenEltIds[hiddenFactRef].append(ixElt)
+            if styleIxHiddenProperty:
+                for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
+                    for ixElt in ixdsHtmlRootElt.getroottree().iterfind(".//{http://www.w3.org/1999/xhtml}*[@style]"):
+                        hiddenFactRefMatch = styleIxHiddenPattern.match(ixElt.get("style",""))
+                        if hiddenFactRefMatch:
+                            hiddenFactRef = hiddenFactRefMatch.group(2)
+                            if hiddenFactRef not in hiddenEltIds:
+                                modelXbrl.error("ESEF.2.4.1.esefIxHiddenStyleNotLinkingFactInHiddenSection",
+                                    _("\"%(styleIxHiddenProperty)s\" style identifies id attribute of a fact that is not in ix:hidden section: %(factId)s"),
+                                    modelObject=ixElt, styleIxHiddenProperty=styleIxHiddenProperty, factId=hiddenFactRef)
+                            else:
+                                presentedHiddenEltIds[hiddenFactRef].append(ixElt)
             for hiddenEltId, ixElt in hiddenEltIds.items():
                 if (hiddenEltId not in presentedHiddenEltIds and
                     getattr(ixElt, "xValid", 0) >= VALID and # may not be validated
@@ -514,11 +532,11 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
         if contextsWithDisallowedOCEs:
             modelXbrl.error("ESEF.2.1.3.segmentUsed",
                 _("xbrli:segment container MUST NOT be used in contexts: %(contextIds)s"),
-                modelObject=contextsWithDisallowedOCEs, contextIds=", ".join(c.id for c in contextsWithDisallowedOCEs))
+                modelObject=contextsWithDisallowedOCEs, contextIds=", ".join(c.id for c in contextsWithDisallowedOCEs if c.id is not None))
         if contextsWithDisallowedOCEcontent:
             modelXbrl.error("ESEF.2.1.3.scenarioContainsNonDimensionalContent",
                 _("xbrli:scenario in contexts MUST NOT contain any other content than defined in XBRL Dimensions specification: %(contextIds)s"),
-                modelObject=contextsWithDisallowedOCEcontent, contextIds=", ".join(c.id for c in contextsWithDisallowedOCEcontent))
+                modelObject=contextsWithDisallowedOCEcontent, contextIds=", ".join(c.id for c in contextsWithDisallowedOCEcontent if c.id is not None))
         if len(contextIdentifiers) > 1:
             modelXbrl.error("ESEF.2.1.4.multipleIdentifiers",
                 _("All entity identifiers in contexts MUST have identical content: %(contextIds)s"),
@@ -551,27 +569,17 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
         # identify unique contexts and units
         mapContext = {}
         mapUnit = {}
-        uniqueContextHashes: dict[Any, Any] = {}
-        for context in modelXbrl.contexts.values():
-            h = context.contextDimAwareHash
-            if h in uniqueContextHashes:
-                if context.isEqualTo(uniqueContextHashes[h]):
-                    mapContext[context] = uniqueContextHashes[h]
-            else:
-                uniqueContextHashes[h] = context
-        del uniqueContextHashes
-        uniqueUnitHashes: dict[Any, Any] = {}
+        for exemplar_context, *contexts in partitionModelXbrlContexts(modelXbrl).values():
+            for context in contexts:
+                mapContext[context] = exemplar_context
         utrValidator = ValidateUtr(modelXbrl)
         utrUnitIds = set(u.unitId
                          for unitItemType in utrValidator.utrItemTypeEntries.values()
                          for u in unitItemType.values())
+        for exemplar_unit, *units in partitionModelXbrlUnits(modelXbrl).values():
+            for unit in units:
+                mapUnit[unit] = exemplar_unit
         for unit in modelXbrl.units.values():
-            h = unit.hash
-            if h in uniqueUnitHashes:
-                if unit.isEqualTo(uniqueUnitHashes[h]):
-                    mapUnit[unit] = uniqueUnitHashes[h]
-            else:
-                uniqueUnitHashes[h] = unit
             # check if any custom measure is in UTR
             for measureTerm in unit.measures:
                 for measure in measureTerm:
@@ -581,7 +589,6 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                             modelXbrl.warning("ESEF.RTS.III.1.G1-7-1.customUnitInUtr",
                                 _("Custom measure SHOULD NOT duplicate a UnitID of UTR: %(measure)s"),
                                 modelObject=unit, measure=measure)
-        del uniqueUnitHashes
 
         reportedMandatory: set[QName] = set()
         precisionFacts = set()
@@ -726,12 +733,12 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 _("The xlink:role attribute of a link:footnote and link:footnoteLink element as well as xlink:arcrole attribute of a link:footnoteArc MUST be defined in the XBRL Specification 2.1."),
                 modelObject=footnoteRoleErrors)
 
-        nonStdFootnoteElts = list()
+        nonStdFootnoteElts: list[_Element] = list()
         for modelLink in modelXbrl.baseSets[("XBRL-footnotes",None,None,None)]:
             for uncast_elt in modelLink.iterchildren():
                 elt = cast(Any, uncast_elt)
 
-                if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction)):
+                if isinstance(elt, (_Comment, _ElementTree, _Entity, _ProcessingInstruction)):
                     continue # comment or other non-parsed element
                 if elt.qname not in FOOTNOTE_LINK_CHILDREN:
                     nonStdFootnoteElts.append(elt)
@@ -763,7 +770,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
 
         if not hasOutdatedUrl and not any(e in val.extensionImportedUrls for e in val.authParam["effectiveTaxonomyURLs"]):
             val.modelXbrl.error(
-                "UKFRC22.1.requiredUksefEntryPointNotImported" if val.authority == "UKFRC" else
+                "UKFRC22.1.requiredUksefEntryPointNotImported" if val.authority and val.authority.startswith("UKFRC") else
                 "ESEF.3.1.2.requiredEntryPointNotImported",
                 _("The issuer's extension taxonomies MUST import the entry point of the taxonomy files prepared by %(authority)s."),
                 modelObject=modelDocument, authority=val.authParam["authorityName"])
@@ -790,9 +797,25 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                             unreportedLbElts.add(to)
                     elif arcrole in (hc_all, domainMember, dimensionDomain):
                         # all primary items
-                        if fr is not None and not fr.isAbstract and rel.isUsable and fr not in conceptsUsed and isExtension(val, rel) and not fr.type.isDomainItemType:
-                            unreportedLbElts.add(to)
-                        if to is not None and not to.isAbstract and rel.isUsable and to not in conceptsUsed and isExtension(val, rel) and not to.type.isDomainItemType:
+                        if (
+                            fr is not None
+                            and fr.type is not None
+                            and not fr.isAbstract
+                            and rel.isUsable
+                            and fr not in conceptsUsed
+                            and isExtension(val, rel)
+                            and not fr.type.isDomainItemType
+                        ):
+                            unreportedLbElts.add(fr)
+                        if (
+                            to is not None
+                            and to.type is not None
+                            and not to.isAbstract
+                            and rel.isUsable
+                            and to not in conceptsUsed
+                            and isExtension(val, rel)
+                            and not to.type.isDomainItemType
+                        ):
                             unreportedLbElts.add(to)
                     reportedEltsNotInLb.discard(fr)
                     reportedEltsNotInLb.discard(to)