cocotb 2.0.0b1__cp313-cp313-win32.whl → 2.0.0rc2__cp313-cp313-win32.whl

cocotb/types/_logic.py

@@ -4,13 +4,10 @@
 from functools import lru_cache
 from typing import (
     Dict,
-    Set,
-    Type,
     Union,
 )
 
-from cocotb._deprecation import deprecated
-from cocotb._py_compat import TypeAlias
+from cocotb._py_compat import Self, TypeAlias
 from cocotb.types._resolve import RESOLVE_X, ResolverLiteral, get_str_resolver
 
 LogicLiteralT: TypeAlias = Union[str, int, bool]
@@ -56,21 +53,16 @@ _literal_repr: Dict[LogicLiteralT, int] = {
     "-": _D,
 }
 
-_str_literals: Set[str] = {k for k in _literal_repr if isinstance(k, str)}
-
 
 class Logic:
-    r"""
-    Model of a 9-value (``U``, ``X``, ``0``, ``1``, ``Z``, ``W``, ``L``, ``H``, ``-``) datatype commonly seen in VHDL.
-
-    .. currentmodule:: cocotb.types
+    r"""9-state digital signal value type.
 
-    This is modeled after VHDL's ``std_ulogic`` type.
-    (System)Verilog's 4-value ``logic`` type only utilizes ``X``, ``0``, ``1``, and ``Z`` values.
+    This type is modeled after VHDL's ``std_ulogic`` type.
+    It can represent the values (``U``, ``X``, ``0``, ``1``, ``Z``, ``W``, ``L``, ``H``, ``-``).
+    (System)Verilog's 4-state ``logic`` type is a subset which only utilizes the ``X``, ``0``, ``1``, and ``Z`` values.
 
-    :class:`Logic` can be converted to and from :class:`int`, :class:`str`, and :class:`bool`.
-    The list of values convertible to :class:`Logic` includes
-    ``"U"``, ``"X"``, ``"0"``, ``"1"``, ``"Z"``, ``"W"``, ``"L"``, ``"H"``, ``"-"``, ``0``, ``1``, ``True``, and ``False``.
+    :class:`!Logic` can be converted to and from :class:`int`, :class:`str`, :class:`bool` and :class:`Bit`.
+    String literals include ``"U"``, ``"X"``, ``"0"``, ``"1"``, ``"Z"``, ``"W"``, ``"L"``, ``"H"``, ``"-"``, and their lowercase values.
 
     .. code-block:: pycon3
 
@@ -92,8 +84,6 @@ class Logic:
 
         The :class:`int` and :class:`bool` conversions will raise :exc:`ValueError` if the value is not ``0``, ``1``, ``L``, or ``H``.
 
-    :class:`Logic` values are immutable and therefore hashable and can be placed in :class:`set`\ s and used as keys in :class:`dict`\ s.
-
     :class:`Logic` supports the common logic operations ``&``, ``|``, ``^``, and ``~``.
 
     .. code-block:: pycon3
@@ -107,53 +97,54 @@ class Logic:
         (Logic('0'), Logic('1'))
 
     Args:
-        value: value to construct into a :class:`Logic`.
+        value: value to construct into a :class:`!Logic`.
 
     Raises:
-        ValueError: If the value if of the correct type, but cannot be constructed into a :class:`Logic`.
-        TypeError: If the value is of a type that can't be constructed into a :class:`Logic`.
+        ValueError: If the value if of the correct type, but cannot be constructed into a :class:`!Logic`.
+        TypeError: If the value is of a type that can't be constructed into a :class:`!Logic`.
     """
 
+    _values = {_U, _X, _0, _1, _Z, _W, _L, _H, _D}
+
     _repr: int
 
+    __slots__ = ("_repr",)
+
     @classmethod
     @lru_cache(maxsize=None)
-    def _singleton(cls: Type["Logic"], _repr: int) -> "Logic":
+    def _singleton(cls, _repr: int) -> Self:
         """Return the Logic object associated with the repr, enforcing singleton."""
         self = object.__new__(cls)
         self._repr = _repr
         return self
 
-    @classmethod
-    @lru_cache(maxsize=None)
-    def _map_literal(
-        cls: Type["Logic"],
-        value: LogicLiteralT,
-    ) -> "Logic":
-        """Convert and cache all literals."""
-        try:
-            _repr = _literal_repr[value]
-        except KeyError:
-            raise ValueError(
-                f"{value!r} is not convertible to a {cls.__qualname__}"
-            ) from None
-        obj = cls._singleton(_repr)
-        return obj
-
     def __new__(
-        cls: Type["Logic"],
+        cls,
         value: LogicConstructibleT,
-    ) -> "Logic":
+    ) -> Self:
         if isinstance(value, Logic):
-            return value
+            _repr = value._repr
         elif isinstance(value, (str, int)):
-            return cls._map_literal(value)
-        raise TypeError(f"Expected str, bool, or int, not {type(value).__qualname__}")
+            try:
+                _repr = _literal_repr[value]
+            except KeyError:
+                raise ValueError(
+                    f"{value!r} is not convertible to {cls.__qualname__}"
+                ) from None
+        else:
+            raise TypeError(
+                f"Expected str, bool, or int, not {type(value).__qualname__}"
+            )
+
+        if _repr not in cls._values:
+            raise ValueError(f"{value!r} is not a valid {cls.__qualname__}")
 
-    def __and__(self, other: "Logic") -> "Logic":
-        if not isinstance(other, Logic):
+        return cls._singleton(_repr)
+
+    def __and__(self, other: Self) -> Self:
+        if not isinstance(other, type(self)):
             return NotImplemented
-        return Logic(
+        return type(self)(
             (
                 # -----------------------------------------------------
                 # U    X    0    1    Z    W    L    H    -       |   |
@@ -170,10 +161,13 @@ class Logic:
             )[self._repr][other._repr]
         )
 
-    def __or__(self: "Logic", other: "Logic") -> "Logic":
-        if not isinstance(other, Logic):
+    def __rand__(self, other: Self) -> Self:
+        return self & other
+
+    def __or__(self, other: Self) -> Self:
+        if not isinstance(other, type(self)):
             return NotImplemented
-        return Logic(
+        return type(self)(
             (
                 # -----------------------------------------------------
                 # U    X    0    1    Z    W    L    H    -       |   |
@@ -190,10 +184,13 @@ class Logic:
             )[self._repr][other._repr]
         )
 
-    def __xor__(self: "Logic", other: "Logic") -> "Logic":
-        if not isinstance(other, Logic):
+    def __ror__(self, other: Self) -> Self:
+        return self | other
+
+    def __xor__(self, other: Self) -> Self:
+        if not isinstance(other, type(self)):
             return NotImplemented
-        return Logic(
+        return type(self)(
             (
                 # -----------------------------------------------------
                 # U    X    0    1    Z    W    L    H    -       |   |
@@ -210,12 +207,15 @@ class Logic:
             )[self._repr][other._repr]
         )
 
-    def __invert__(self: "Logic") -> "Logic":
-        return Logic(("U", "X", "1", "0", "X", "X", "1", "0", "X")[self._repr])
+    def __rxor__(self, other: Self) -> Self:
+        return self ^ other
+
+    def __invert__(self) -> Self:
+        return type(self)(("U", "X", "1", "0", "X", "X", "1", "0", "X")[self._repr])
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Logic):
-            return self is other
+            return self._repr == other._repr
         elif isinstance(other, (int, str, bool)):
             try:
                 other = Logic(other)
@@ -225,6 +225,8 @@ class Logic:
         else:
             return NotImplemented
 
+    __hash__: None  # type: ignore[assignment]
+
     def __repr__(self) -> str:
         return f"{type(self).__qualname__}({str(self)!r})"
 
@@ -260,12 +262,13 @@ class Logic:
     def __index__(self) -> int:
         return int(self)
 
-    def resolve(self, resolver: ResolverLiteral) -> "Logic":
-        """Resolves non-0/1 values to 0/1.
+    def resolve(self, resolver: ResolverLiteral) -> Self:
+        """Resolve non-``0``/``1`` values to ``0``/``1``.
 
         The possible values of the *resolver* argument are:
 
-        * ``"weak"``: Weak values are resolved to their strong-valued equivalents.
+        * ``"weak"``:
+            Weak values are resolved to their strong-valued equivalents.
 
         * ``"zeros"``:
             ``L`` and ``H`` are resolved to ``0`` and ``1``, respectively.
@@ -289,8 +292,42 @@ class Logic:
             ValueError: Invalid *resolver* value.
             TypeError: Unsupported *value* type.
         """
-        return Logic(get_str_resolver(resolver)(str(self)))
+        return type(self)(get_str_resolver(resolver)(str(self)))
 
-    @deprecated('`len(logic)` is deprecated. A Logic\'s "length" is always 1.')
     def __len__(self) -> int:
         return 1
+
+    @property
+    def is_resolvable(self) -> bool:
+        """``True`` if value is ``0``, ``1``, ``L``, ``H``.
+
+        .. versionadded:: 2.0
+        """
+        return (False, False, True, True, False, False, True, True, False)[self._repr]
+
+    def __copy__(self) -> "Logic":
+        return self
+
+    def __deepcopy__(self, memo: Dict[int, object]) -> "Logic":
+        return self
+
+
+class Bit(Logic):
+    """2-state digital signal value type.
+
+    This is modeled after (System)Verilog's and VHDL's ``bit`` type.
+    It can represent only the values ``0`` and ``1``.
+    It can be converted to and from :class:`int`, :class:`str`, :class:`bool`, or :class:`Logic` values.
+
+    As a subtype of :class:`!Logic`, it supports all of the same operations
+    and can be used in operations interchangeably with :class:`!Logic`.
+
+    Args:
+        value: value to construct into a :class:`!Bit`.
+
+    Raises:
+        ValueError: If the value if of the correct type, but cannot be constructed into a :class:`!Bit`.
+        TypeError: If the value is of a type that can't be constructed into a :class:`!Bit`.
+    """
+
+    _values = {_0, _1}

cocotb/types/_logic_array.py

@@ -1,8 +1,12 @@
 # Copyright cocotb contributors
 # Licensed under the Revised BSD License, see LICENSE for details.
 # SPDX-License-Identifier: BSD-3-Clause
+import copy
+import warnings
 from math import ceil
 from typing import (
+    Any,
+    Dict,
     Iterable,
     Iterator,
     List,
@@ -14,29 +18,29 @@ from typing import (
 from cocotb._deprecation import deprecated
 from cocotb._py_compat import Literal, TypeAlias
 from cocotb.types._abstract_array import AbstractMutableArray
-from cocotb.types._logic import Logic, LogicConstructibleT, _str_literals
+from cocotb.types._indexing import IndexingChangedWarning
+from cocotb.types._logic import Logic, LogicConstructibleT
 from cocotb.types._range import Range
 from cocotb.types._resolve import RESOLVE_X, ResolverLiteral, get_str_resolver
 
 _resolve_lh_table = str.maketrans({"L": "0", "H": "1"})
+_str_literals = frozenset("uUxX01zZwWlLhH-")
 
 
 ByteOrder: TypeAlias = Literal["big", "little"]
 
 
 class LogicArray(AbstractMutableArray[Logic]):
-    r"""Fixed-sized, arbitrarily-indexed, Array of Logics.
+    r"""Fixed-sized, arbitrarily-indexed, :class:`.Array` of :class:`.Logic`\ s.
 
-    .. currentmodule:: cocotb.types
-
-    An :class:`Array`, where all elements are enforced to be :class:`Logic`.
+    An :class:`!Array`, where all elements are enforced to be :class:`!Logic`.
     This allows the additional of bit-wise logical operators, conversions to integers and bytes, and ``X`` testing and mapping.
 
     :class:`!LogicArray`\ s can be constructed from an iterable of :class:`!Logic`\ s,
     or values constructible into :class:`!Logic`, like :class:`bool`, :class:`str`, or :class:`int`.
     Alternatively, they can be constructed from :class:`!str` or :class:`!int` literals.
 
-    Like :class:`Array`, if *range* is not given, the range ``Range(len(value)-1, "downto", 0)`` is used;
+    Like :class:`!Array`, if *range* is not given, the range ``Range(len(value)-1, "downto", 0)`` is used;
     and if an :class:`int` is passed for *range*, the range ``Range(range-1, "downto", 0)`` is used.
 
     .. code-block:: pycon3
@@ -74,7 +78,7 @@ class LogicArray(AbstractMutableArray[Logic]):
         >>> LogicArray.from_bytes(b"1n", byteorder="little")
         LogicArray('0110111000110001', Range(15, 'downto', 0))
 
-    :class:`!LogicArray`\ s support the same :class:`list`-like operations as :class:`Array`;
+    :class:`!LogicArray`\ s support the same :class:`list`-like operations as :class:`!Array`;
     however, it enforces the condition that all elements must be a :class:`!Logic`.
 
     .. code-block:: pycon3
@@ -92,7 +96,7 @@ class LogicArray(AbstractMutableArray[Logic]):
         >>> list(array)  # is an iterable
         [Logic('1'), Logic('0'), Logic('1'), Logic('0')]
 
-    When setting an element or slice, the *value* is first constructed into a :class:`Logic`.
+    When setting an element or slice, the *value* is first constructed into a :class:`!Logic`.
 
     .. code-block:: pycon3
 
@@ -147,7 +151,7 @@ class LogicArray(AbstractMutableArray[Logic]):
         These operations assume the value is entirely ``0``, ``1``, ``L``, or ``H``, and will raise an exception otherwise.
 
     You can also convert :class:`!LogicArray`\ s to hexadecimal or binary strings using
-    the built-ins :func:`hex:` and :func:`bin`, respectively.
+    the built-ins :func:`hex` and :func:`bin`, respectively.
 
     .. code-block:: pycon3
 
@@ -159,8 +163,8 @@ class LogicArray(AbstractMutableArray[Logic]):
         '0b1111010'
 
     .. warning::
-        Using :func:`hex` or :func:`bin` first turns the LogicArray into an :class:`int`.
-        This means the exact length of the LogicArray is lost.
+        Using :func:`hex` or :func:`bin` first turns the :class:`!LogicArray` into an :class:`int`.
+        This means the exact length of the :class:`!LogicArray` is lost.
         It also means that these expressions will raise an exception if the value is not entirely ``0``, ``1``, ``L``, or ``H``.
 
     :class:`!LogicArray`\ s also support element-wise logical operations: ``&``, ``|``,
@@ -179,12 +183,12 @@ class LogicArray(AbstractMutableArray[Logic]):
         LogicArray('1110', Range(3, 'downto', 0))
 
     Args:
-        value: Initial value for the LogicArray.
-        range: The indexing scheme of the LogicArray.
+        value: Initial value for the :class:`!LogicArray`.
+        range: The indexing scheme of the :class:`!LogicArray`.
 
     Raises:
         TypeError: When invalid argument types are used.
-        ValueError: When *value* will not fit in a LogicArray of the given *range*.
+        ValueError: When *value* will not fit in a :class:`!LogicArray` of the given *range*.
     """
 
     # These three attribute contain the current value of the array in one or more of
@@ -196,6 +200,15 @@ class LogicArray(AbstractMutableArray[Logic]):
     _value_as_int: Union[int, None]
     _value_as_str: Union[str, None]
     _range: Range
+    _warn_indexing: bool
+
+    __slots__ = (
+        "_value_as_array",
+        "_value_as_int",
+        "_value_as_str",
+        "_range",
+        "_warn_indexing",
+    )
 
     def __init__(
         self,
@@ -205,6 +218,7 @@ class LogicArray(AbstractMutableArray[Logic]):
         self._value_as_array = None
         self._value_as_int = None
         self._value_as_str = None
+        self._warn_indexing = False
 
         if isinstance(range, int):
             range = Range(range - 1, "downto", 0)
@@ -299,7 +313,7 @@ class LogicArray(AbstractMutableArray[Logic]):
 
         Args:
             value: The integer to convert.
-            range: Indexing scheme for the LogicArray.
+            range: Indexing scheme for the :class:`!LogicArray`.
 
         Returns:
             A :class:`!LogicArray` equivalent to the *value*.
@@ -325,7 +339,7 @@ class LogicArray(AbstractMutableArray[Logic]):
 
         Args:
             value: The integer to convert.
-            range: Indexing scheme for the LogicArray.
+            range: Indexing scheme for the :class:`!LogicArray`.
 
         Returns:
             A :class:`!LogicArray` equivalent to the *value*.
@@ -371,7 +385,7 @@ class LogicArray(AbstractMutableArray[Logic]):
 
         Args:
             value: The bytes to convert.
-            range: Indexing scheme for the LogicArray.
+            range: Indexing scheme for the :class:`!LogicArray`.
             byteorder: The endianness used to construct the intermediate integer, either ``"big"`` or ``"little"``.
 
         Returns:
@@ -393,7 +407,7 @@ class LogicArray(AbstractMutableArray[Logic]):
         return LogicArray(value_as_int, range)
 
     @classmethod
-    def _from_handle(cls, value: str) -> "LogicArray":
+    def _from_handle(cls, value: str, warn_indexing: bool) -> "LogicArray":
         # Used by cocotb.handle classes to make LogicArray from values gotten from the
         # simulator which we expect to be well-formed.
         # Values are required to be uppercase.
@@ -402,6 +416,7 @@ class LogicArray(AbstractMutableArray[Logic]):
         self._value_as_int = None
         self._value_as_str = value
         self._range = Range(len(value) - 1, "downto", 0)
+        self._warn_indexing = warn_indexing
         return self
 
     @property
@@ -514,9 +529,7 @@ class LogicArray(AbstractMutableArray[Logic]):
     @property
     def is_resolvable(self) -> bool:
         """``True`` if all elements are ``0``, ``1``, ``L``, ``H``."""
-        return all(
-            bit in (Logic("0"), Logic("1"), Logic("L"), Logic("H")) for bit in self
-        )
+        return all(bit.is_resolvable for bit in self)
 
     @property
     @deprecated(
@@ -677,9 +690,23 @@ class LogicArray(AbstractMutableArray[Logic]):
     def __getitem__(self, item: Union[int, slice]) -> Union[Logic, "LogicArray"]:
         array = self._get_array()
         if isinstance(item, int):
+            if self._warn_indexing:
+                warnings.warn(
+                    f"Update index {item} to {self.range[item]}",
+                    IndexingChangedWarning,
+                    stacklevel=2,
+                )
             idx = self._translate_index(item)
             return array[idx]
         elif isinstance(item, slice):
+            if self._warn_indexing:
+                start = item.start if item.start is not None else 0
+                stop = item.stop if item.stop is not None else len(self) - 1
+                warnings.warn(
+                    f"Update slice {start}:{stop} to {self.range[start]}:{self.range[stop]}",
+                    IndexingChangedWarning,
+                    stacklevel=2,
+                )
             start = item.start if item.start is not None else self.left
             stop = item.stop if item.stop is not None else self.right
             if item.step is not None:
@@ -807,7 +834,8 @@ class LogicArray(AbstractMutableArray[Logic]):
 
         The possible values of the *resolver* argument are:
 
-        * ``"weak"``: Weak values are resolved to their strong-valued equivalents.
+        * ``"weak"``:
+            Weak values are resolved to their strong-valued equivalents.
 
         * ``"zeros"``:
             ``L`` and ``H`` are resolved to ``0`` and ``1``, respectively.
@@ -832,3 +860,9 @@ class LogicArray(AbstractMutableArray[Logic]):
             TypeError: Unsupported *value* type.
         """
         return LogicArray(get_str_resolver(resolver)(str(self)), self.range)
+
+    def __copy__(self) -> "LogicArray":
+        raise NotImplementedError("`copy.copy` on LogicArray is not supported")
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "LogicArray":
+        return LogicArray(self._get_str(), copy.deepcopy(self._range, memo=memo))

cocotb/types/_range.py

@@ -1,8 +1,9 @@
 # Copyright cocotb contributors
 # Licensed under the Revised BSD License, see LICENSE for details.
 # SPDX-License-Identifier: BSD-3-Clause
+import copy
 from functools import lru_cache
-from typing import Iterator, Sequence, Union, overload
+from typing import Any, Dict, Iterator, Sequence, Union, overload
 
 from cocotb._utils import cached_method
 
@@ -40,7 +41,7 @@ class Range(Sequence[int]):
 
     :class:`Range` supports "null" ranges as seen in VHDL.
     "null" ranges occur when a left bound cannot reach a right bound with the given direction.
-    They have a length of 0, but the :attr:`left`, :attr:`right`, and :attr:`direction` values remain as given.
+    They have a length of ``0``, but the :attr:`left`, :attr:`right`, and :attr:`direction` values remain as given.
 
     .. code-block:: pycon3
 
@@ -61,9 +62,9 @@ class Range(Sequence[int]):
     The typical use case of this type is in conjunction with :class:`~cocotb.types.Array`.
 
     Args:
-        left: leftmost bound of range
-        direction: ``'to'`` if values are ascending, ``'downto'`` if descending
-        right: rightmost bound of range (inclusive)
+        left: Leftmost bound of range.
+        direction: ``'to'`` if values are ascending, ``'downto'`` if descending.
+        right: Rightmost bound of range (inclusive).
     """
 
     @overload
@@ -165,6 +166,12 @@ class Range(Sequence[int]):
 
     index = cached_method(Sequence.index)
 
+    def __copy__(self) -> "Range":
+        return Range.from_range(self._range)
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "Range":
+        return Range.from_range(copy.deepcopy(self._range, memo=memo))
+
 
 def _guess_step(left: int, right: int) -> int:
     if left <= right:

cocotb/utils.py

@@ -4,18 +4,19 @@
 # Licensed under the Revised BSD License, see LICENSE for details.
 # SPDX-License-Identifier: BSD-3-Clause
 
-"""Utility functions for dealing with simulation time."""
+"""Tools for dealing with simulated time."""
 
 import warnings
 from decimal import Decimal
 from fractions import Fraction
-from functools import lru_cache
-from math import ceil, floor
-from typing import Union, overload
+from typing import Union
 
-from cocotb import simulator
-from cocotb._py_compat import Literal, TypeAlias
 from cocotb._typing import RoundMode, TimeUnit
+from cocotb.simtime import (
+    _get_sim_steps,
+    _get_time_from_sim_steps,
+    get_sim_time,
+)
 
 __all__ = (
     "get_sim_steps",
@@ -24,74 +25,6 @@ __all__ = (
 )
 
 
-def _get_simulator_precision() -> int:
-    # cache and replace this function
-    precision = simulator.get_precision()
-    global _get_simulator_precision
-    _get_simulator_precision = precision.__int__
-    return _get_simulator_precision()
-
-
-# Simulator helper functions
-def get_sim_time(unit: TimeUnit = "step", *, units: None = None) -> float:
-    """Retrieve the simulation time from the simulator.
-
-    Args:
-        unit: String specifying the unit of the result
-            (one of ``'step'``, ``'fs'``, ``'ps'``, ``'ns'``, ``'us'``, ``'ms'``, ``'sec'``).
-            ``'step'`` will return the raw simulation time.
-
-            .. versionchanged:: 2.0
-                Passing ``None`` as the *unit* argument was removed, use ``'step'`` instead.
-
-            .. versionchanged:: 2.0
-                Renamed from ``units``.
-
-    Raises:
-        ValueError: If *unit* is not a valid unit.
-
-    Returns:
-        The simulation time in the specified unit.
-
-    .. versionchanged:: 1.6
-        Support ``'step'`` as the the *unit* argument to mean "simulator time step".
-    """
-    if units is not None:
-        warnings.warn(
-            "The 'units' argument has been renamed to 'unit'.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        unit = units
-    timeh, timel = simulator.get_sim_time()
-    steps = timeh << 32 | timel
-    return get_time_from_sim_steps(steps, unit) if unit != "step" else steps
-
-
-@overload
-def _ldexp10(frac: float, exp: int) -> float: ...
-
-
-@overload
-def _ldexp10(frac: Fraction, exp: int) -> Fraction: ...
-
-
-@overload
-def _ldexp10(frac: Decimal, exp: int) -> Decimal: ...
-
-
-def _ldexp10(
-    frac: Union[float, Fraction, Decimal], exp: int
-) -> Union[float, Fraction, Decimal]:
-    """Like :func:`math.ldexp`, but base 10."""
-    # using * or / separately prevents rounding errors if `frac` is a
-    # high-precision type
-    if exp > 0:
-        return frac * (10**exp)
-    else:
-        return frac / (10**-exp)
-
-
 def get_time_from_sim_steps(
     steps: int,
     unit: Union[TimeUnit, None] = None,
@@ -124,9 +57,7 @@ def get_time_from_sim_steps(
         unit = units
     if unit is None:
         raise TypeError("Missing required argument 'unit'")
-    if unit == "step":
-        return steps
-    return _ldexp10(steps, _get_simulator_precision() - _get_log_time_scale(unit))
+    return _get_time_from_sim_steps(steps, unit)
 
 
 def get_sim_steps(
@@ -176,55 +107,4 @@ def get_sim_steps(
             stacklevel=2,
         )
         unit = units
-    result: Union[float, Fraction, Decimal]
-    if unit != "step":
-        result = _ldexp10(time, _get_log_time_scale(unit) - _get_simulator_precision())
-    else:
-        result = time
-
-    if round_mode == "error":
-        result_rounded = floor(result)
-        if result_rounded != result:
-            precision = _get_simulator_precision()
-            raise ValueError(
-                f"Unable to accurately represent {time}({unit}) with the simulator precision of 1e{precision}"
-            )
-    elif round_mode == "ceil":
-        result_rounded = ceil(result)
-    elif round_mode == "round":
-        result_rounded = round(result)
-    elif round_mode == "floor":
-        result_rounded = floor(result)
-    else:
-        raise ValueError(f"Invalid round_mode specifier: {round_mode}")
-
-    return result_rounded
-
-
-TimeUnitWithoutSteps: TypeAlias = Literal["fs", "ps", "ns", "us", "ms", "sec"]
-
-
-@lru_cache(maxsize=None)
-def _get_log_time_scale(unit: TimeUnitWithoutSteps) -> int:
-    """Retrieves the ``log10()`` of the scale factor for a given time unit.
-
-    Args:
-        unit: String specifying the unit
-            (one of ``'fs'``, ``'ps'``, ``'ns'``, ``'us'``, ``'ms'``, ``'sec'``).
-
-            .. versionchanged:: 2.0
-                Renamed from ``units``.
-
-    Raises:
-        ValueError: If *unit* is not a valid unit.
-
-    Returns:
-        The ``log10()`` of the scale factor for the time unit.
-    """
-    scale = {"fs": -15, "ps": -12, "ns": -9, "us": -6, "ms": -3, "sec": 0}
-
-    unit_lwr = unit.lower()
-    if unit_lwr not in scale:
-        raise ValueError(f"Invalid unit ({unit}) provided")
-    else:
-        return scale[unit_lwr]
+    return _get_sim_steps(time, unit, round_mode=round_mode)