ansys-units 0.12.dev0__tar.gz → 0.13.dev0__tar.gz

{ansys_units-0.12.dev0 → ansys_units-0.13.dev0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: ansys-units
-Version: 0.12.dev0
+Version: 0.13.dev0
 Summary: Pythonic interface for units, unit systems, and unit conversions.
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Requires-Python: >=3.10,<3.15
 Description-Content-Type: text/x-rst
+License-Expression: MIT
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 License-File: LICENSE
@@ -21,20 +21,21 @@ Requires-Dist: pandas>=2.2,<3.0 ; extra == "additional" and ( python_version < '
 Requires-Dist: pandas-stubs>=2 ; extra == "additional"
 Requires-Dist: pydantic>=2.11.7 ; extra == "additional"
 Requires-Dist: pydantic_core>=2.33.2 ; extra == "additional"
+Requires-Dist: basedpyright ; extra == "ci-types"
 Requires-Dist: matplotlib==3.10.8 ; extra == "ci-types"
 Requires-Dist: pandas>=3.0.0 ; extra == "ci-types" and ( python_version >= '3.11')
 Requires-Dist: pandas>=2.2,<3.0 ; extra == "ci-types" and ( python_version < '3.11')
 Requires-Dist: pandas-stubs>=2 ; extra == "ci-types"
 Requires-Dist: pydantic>=2.11.7 ; extra == "ci-types"
 Requires-Dist: pydantic_core>=2.33.2 ; extra == "ci-types"
-Requires-Dist: pytest==9.0.2 ; extra == "ci-types"
-Requires-Dist: pytest-cov==7.0.0 ; extra == "ci-types"
+Requires-Dist: pytest==9.0.3 ; extra == "ci-types"
+Requires-Dist: pytest-cov==7.1.0 ; extra == "ci-types"
 Requires-Dist: pytest-mock==3.15.1 ; extra == "ci-types"
 Requires-Dist: pint==0.24.4 ; extra == "ci-types"
-Requires-Dist: black==26.1.0 ; extra == "ci-types"
-Requires-Dist: ansys-sphinx-theme==1.6.4 ; extra == "doc"
+Requires-Dist: black==26.3.1 ; extra == "ci-types"
+Requires-Dist: ansys-sphinx-theme==1.7.2 ; extra == "doc"
 Requires-Dist: pdf2image==1.17.0 ; extra == "doc"
-Requires-Dist: quarto-cli==1.8.25 ; extra == "doc"
+Requires-Dist: quarto-cli==1.9.37 ; extra == "doc"
 Requires-Dist: matplotlib==3.10.8 ; extra == "doc"
 Requires-Dist: numpydoc==1.10.0 ; extra == "doc"
 Requires-Dist: Sphinx==7.4.7 ; extra == "doc"
@@ -45,8 +46,8 @@ Requires-Dist: numpy>=1.24,<3 ; extra == "tests"
 Requires-Dist: pandas>=3.0.0 ; extra == "tests" and ( python_version >= '3.11')
 Requires-Dist: pandas>=2.2,<3.0 ; extra == "tests" and ( python_version < '3.11')
 Requires-Dist: pandas-stubs>=2 ; extra == "tests"
-Requires-Dist: pytest==9.0.2 ; extra == "tests"
-Requires-Dist: pytest-cov==7.0.0 ; extra == "tests"
+Requires-Dist: pytest==9.0.3 ; extra == "tests"
+Requires-Dist: pytest-cov==7.1.0 ; extra == "tests"
 Requires-Dist: pytest-mock==3.15.1 ; extra == "tests"
 Requires-Dist: pint==0.24.4 ; extra == "tests"
 Project-URL: Documentation, https://units.docs.pyansys.com/

{ansys_units-0.12.dev0 → ansys_units-0.13.dev0}/pyproject.toml

@@ -5,48 +5,48 @@ build-backend = "flit_core.buildapi"
 [project]
 # Check https://flit.readthedocs.io/en/latest/pyproject_toml.html for all available sections
 name = "ansys-units"
-version = "0.12.dev0"
+version = "0.13.dev0"
 description = "Pythonic interface for units, unit systems, and unit conversions."
 readme = "README.rst"
 requires-python = ">=3.10,<3.15"
-license = {file = "LICENSE"}
+license = "MIT"
+license-files = ["LICENSE"]
 authors = [{name = "ANSYS, Inc.", email = "pyansys.core@ansys.com"}]
 maintainers = [{name = "ANSYS, Inc.", email = "pyansys.core@ansys.com"}]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Science/Research",
     "Topic :: Scientific/Engineering :: Information Analysis",
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3"
 ]
 
 dependencies = [
     "pyyaml>=6.0",
-    "typing-extensions>=4.5.0",
+    "typing-extensions>=4.5.0"
 ]
 
 [project.optional-dependencies]
 doc = [
-    "ansys-sphinx-theme==1.6.4",
+    "ansys-sphinx-theme==1.7.2",
     "pdf2image==1.17.0",
-    "quarto-cli==1.8.25",
+    "quarto-cli==1.9.37",
     "matplotlib==3.10.8",
     "numpydoc==1.10.0",
     "Sphinx==7.4.7",
     "sphinx-copybutton==0.5.2",
     "sphinx-gallery==0.20.0",
-    "sphinx-toggleprompt==0.6.0",
+    "sphinx-toggleprompt==0.6.0"
 ]
 tests = [
     "numpy>=1.24,<3",
     "pandas>=3.0.0; python_version >= '3.11'",
     "pandas>=2.2,<3.0; python_version < '3.11'",
     "pandas-stubs>=2",
-    "pytest==9.0.2",
-    "pytest-cov==7.0.0",
+    "pytest==9.0.3",
+    "pytest-cov==7.1.0",
     "pytest-mock==3.15.1",
-    "pint==0.24.4",
+    "pint==0.24.4"
 ]
 additional = [
     "numpy>=1.24,<3",
@@ -54,21 +54,22 @@ additional = [
     "pandas>=2.2,<3.0; python_version < '3.11'",
     "pandas-stubs>=2",
     "pydantic>=2.11.7",
-    "pydantic_core>=2.33.2",
+    "pydantic_core>=2.33.2"
 ]
 # getting versions of matplotlib and numpy that are compatible is hard so we have this for CI
 ci_types = [
+    "basedpyright",
     "matplotlib==3.10.8",
     "pandas>=3.0.0; python_version >= '3.11'",
     "pandas>=2.2,<3.0; python_version < '3.11'",
     "pandas-stubs>=2",
     "pydantic>=2.11.7",
     "pydantic_core>=2.33.2",
-    "pytest==9.0.2",
-    "pytest-cov==7.0.0",
+    "pytest==9.0.3",
+    "pytest-cov==7.1.0",
     "pytest-mock==3.15.1",
     "pint==0.24.4",
-    "black==26.1.0",
+    "black==26.3.1"
 ]
 
 [project.urls]
@@ -84,7 +85,7 @@ name = "ansys.units"
 testpaths = ["tests"]
 addopts = "-v --cov=ansys.units --cov-report html:.cov/html --cov-report xml:.cov/xml --cov-report term --durations 0 --show-capture=all"
 markers = [
-    "developer_only: tests that must not run on github",
+    "developer_only: tests that must not run on github"
 ]
 
 [tool.black]
@@ -125,4 +126,5 @@ reportUnknownMemberType = false
 reportExplicitAny = false
 reportPrivateUsage = false
 reportUnusedCallResult = false
+reportUnknownArgumentType = false
 ignore = ["doc"]

{ansys_units-0.12.dev0 → ansys_units-0.13.dev0}/src/ansys/units/_constants.py

@@ -66,6 +66,8 @@ class _DerivedUnitInfo(TypedDict):
 
 _derived_units: dict[str, _DerivedUnitInfo] = qc_data["derived_units"]
 
+_aliases: dict[str, str] = qc_data.get("aliases", {})
+
 table_path = os.path.join(file_dir, "quantity_tables/si_table.yaml")
 
 with open(table_path, "r") as table:

{ansys_units-0.12.dev0 → ansys_units-0.13.dev0}/src/ansys/units/cfg.yaml

@@ -284,3 +284,41 @@ derived_units:
   tonne:
     composition: kg
     factor: 1000
+
+# Aliases
+# -------
+# Alternative names that map to existing base or derived units.
+# Each alias resolves to its canonical unit name during parsing.
+#
+# <alias>: <canonical unit name>
+
+aliases:
+  deg: degree
+  rad: radian
+  sec: s
+  lb_mass: lbm
+  pound: lb
+  meter: m
+  metre: m
+  kilogram: kg
+  gram: g
+  second: s
+  ampere: A
+  kelvin: K
+  candela: cd
+  steradian: sr
+  newton: N
+  pascal: Pa
+  watt: W
+  joule: J
+  volt: V
+  henry: H
+  siemens: S
+  weber: Wb
+  tesla: T
+  hertz: Hz
+  liter: l
+  litre: l
+  gallon: gal
+  foot: ft
+  feet: ft

{ansys_units-0.12.dev0 → ansys_units-0.13.dev0}/src/ansys/units/extensions/pandas_extension.py

@@ -516,7 +516,7 @@ class QuantityArray(ExtensionArray):
 
     @staticmethod
     def _create_arithmetic_method(
-        op: Callable[..., Any], reflected: bool = False
+        op: Callable[[Any, Any], Any], reflected: bool = False
     ) -> Callable[..., Any]:
         """
         Create arithmetic method.

{ansys_units-0.12.dev0 → ansys_units-0.13.dev0}/src/ansys/units/unit.py

@@ -28,6 +28,7 @@ import os
 from typing import TYPE_CHECKING, Any, overload
 
 from ansys.units._constants import (
+    _aliases,
     _base_units,
     _BaseUnitInfo,
     _derived_units,
@@ -544,8 +545,13 @@ def _multiplier_check(unit_term: str) -> bool:
         ``True`` if the unit term contains a multiplier, ``False`` otherwise.
     """
     # Check if the unit term is not an existing base or derived unit.
-    return unit_term and not (
-        (unit_term in _base_units) or (unit_term in _derived_units)
+    return bool(
+        unit_term
+        and not (
+            (unit_term in _base_units)
+            or (unit_term in _derived_units)
+            or (unit_term in _aliases)
+        )
     )
 
 
@@ -638,6 +644,11 @@ def _filter_unit_term(unit_term: str) -> tuple[str, str, float]:
 
     base = unit_term
 
+    # Resolve alias to canonical unit name before multiplier detection
+    while unit_term in _aliases:
+        unit_term = _aliases[unit_term]
+    base = unit_term
+
     # strip multiplier and base from unit term
     has_multiplier = _multiplier_check(unit_term)
     if has_multiplier:

ansys_units-0.13.dev0/src/ansys/units/unit_registry.py

@@ -0,0 +1,370 @@
+# Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""Provides the ``UnitRegistry`` class and instance-scoped unit registration."""
+
+from collections.abc import Generator, Mapping, Sequence
+import math
+import os
+from typing import TYPE_CHECKING, Any
+
+import yaml
+
+from ansys.units._constants import (
+    _BaseUnitInfo,
+)
+from ansys.units._constants import (
+    _DerivedUnitInfo,
+)
+from ansys.units._constants import _aliases as _CONST_ALIASES
+from ansys.units._constants import _base_units as _CONST_BASE_UNITS
+from ansys.units._constants import _derived_units as _CONST_DERIVED_UNITS
+from ansys.units.unit import Unit
+
+if TYPE_CHECKING:
+    from ansys.units.quantity import Quantity  # noqa: F401
+
+
+class UnitRegistry:
+    """
+    A representation of valid ``Unit`` instances.
+
+    All base and derived units loaded from the configuration file, `cfg.yaml`,
+    on package initialization are provided by default.
+
+    Parameters
+    ----------
+    config: str, optional
+        Path of a ``YAML`` configuration file, which can be a custom file, and
+        defaults to the provided file, ``cfg.yaml``. Custom configuration files
+        must match the format of the default configuration file.
+    other: dict, optional
+        Dictionary for additional units (uses config file format).
+    custom_units : list of dict, optional
+        List of custom units to register during construction. Each dict must
+        have keys ``"unit"``, ``"composition"``, and ``"factor"`` matching
+        the :meth:`register_unit` signature.
+
+    Examples
+    --------
+    >>> from ansys.units import UnitRegistry, Unit
+    >>> ureg = UnitRegistry()
+    >>> assert ureg.kg == Unit(units="kg")
+    >>> fps = Unit("ft s^-1")
+    >>> ureg.foot_per_sec = fps
+
+    Register custom units at construction:
+
+    >>> ur = UnitRegistry(custom_units=[
+    ...     {"unit": "micron", "composition": "m", "factor": 1e-6},
+    ...     {"unit": "inch", "composition": "m", "factor": 0.0254},
+    ... ])
+    >>> q = ur.Quantity(10, "micron")
+    """
+
+    def __init__(
+        self,
+        config: str = "cfg.yaml",
+        other: Mapping[
+            str, Mapping[str, Any]
+        ] = {},  # pyright: ignore[reportCallInDefaultInitializer]
+        custom_units: Sequence[Mapping[str, Any]] | None = None,
+    ):
+        unitdict = dict(other)
+
+        if config:
+            file_dir = os.path.dirname(__file__)
+            qc_path = os.path.join(file_dir, config)
+
+            with open(qc_path, "r") as qc_yaml:
+                qc_data = yaml.safe_load(qc_yaml)
+                _base_units: dict[str, _BaseUnitInfo] = qc_data["base_units"]
+                _derived_units: dict[str, _DerivedUnitInfo] = qc_data["derived_units"]
+
+            unitdict |= _base_units | _derived_units
+
+        for unit_name in unitdict:
+            # Prevent overriding attributes already present on this instance
+            if hasattr(self, unit_name):
+                raise UnitNameAlreadyRegistered(unit_name)
+
+            cfg = unitdict[unit_name]
+            if unit_name in _CONST_BASE_UNITS or unit_name in _CONST_DERIVED_UNITS:
+                object.__setattr__(self, unit_name, Unit(unit_name, cfg))
+            else:
+                # For dynamically registered units not present in constants, build
+                # from their composition so dimensions/si data are correct, then
+                # override the name to the desired symbol and attach config.
+                if "composition" in cfg:
+                    composed = Unit(units=str(cfg["composition"]))
+                    obj = Unit(copy_from=composed)
+                    obj._name = unit_name
+                    object.__setattr__(self, unit_name, obj)
+                else:
+                    object.__setattr__(self, unit_name, Unit(unit_name, cfg))
+
+        # Register custom units using the same logic as register_unit
+        if custom_units:
+            for cu in custom_units:
+                self.register_unit(
+                    unit=cu["unit"],
+                    composition=cu["composition"],
+                    factor=cu["factor"],
+                )
+
+    def __str__(self):
+        returned_string = ""
+        attrs = self.__dict__
+        for key in attrs:
+            returned_string += f"{key}, "
+        return returned_string
+
+    if TYPE_CHECKING:
+
+        def __getattr__(self, name: str) -> Unit: ...
+
+    def __setattr__(self, name: str, unit: Any) -> None:
+        if hasattr(self, name):
+            raise UnitNameAlreadyRegistered(name)
+        self.__dict__[name] = unit
+
+    def __iter__(self) -> Generator[str]:
+        yield from self.__dict__
+
+    def get_unit(self, name: str) -> Unit:
+        """
+        Look up a unit by name from this registry.
+
+        Checks instance-registered units first, then falls back to built-in
+        units and compound unit strings. This allows string-based lookup of
+        custom registered units as well as standard unit expressions.
+
+        Parameters
+        ----------
+        name : str
+            The unit name or compound unit string to look up (e.g., "micron",
+            "m", "kg mol^-1").
+
+        Returns
+        -------
+        Unit
+            The unit object.
+
+        Raises
+        ------
+        AttributeError
+            If the unit is not found in this registry or cannot be parsed.
+        """
+        # First check instance-registered units
+        if name in self.__dict__:
+            return self.__dict__[name]
+        # Fall back to creating a Unit (handles built-ins and compound strings)
+        try:
+            return Unit(name)
+        except Exception as e:
+            raise AttributeError(f"Unit `{name}` not found in this registry.") from e
+
+    def Quantity(
+        self,
+        value: "int | float | Sequence[float]",
+        units: "str | Unit",
+    ) -> "Quantity":
+        """
+        Create a Quantity using this registry's units.
+
+        This method allows creating quantities with instance-registered units
+        using string names.
+
+        Parameters
+        ----------
+        value : int, float, or sequence
+            The numeric value.
+        units : str or Unit
+            The unit name (looked up in this registry) or a Unit object.
+
+        Returns
+        -------
+        Quantity
+            The created quantity.
+
+        Examples
+        --------
+        >>> ur = UnitRegistry()
+        >>> ur.register_unit(unit="micron", composition="m", factor=1e-6)
+        >>> q = ur.Quantity(1, "micron")
+        >>> print(q)
+        1.0 micron
+        """
+        from ansys.units.quantity import Quantity as _Quantity
+
+        if isinstance(units, str):
+            units = self.get_unit(units)
+        return _Quantity(value, units)
+
+    def register_unit(
+        self,
+        *,
+        unit: str,
+        composition: str,
+        factor: float,
+    ) -> Unit:
+        """
+        Register a new derived unit on this ``UnitRegistry`` instance.
+
+        This is instance-scoped: it affects only this registry and does not
+        mutate global state or other registries. The registered unit can be
+        accessed as an attribute (e.g., ``ur.micron``) or via
+        :meth:`get_unit` for string-based lookup.
+
+        Parameters
+        ----------
+        unit: str
+            The symbol/name of the new unit (e.g., "micron").
+        composition: str
+            A valid unit composition using existing configured units (e.g., "m").
+        factor: float
+            Scale factor that relates the composition to this unit.
+
+        Returns
+        -------
+        Unit
+            The registered unit attached on this instance.
+
+        Raises
+        ------
+        UnitNameAlreadyRegistered
+            If a unit with the same name already exists on this instance or
+            as a built-in. This is a name-only check and does not detect
+            equivalent definitions with different names.
+        ValueError
+            If ``unit`` is empty or ``factor`` is not finite.
+
+        Notes
+        -----
+        The name collision check is superficial (name-only). Two units with
+        different names but equivalent definitions (same composition and factor)
+        can both be registered without error.
+
+        Examples
+        --------
+        >>> ur = UnitRegistry()
+        >>> ur.register_unit(unit="micron", composition="m", factor=1e-6)
+        >>> q = ur.Quantity(1, "micron")  # Use registry's Quantity method
+        """
+        unit = unit.strip()
+        if not unit:
+            raise ValueError("`unit` must be a non-empty string.")
+        f = float(factor)
+        if not math.isfinite(f):
+            raise ValueError("`factor` must be a finite number.")
+
+        # Name-only collision check against built-ins and this instance
+        if (
+            unit in _CONST_BASE_UNITS
+            or unit in _CONST_DERIVED_UNITS
+            or hasattr(self, unit)
+        ):
+            raise UnitNameAlreadyRegistered(unit)
+
+        composed = Unit(units=str(composition))
+        obj = Unit(copy_from=composed)
+
+        obj._si_scaling_factor *= f
+        obj._name = unit
+        object.__setattr__(self, unit, obj)
+        return obj
+
+    def register_alias(
+        self,
+        alias: str,
+        canonical: str,
+    ) -> None:
+        """
+        Register a new alias for an existing unit.
+
+        The alias is added to the global alias table so that it can be used
+        anywhere a unit string is accepted (``Unit()``, ``Quantity()``, etc.).
+
+        Parameters
+        ----------
+        alias : str
+            The alias name (e.g., ``"deg"``).
+        canonical : str
+            The canonical unit name the alias resolves to
+            (e.g., ``"degree"``). Must be a configured base or derived unit,
+            or an existing alias.
+
+        Raises
+        ------
+        AliasAlreadyRegistered
+            If ``alias`` is already registered as a unit or alias.
+        ValueError
+            If ``canonical`` is not a known unit or alias.
+        """
+        alias = alias.strip()
+        canonical = canonical.strip()
+        if not alias:
+            raise ValueError("`alias` must be a non-empty string.")
+        if not canonical:
+            raise ValueError("`canonical` must be a non-empty string.")
+
+        # Prevent shadowing existing units
+        if (
+            alias in _CONST_BASE_UNITS
+            or alias in _CONST_DERIVED_UNITS
+            or alias in _CONST_ALIASES
+        ):
+            raise AliasAlreadyRegistered(alias)
+
+        # Validate the canonical target exists
+        if not (
+            canonical in _CONST_BASE_UNITS
+            or canonical in _CONST_DERIVED_UNITS
+            or canonical in _CONST_ALIASES
+        ):
+            raise ValueError(
+                f"`{canonical}` is not a configured unit or existing alias."
+            )
+
+        _CONST_ALIASES[alias] = canonical
+
+
+class AliasAlreadyRegistered(ValueError):
+    """Raised when an alias conflicts with an existing unit or alias."""
+
+    def __init__(self, name: str):
+        super().__init__(
+            f"Unable to register alias `{name}`: it already exists as a unit or alias."
+        )
+
+
+class UnitNameAlreadyRegistered(ValueError):
+    """
+    Raised when a unit name conflicts with an existing name.
+
+    This is a name-only check. Units with different names but equivalent definitions
+    (same composition and factor) are not detected.
+    """
+
+    def __init__(self, name: str):
+        super().__init__(
+            f"Unable to register `{name}`: a unit with this name already exists."
+        )

ansys_units-0.12.dev0/src/ansys/units/unit_registry.py

@@ -1,188 +0,0 @@
-# Copyright (C) 2023 - 2026 ANSYS, Inc. and/or its affiliates.
-# SPDX-License-Identifier: MIT
-#
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""Provides the ``UnitRegistry`` class and instance-scoped unit registration."""
-
-from collections.abc import Generator, Mapping
-import math
-import os
-from typing import TYPE_CHECKING, Any
-
-import yaml
-
-from ansys.units._constants import (
-    _BaseUnitInfo,
-)
-from ansys.units._constants import (
-    _DerivedUnitInfo,
-)
-from ansys.units._constants import _base_units as _CONST_BASE_UNITS
-from ansys.units._constants import _derived_units as _CONST_DERIVED_UNITS
-from ansys.units.unit import Unit
-
-
-class UnitRegistry:
-    """
-    A representation of valid ``Unit`` instances.
-
-    All base and derived units loaded from the configuration file, `cfg.yaml`,
-    on package initialization are provided by default.
-
-    Parameters
-    ----------
-    config: str, optional
-        Path of a ``YAML`` configuration file, which can be a custom file, and
-        defaults to the provided file, ``cfg.yaml``. Custom configuration files
-        must match the format of the default configuration file.
-    other: dict, optional
-        Dictionary for additional units.
-
-    Examples
-    --------
-    >>> from ansys.units import UnitRegistry, Unit
-    >>> ureg = UnitRegistry()
-    >>> assert ureg.kg == Unit(units="kg")
-    >>> fps = Unit("ft s^-1")
-    >>> ureg.foot_per_sec = fps
-    """
-
-    def __init__(
-        self,
-        config: str = "cfg.yaml",
-        other: Mapping[
-            str, Mapping[str, Any]
-        ] = {},  # pyright: ignore[reportCallInDefaultInitializer]
-    ):
-        unitdict = dict(other)
-
-        if config:
-            file_dir = os.path.dirname(__file__)
-            qc_path = os.path.join(file_dir, config)
-
-            with open(qc_path, "r") as qc_yaml:
-                qc_data = yaml.safe_load(qc_yaml)
-                _base_units: dict[str, _BaseUnitInfo] = qc_data["base_units"]
-                _derived_units: dict[str, _DerivedUnitInfo] = qc_data["derived_units"]
-
-            unitdict |= _base_units | _derived_units
-
-        for unit_name in unitdict:
-            # Prevent overriding attributes already present on this instance
-            if hasattr(self, unit_name):
-                raise UnitAlreadyRegistered(unit_name)
-
-            cfg = unitdict[unit_name]
-            if unit_name in _CONST_BASE_UNITS or unit_name in _CONST_DERIVED_UNITS:
-                object.__setattr__(self, unit_name, Unit(unit_name, cfg))
-            else:
-                # For dynamically registered units not present in constants, build
-                # from their composition so dimensions/si data are correct, then
-                # override the name to the desired symbol and attach config.
-                if "composition" in cfg:
-                    composed = Unit(units=str(cfg["composition"]))
-                    obj = Unit(copy_from=composed)
-                    obj._name = unit_name
-                    object.__setattr__(self, unit_name, obj)
-                else:
-                    object.__setattr__(self, unit_name, Unit(unit_name, cfg))
-
-    def __str__(self):
-        returned_string = ""
-        attrs = self.__dict__
-        for key in attrs:
-            returned_string += f"{key}, "
-        return returned_string
-
-    if TYPE_CHECKING:
-
-        def __getattr__(self, name: str) -> Unit: ...
-
-    def __setattr__(self, name: str, unit: Any) -> None:
-        if hasattr(self, name):
-            raise UnitAlreadyRegistered(name)
-        self.__dict__[name] = unit
-
-    def __iter__(self) -> Generator[str]:
-        yield from self.__dict__
-
-    def register_unit(
-        self,
-        *,
-        unit: str,
-        composition: str,
-        factor: float,
-    ) -> Unit:
-        """
-        Register a new derived unit on this ``UnitRegistry`` instance.
-
-        This is instance-scoped: it affects only this registry and does not
-        mutate global state or other registries.
-
-        Parameters
-        ----------
-        unit: str
-            The symbol/name of the new unit (e.g., "Q"). Preferred keyword.
-        composition: str
-            A valid unit composition using existing configured units (e.g., "N m").
-        factor: float
-            Scale factor that relates the composition to this unit.
-
-        Returns
-        -------
-        Unit
-            The registered unit attached on this instance.
-
-        Raises
-        ------
-        UnitAlreadyRegistered
-            If a unit with the same name already exists on this instance or is built-in.
-        ValueError
-            If ``unit`` is empty or ``factor`` is not finite.
-        """
-        unit = unit.strip()
-        if not unit:
-            raise ValueError("`unit` must be a non-empty string.")
-        f = float(factor)
-        if not math.isfinite(f):
-            raise ValueError("`factor` must be a finite number.")
-
-        # Prevent overriding built-ins or existing attributes on this instance
-        if (
-            unit in _CONST_BASE_UNITS
-            or unit in _CONST_DERIVED_UNITS
-            or hasattr(self, unit)
-        ):
-            raise UnitAlreadyRegistered(unit)
-
-        composed = Unit(units=str(composition))
-        obj = Unit(copy_from=composed)
-
-        obj._si_scaling_factor *= f
-        obj._name = unit
-        object.__setattr__(self, unit, obj)
-        return obj
-
-
-class UnitAlreadyRegistered(ValueError):
-    """Raised when a unit has previously been registered."""
-
-    def __init__(self, name: str):
-        super().__init__(f"Unable to override `{name}` it has already been registered.")