prov 2.2.0__tar.gz → 2.3.0__tar.gz

{prov-2.2.0/src/prov.egg-info → prov-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prov
-Version: 2.2.0
+Version: 2.3.0
 Summary: A library for W3C Provenance Data Model supporting PROV-JSON, PROV-XML and PROV-O (RDF)
 Author-email: Trung Dong Huynh <trungdong@donggiang.com>
 License-Expression: MIT
@@ -16,7 +16,6 @@ Classifier: Intended Audience :: Information Technology
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -28,14 +27,14 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Security
 Classifier: Topic :: System :: Logging
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: networkx>=2.0
 Requires-Dist: pydot>=1.2.0
 Requires-Dist: python-dateutil>=2.2
 Provides-Extra: rdf
-Requires-Dist: rdflib<7,>=4.2.1; extra == "rdf"
+Requires-Dist: rdflib<8,>=6.0.0; extra == "rdf"
 Provides-Extra: xml
 Requires-Dist: lxml>=3.3.5; extra == "xml"
 Provides-Extra: plot
@@ -99,3 +98,11 @@ The library is undergoing a staged modernisation (tooling, type hints, tests,
 documentation, standards conformance), a batch of bug fixes, and new format support.
 See `ROADMAP.md <ROADMAP.md>`_ for the plan and the 2.x API-stability promise.
 Feedback is welcome on the `issue tracker <https://github.com/trungdong/prov/issues>`_.
+
+
+Supported versions
+-------------------
+
+Only the latest 2.x release is supported; 1.x and earlier no longer receive
+fixes. See `SECURITY.md <SECURITY.md>`_ for the full support table and how to
+report a vulnerability.

{prov-2.2.0 → prov-2.3.0}/README.rst

@@ -55,3 +55,11 @@ The library is undergoing a staged modernisation (tooling, type hints, tests,
 documentation, standards conformance), a batch of bug fixes, and new format support.
 See `ROADMAP.md <ROADMAP.md>`_ for the plan and the 2.x API-stability promise.
 Feedback is welcome on the `issue tracker <https://github.com/trungdong/prov/issues>`_.
+
+
+Supported versions
+-------------------
+
+Only the latest 2.x release is supported; 1.x and earlier no longer receive
+fixes. See `SECURITY.md <SECURITY.md>`_ for the full support table and how to
+report a vulnerability.

{prov-2.2.0 → prov-2.3.0}/pyproject.toml

@@ -16,7 +16,6 @@ classifiers = [
     "Natural Language :: English",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -29,7 +28,7 @@ classifiers = [
     "Topic :: Security",
     "Topic :: System :: Logging",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 dependencies = [
     "networkx>=2.0",
     # Supporting graphic outputs (e.g. PNG, SVG, PDF) - a local graphviz is required
@@ -39,7 +38,7 @@ dependencies = [
 
 [project.optional-dependencies]
 rdf = [
-    "rdflib>=4.2.1,<7",
+    "rdflib>=6.0.0,<8",
 ]
 xml = [
     "lxml>=3.3.5",
@@ -67,6 +66,7 @@ build-backend = "setuptools.build_meta"
 version = {attr = "prov.__version__"}
 
 [tool.setuptools.package-data]
+prov = ["py.typed"]
 "prov.tests" = [
     "json/*.json",
     "xml/*.xml",
@@ -77,7 +77,6 @@ version = {attr = "prov.__version__"}
 
 [dependency-groups]
 dev = [
-    "bumpversion>=0.6.0",
     "coverage>=7.6.10",
     "lxml-stubs>=0.5.1",
     "mypy>=1.19.1",
@@ -85,18 +84,29 @@ dev = [
     "pytest>=8.4.2",
     "pytest-cov>=7.1.0",
     "ruff>=0.15.20",
-    "setuptools>=75.8.0",
-    "sphinx>=8.1.3; python_version >= '3.11'",
-    "sphinx-rtd-theme",
-    "tox>=4.23.2",
     "types-networkx>=3.4.2.20250509",
     "types-python-dateutil>=2.9.0.20260124",
-    "wheel>=0.45.1",
 ]
+docs = [
+    "sphinx>=8.1.3,<9",
+    "sphinx-rtd-theme",
+]
+
+[tool.uv]
+# numpy is a transitive typing dependency (via types-networkx/matplotlib), not
+# something prov imports itself. numpy 2.5 switched its inline stubs to
+# unconditional PEP 695 `type` statements, which mypy refuses to parse once
+# `[tool.mypy] python_version` is below 3.12 (see below) regardless of the
+# interpreter actually running mypy. Cap it below that until numpy's stubs
+# gate the new syntax on `python_version`, or this project's mypy floor rises
+# to 3.12. If a Dependabot bump of matplotlib or types-networkx ever fails to
+# resolve, this pin is the likely cause: lift it, run `uv run mypy src`, and
+# keep it lifted only if mypy stays green.
+constraint-dependencies = ["numpy<2.5"]
 
 [tool.ruff]
 line-length = 88
-target-version = "py39"
+target-version = "py310"
 extend-exclude = ["build"]  # dist/.eggs are already in ruff's default excludes
 
 [tool.ruff.lint]
@@ -105,20 +115,20 @@ select = [
     "F",   # pyflakes
     "W",   # pycodestyle warnings
     "B",   # flake8-bugbear
-    "UP",  # pyupgrade (3.9-safe)
+    "C4",  # flake8-comprehensions
+    "I",   # isort (import sorting)
+    "SIM", # flake8-simplify
+    "UP",  # pyupgrade (3.10-safe)
+    "RUF", # ruff-specific rules
 ]
 ignore = [
     "E203",  # whitespace before ':' (black/ruff-format compatible)
     "E501",  # line length handled by the formatter
-    # These two pyupgrade rules only offer *unsafe* fixes when targeting py39
-    # (ruff can't prove nothing relies on runtime evaluation of the old
-    # syntax, e.g. via typing.get_type_hints()), so they fire on almost every
-    # annotated/`%`-formatted line in the project without an autofix.
-    # Deferred to a dedicated follow-up rather than mass hand-editing here.
-    "UP045",  # non-pep604-annotation-optional (`Optional[X]` -> `X | None`)
-    "UP031",  # printf-string-formatting (`%` -> `.format()`/f-string)
 ]
 
+[tool.ruff.lint.isort]
+combine-as-imports = true  # keep multi-name `X as X` re-export blocks compact
+
 [tool.ruff.lint.per-file-ignores]
 # These modules intentionally re-export everything from another module with
 # `import *`; pyflakes can't tell which of the resulting names are "used".
@@ -143,47 +153,29 @@ python_classes = []
 [tool.coverage.run]
 branch = true
 source = ["prov"]
-omit = ["*/tests*"]
-
-[tool.coverage.paths]
-source = [
-    "src/prov",
-    ".tox/*/lib/python*/site-packages/prov",
-    ".tox/pypy*/site-packages/prov",
-]
+omit = ["*/prov/tests/*"]
 
 [tool.coverage.report]
+# Coverage ratchet (docs/test-gap-checklist.md). T13 fixed the `omit` glob
+# above (it previously did not exclude src/prov/tests/, inflating TOTAL by
+# ~3.8pt with near-fully-covered test code) and closed the remaining
+# checklist gaps; the honest package-only TOTAL measured after that work is
+# 97.42%, rounded down to this floor. Never lower without a documented
+# reason. Remaining misses are individually annotated as "defer" in the
+# checklist (dead/defensive branches unreachable via the public API, plus
+# the matplotlib-requiring interactive plot() path not installed in the
+# test env).
+fail_under = 97
 exclude_lines = [
     "pragma: no cover",
     "def __repr__",
     "raise AssertionError",
     "raise NotImplementedError",
     "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
 ]
 
 [tool.mypy]
-python_version = "3.12"
+python_version = "3.10"
+strict = true
 exclude = ["^src/prov/tests/"]
-
-[[tool.mypy.overrides]]
-module = "prov.*"
-disallow_untyped_defs = true
-check_untyped_defs = true
-
-[[tool.mypy.overrides]]
-# rdflib ships its own inline types (py.typed) that are far stricter than
-# this module's historic behaviour of freely mixing rdflib term types
-# (URIRef/BNode/Literal/Node) with prov.model's QualifiedName/str
-# identifiers at runtime -- which works correctly (see the RDF round-trip
-# tests in prov.tests.test_rdf). Untangling that is a real typing refactor,
-# deferred to a follow-up; suppress the resulting noise for this module only
-# rather than scatter dozens of individually-justified ignores.
-module = "prov.serializers.provrdf"
-disable_error_code = ["arg-type", "assignment", "operator", "index"]
-
-[[tool.mypy.overrides]]
-# pydot.Dot.create() is annotated to return `str`, but its own docstring
-# says (and it actually does, for binary Graphviz formats) return `bytes`;
-# this is an inaccuracy in pydot's stub, not a bug in this module.
-module = "prov.scripts.convert"
-disable_error_code = ["arg-type"]

{prov-2.2.0 → prov-2.3.0}/src/prov/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations  # needed for | type annotations in Python < 3.10
+
 import os
 from typing import TYPE_CHECKING
 
@@ -7,7 +8,7 @@ if TYPE_CHECKING:
 
 __author__ = "Trung Dong Huynh"
 __email__ = "trungdong@donggiang.com"
-__version__ = "2.2.0"
+__version__ = "2.3.0"
 
 __all__ = ["Error", "model", "read"]
 
@@ -19,7 +20,7 @@ class Error(Exception):
 
 
 def read(
-    source: str | bytes | os.PathLike, format: str | None = None
+    source: str | bytes | os.PathLike[str], format: str | None = None
 ) -> ProvDocument | None:
     """
     Convenience function returning a ProvDocument instance.
@@ -35,7 +36,6 @@ def read(
     """
     # Lazy imports to not globber the namespace.
     from prov.model import ProvDocument
-
     from prov.serializers import Registry
 
     Registry.load_serializers()

{prov-2.2.0 → prov-2.3.0}/src/prov/constants.py

@@ -166,17 +166,16 @@ PROV_ATTRIBUTE_LITERALS = {PROV_ATTR_TIME, PROV_ATTR_STARTTIME, PROV_ATTR_ENDTIM
 
 # Set of formal attributes of PROV records
 PROV_ATTRIBUTES = PROV_ATTRIBUTE_QNAMES | PROV_ATTRIBUTE_LITERALS
-PROV_RECORD_ATTRIBUTES = list((attr, str(attr)) for attr in PROV_ATTRIBUTES)
-
-PROV_RECORD_IDS_MAP = dict(
-    (PROV_N_MAP[rec_type_id], rec_type_id) for rec_type_id in PROV_N_MAP
-)
-PROV_ID_ATTRIBUTES_MAP = dict(
-    (prov_id, attribute) for (prov_id, attribute) in PROV_RECORD_ATTRIBUTES
-)
-PROV_ATTRIBUTES_ID_MAP = dict(
-    (attribute, prov_id) for (prov_id, attribute) in PROV_RECORD_ATTRIBUTES
-)
+PROV_RECORD_ATTRIBUTES = [(attr, str(attr)) for attr in PROV_ATTRIBUTES]
+
+PROV_RECORD_IDS_MAP = {
+    PROV_N_MAP[rec_type_id]: rec_type_id for rec_type_id in PROV_N_MAP
+}
+PROV_ID_ATTRIBUTES_MAP = dict(PROV_RECORD_ATTRIBUTES)
+# inverse of PROV_ID_ATTRIBUTES_MAP: maps each attribute name back to its QName
+PROV_ATTRIBUTES_ID_MAP = {
+    attribute: prov_id for (prov_id, attribute) in PROV_RECORD_ATTRIBUTES
+}
 
 # Extra definition for convenience
 PROV_TYPE = PROV["type"]

{prov-2.2.0 → prov-2.3.0}/src/prov/dot.py

@@ -13,44 +13,46 @@ References:
 """
 
 from __future__ import annotations  # needed for | type annotations in Python < 3.10
+
 from datetime import datetime
 from html import escape
-from typing import Any, Optional
+from typing import Any
+
+import pydot
 
 from prov.graph import INFERRED_ELEMENT_CLASS
 from prov.identifier import QualifiedName
 from prov.model import (
-    ProvEntity,
-    ProvActivity,
-    ProvAgent,
-    ProvBundle,
     PROV_ACTIVITY,
     PROV_AGENT,
     PROV_ALTERNATE,
     PROV_ASSOCIATION,
+    PROV_ATTRIBUTE_QNAMES,
     PROV_ATTRIBUTION,
     PROV_BUNDLE,
     PROV_COMMUNICATION,
-    PROV_DERIVATION,
     PROV_DELEGATION,
+    PROV_DERIVATION,
+    PROV_END,
     PROV_ENTITY,
     PROV_GENERATION,
     PROV_INFLUENCE,
     PROV_INVALIDATION,
-    PROV_END,
     PROV_MEMBERSHIP,
     PROV_MENTION,
     PROV_SPECIALIZATION,
     PROV_START,
     PROV_USAGE,
     Identifier,
-    PROV_ATTRIBUTE_QNAMES,
-    sorted_attributes,
+    ProvActivity,
+    ProvAgent,
+    ProvBundle,
+    ProvElement,
+    ProvEntity,
     ProvException,
     ProvRecord,
-    ProvElement,
+    sorted_attributes,
 )
-import pydot  # type: ignore[import]
 
 __author__ = "Trung Dong Huynh"
 __email__ = "trungdong@donggiang.com"
@@ -89,7 +91,7 @@ GENERIC_NODE_STYLE = {
         "fillcolor": "lightgray",
         "color": "dimgray",
     },
-}  # type: dict[Optional[type[ProvElement | ProvBundle]], dict[str, Any]]
+}  # type: dict[type[ProvElement | ProvBundle] | None, dict[str, Any]]
 # Value type is widened to Any (rather than str) because mypy treats a
 # dict[str, str] unpacked via `**style` as needing to satisfy *every*
 # named parameter pydot.Node/Edge/Cluster declare (e.g. `obj_dict`), not
@@ -180,7 +182,7 @@ ANNOTATION_END_ROW = "    </TABLE>>"
 def htlm_link_if_uri(value: Any) -> str:
     try:
         uri = value.uri
-        return '<a href="%s">%s</a>' % (uri, str(value))
+        return f'<a href="{uri}">{value!s}</a>'
     except AttributeError:
         return str(value)
 
@@ -220,11 +222,11 @@ def prov_to_dot(
     def _bundle_to_dot(dot: pydot.Dot | pydot.Cluster, bundle: ProvBundle) -> None:
         def _attach_attribute_annotation(node: pydot.Node, record: ProvRecord) -> None:
             # Adding a node to show all attributes
-            attributes = list(
+            attributes = [
                 (attr_name, value)
                 for attr_name, value in record.attributes
                 if attr_name not in PROV_ATTRIBUTE_QNAMES
-            )
+            ]
 
             if not attributes:
                 return  # No attribute to display
@@ -238,7 +240,7 @@ def prov_to_dot(
                 % (
                     attr.uri,
                     escape(str(attr)),
-                    ' href="%s"' % value.uri if isinstance(value, Identifier) else "",
+                    f' href="{value.uri}"' if isinstance(value, Identifier) else "",
                     escape(
                         str(value)
                         if not isinstance(value, datetime)
@@ -250,7 +252,7 @@ def prov_to_dot(
             ann_rows.append(ANNOTATION_END_ROW)
             count[3] += 1
             annotations = pydot.Node(
-                "ann%d" % count[3], label="\n".join(ann_rows), **ANNOTATION_STYLE
+                f"ann{count[3]}", label="\n".join(ann_rows), **ANNOTATION_STYLE
             )
             dot.add_node(annotations)
             dot.add_edge(pydot.Edge(annotations, node, **ANNOTATION_LINK_STYLE))
@@ -258,13 +260,13 @@ def prov_to_dot(
         def _add_bundle(bundle: ProvBundle) -> pydot.Cluster:
             count[2] += 1
             subdot = pydot.Cluster(
-                graph_name="c%d" % count[2],
+                graph_name=f"c{count[2]}",
                 URL=f'"{bundle.identifier.uri}"',  # type: ignore[union-attr]
             )
             # set_label is generated at runtime by pydot via setattr() for
             # every Graphviz attribute (see pydot.core.__generate_attribute_methods),
             # so it exists on Cluster instances but isn't visible to mypy.
-            subdot.set_label('"%s"' % str(bundle.identifier))  # type: ignore[attr-defined]
+            subdot.set_label(f'"{bundle.identifier!s}"')  # type: ignore[attr-defined]
             _bundle_to_dot(subdot, bundle)
             # pydot types Graph.add_subgraph() as accepting only a Subgraph,
             # but Cluster (a Graph subclass, not a Subgraph subclass) is the
@@ -274,7 +276,7 @@ def prov_to_dot(
 
         def _add_node(record: ProvRecord) -> pydot.Node:
             count[0] += 1
-            node_id = "n%d" % count[0]
+            node_id = f"n{count[0]}"
             if use_labels:
                 if record.label == record.identifier:
                     node_label = f'"{record.label}"'
@@ -292,7 +294,7 @@ def prov_to_dot(
 
             uri = record.identifier.uri  # type: ignore[union-attr]
             style = DOT_PROV_STYLE[record.get_type()]
-            node = pydot.Node(node_id, label=node_label, URL='"%s"' % uri, **style)
+            node = pydot.Node(node_id, label=node_label, URL=f'"{uri}"', **style)
             node_map[uri] = node
             dot.add_node(node)
 
@@ -301,29 +303,29 @@ def prov_to_dot(
             return node
 
         def _add_generic_node(
-            qname: QualifiedName, prov_type: Optional[type[ProvElement]] = None
+            qname: QualifiedName, prov_type: type[ProvElement] | None = None
         ) -> pydot.Node:
             count[0] += 1
-            node_id = "n%d" % count[0]
+            node_id = f"n{count[0]}"
             node_label = f'"{qname}"'
 
             uri = qname.uri
             style = GENERIC_NODE_STYLE[prov_type] if prov_type else DOT_PROV_STYLE[0]
-            node = pydot.Node(node_id, label=node_label, URL='"%s"' % uri, **style)
+            node = pydot.Node(node_id, label=node_label, URL=f'"{uri}"', **style)
             node_map[uri] = node
             dot.add_node(node)
             return node
 
         def _get_bnode() -> pydot.Node:
             count[1] += 1
-            bnode_id = "b%d" % count[1]
+            bnode_id = f"b{count[1]}"
             bnode = pydot.Node(bnode_id, label='""', shape="point", color="gray")
             dot.add_node(bnode)
             return bnode
 
         def _get_node(
-            qname: Optional[QualifiedName],
-            prov_type: Optional[type[ProvElement]] = None,
+            qname: QualifiedName | None,
+            prov_type: type[ProvElement] | None = None,
         ) -> pydot.Node:
             if qname is None:
                 return _get_bnode()
@@ -358,7 +360,8 @@ def prov_to_dot(
                     (attr_name, value)
                     for attr_name, value in rec.formal_attributes
                     if attr_name in PROV_ATTRIBUTE_QNAMES
-                )
+                ),
+                strict=False,
             )
             inferred_types = list(map(INFERRED_ELEMENT_CLASS.get, attr_names))
             other_attributes = [
@@ -395,7 +398,7 @@ def prov_to_dot(
                     style["color"] = "gray"  # all remaining segment to be gray
                     style["fontcolor"] = "dimgray"  # text in darker gray
                     for attr_name, node, inferred_type in zip(
-                        attr_names[2:], nodes[2:], inferred_types[2:]
+                        attr_names[2:], nodes[2:], inferred_types[2:], strict=False
                     ):
                         if node is not None:
                             style["label"] = attr_name.localpart

{prov-2.2.0 → prov-2.3.0}/src/prov/graph.py

@@ -1,32 +1,38 @@
+from __future__ import annotations
+
+from typing import Any
+
 import networkx as nx
+
+from prov.identifier import QualifiedName
 from prov.model import (
-    ProvDocument,
-    ProvRecord,
-    ProvElement,
-    ProvEntity,
-    ProvActivity,
-    ProvAgent,
-    ProvRelation,
-    PROV_ATTR_ENTITY,
     PROV_ATTR_ACTIVITY,
     PROV_ATTR_AGENT,
-    PROV_ATTR_TRIGGER,
-    PROV_ATTR_GENERATED_ENTITY,
-    PROV_ATTR_USED_ENTITY,
-    PROV_ATTR_DELEGATE,
-    PROV_ATTR_RESPONSIBLE,
-    PROV_ATTR_SPECIFIC_ENTITY,
-    PROV_ATTR_GENERAL_ENTITY,
     PROV_ATTR_ALTERNATE1,
     PROV_ATTR_ALTERNATE2,
+    PROV_ATTR_BUNDLE,
     PROV_ATTR_COLLECTION,
-    PROV_ATTR_INFORMED,
+    PROV_ATTR_DELEGATE,
+    PROV_ATTR_ENDER,
+    PROV_ATTR_ENTITY,
+    PROV_ATTR_GENERAL_ENTITY,
+    PROV_ATTR_GENERATED_ENTITY,
     PROV_ATTR_INFORMANT,
-    PROV_ATTR_BUNDLE,
+    PROV_ATTR_INFORMED,
     PROV_ATTR_PLAN,
-    PROV_ATTR_ENDER,
+    PROV_ATTR_RESPONSIBLE,
+    PROV_ATTR_SPECIFIC_ENTITY,
     PROV_ATTR_STARTER,
+    PROV_ATTR_TRIGGER,
+    PROV_ATTR_USED_ENTITY,
+    ProvActivity,
+    ProvAgent,
     ProvBundle,
+    ProvDocument,
+    ProvElement,
+    ProvEntity,
+    ProvRecord,
+    ProvRelation,
 )
 
 __author__ = "Trung Dong Huynh"
@@ -56,7 +62,7 @@ INFERRED_ELEMENT_CLASS = {
 }
 
 
-def prov_to_graph(prov_document: ProvDocument) -> nx.MultiDiGraph:
+def prov_to_graph(prov_document: ProvDocument) -> nx.MultiDiGraph[Any]:
     """
     Convert a :class:`~prov.model.ProvDocument` to a `MultiDiGraph
     <https://networkx.github.io/documentation/stable/reference/classes/multidigraph.html>`_
@@ -64,9 +70,9 @@ def prov_to_graph(prov_document: ProvDocument) -> nx.MultiDiGraph:
 
     :param prov_document: The :class:`~prov.model.ProvDocument` instance to convert.
     """
-    g = nx.MultiDiGraph()  # type: nx.MultiDiGraph
+    g: nx.MultiDiGraph[Any] = nx.MultiDiGraph()
     unified = prov_document.unified()
-    node_map = dict()
+    node_map: dict[QualifiedName | None, ProvRecord] = {}
     for element in unified.get_records(ProvElement):
         g.add_node(element)
         node_map[element.identifier] = element
@@ -89,7 +95,7 @@ def prov_to_graph(prov_document: ProvDocument) -> nx.MultiDiGraph:
     return g
 
 
-def graph_to_prov(g: nx.MultiDiGraph) -> ProvDocument:
+def graph_to_prov(g: nx.MultiDiGraph[Any]) -> ProvDocument:
     """
     Convert a `MultiDiGraph
     <https://networkx.github.io/documentation/stable/reference/classes/multidigraph.html>`_

{prov-2.2.0 → prov-2.3.0}/src/prov/identifier.py

@@ -1,4 +1,5 @@
 from __future__ import annotations  # needed for | type annotations in Python < 3.10
+
 from typing import Any
 
 __author__ = "Trung Dong Huynh"
@@ -39,7 +40,7 @@ class Identifier:
         return hash((self.uri, self.__class__))
 
     def __repr__(self) -> str:
-        return "<%s: %s>" % (self.__class__.__name__, self._uri)
+        return f"<{self.__class__.__name__}: {self._uri}>"
 
     def provn_representation(self) -> str:
         """
@@ -48,7 +49,7 @@ class Identifier:
         Returns:
             str: The PROV-N representation of the URI.
         """
-        return '"%s" %%%% xsd:anyURI' % self._uri
+        return f'"{self._uri}" %% xsd:anyURI'
 
 
 class QualifiedName(Identifier):
@@ -94,14 +95,14 @@ class QualifiedName(Identifier):
         return self._str
 
     def __repr__(self) -> str:
-        return "<%s: %s>" % (self.__class__.__name__, self._str)
+        return f"<{self.__class__.__name__}: {self._str}>"
 
     def __hash__(self) -> int:
         return hash(self.uri)
 
     def provn_representation(self) -> str:
         """PROV-N representation of qualified name in a string."""
-        return "'%s'" % self._str
+        return f"'{self._str}'"
 
 
 class Namespace:
@@ -118,7 +119,7 @@ class Namespace:
             raise ValueError("Not a valid URI to create a namespace.")
         self._prefix = prefix
         self._uri = uri
-        self._cache: dict[str, QualifiedName] = dict()
+        self._cache: dict[str, QualifiedName] = {}
 
     @property
     def uri(self) -> str:
@@ -180,7 +181,7 @@ class Namespace:
         return hash((self._uri, self._prefix))
 
     def __repr__(self) -> str:
-        return "<%s: %s {%s}>" % (self.__class__.__name__, self._prefix, self._uri)
+        return f"<{self.__class__.__name__}: {self._prefix} {{{self._uri}}}>"
 
     def __getitem__(self, localpart: str) -> QualifiedName:
         if localpart in self._cache: