nidaqmx 1.2.0.dev1__tar.gz → 1.3.0.dev0__tar.gz

{nidaqmx-1.2.0.dev1 → nidaqmx-1.3.0.dev0}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: nidaqmx
-Version: 1.2.0.dev1
+Version: 1.3.0.dev0
 Summary: NI-DAQmx Python API
-Home-page: https://github.com/ni/nidaqmx-python
 License: MIT
 Keywords: nidaqmx,nidaq,daqmx,daq
 Author: NI
@@ -32,12 +31,13 @@ Requires-Dist: deprecation (>=2.1)
 Requires-Dist: distro (>=1.9.0) ; sys_platform == "linux"
 Requires-Dist: grpcio (>=1.49.0,<2.0) ; extra == "grpc"
 Requires-Dist: hightime (>=0.2.2)
-Requires-Dist: numpy (>=1.22) ; python_version >= "3.9" and python_version < "3.12"
-Requires-Dist: numpy (>=1.26) ; python_version >= "3.12" and python_version < "3.13"
+Requires-Dist: nitypes (>=0.1.0dev10)
+Requires-Dist: numpy (>=1.22) ; python_version >= "3.9" and python_version < "3.13"
 Requires-Dist: numpy (>=2.1) ; python_version >= "3.13" and python_version < "4.0"
 Requires-Dist: protobuf (>=4.21) ; extra == "grpc"
 Requires-Dist: python-decouple (>=3.8)
 Requires-Dist: requests (>=2.25.0)
+Requires-Dist: typing_extensions (>=4.0.0)
 Requires-Dist: tzlocal (>=5.0,<6.0)
 Project-URL: Documentation, https://nidaqmx-python.readthedocs.io
 Project-URL: Repository, https://github.com/ni/nidaqmx-python
@@ -100,7 +100,10 @@ system.
 Python Version Support
 ----------------------
 
-**nidaqmx** supports CPython 3.9+ and PyPy3.
+**nidaqmx** supports CPython 3.9+.
+
+**nidaqmx** supports PyPy3 for non-gRPC use cases. For the status of PyPy support for gRPC,
+see `PyPy support (grpc/grpc#4221) <https://github.com/grpc/grpc/issues/4221>`_.
 
 Installation
 ============

{nidaqmx-1.2.0.dev1 → nidaqmx-1.3.0.dev0}/README.rst

@@ -55,7 +55,10 @@ system.
 Python Version Support
 ----------------------
 
-**nidaqmx** supports CPython 3.9+ and PyPy3.
+**nidaqmx** supports CPython 3.9+.
+
+**nidaqmx** supports PyPy3 for non-gRPC use cases. For the status of PyPy support for gRPC,
+see `PyPy support (grpc/grpc#4221) <https://github.com/grpc/grpc/issues/4221>`_.
 
 Installation
 ============

nidaqmx-1.3.0.dev0/generated/nidaqmx/__init__.py

@@ -0,0 +1,31 @@
+"""The NI-DAQmx API for Python."""
+
+from nidaqmx.errors import (
+    DaqError,
+    DaqReadError,
+    DaqResourceWarning,
+    DaqWarning,
+    DaqWriteError,
+)
+from nidaqmx.grpc_session_options import *  # noqa: F403 - 'from nidaqmx.grpc_session_options import *' used; unable to detect undefined names (auto-generated noqa)
+from nidaqmx.scale import Scale
+from nidaqmx.task import Task
+from nidaqmx.types import CtrFreq, CtrTick, CtrTime
+
+try:
+    from importlib.metadata import version
+except ImportError:
+    from importlib_metadata import version  # type: ignore[no-redef]
+
+__version__ = version(__name__)
+
+__all__ = [  # noqa: F405 - 'errors' may be undefined, or defined from star imports: nidaqmx.grpc_session_options (auto-generated noqa)
+    "errors",
+    "scale",
+    "stream_readers",
+    "stream_writers",
+    "task",
+]
+
+# Do not add a null logging handler. If the application has not configured logging, the
+# default behavior is to log warnings and errors to stderr.

{nidaqmx-1.2.0.dev1 → nidaqmx-1.3.0.dev0}/generated/nidaqmx/__main__.py

@@ -1,7 +1,8 @@
+"""'nidaqmx' command line utility."""
+
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 import click
 
@@ -16,12 +17,14 @@ from . import _install_daqmx
     count=True,
     help="Enable verbose logging. Repeat to increase verbosity.",
 )
-def main(verbosity: int) -> None:
+def main(  # noqa: D103 - Missing docstring in public function (auto-generated noqa)
+    verbosity: int,
+) -> None:
     _configure_logging(verbosity)
 
 
 @main.command()
-def installdriver():
+def installdriver():  # noqa: D103 - Missing docstring in public function (auto-generated noqa)
     _install_daqmx.installdriver()
 
 

{nidaqmx-1.2.0.dev1 → nidaqmx-1.3.0.dev0}/generated/nidaqmx/_base_interpreter.py

@@ -1,6 +1,11 @@
 # Do not edit this file; it was automatically generated.
+from __future__ import annotations
+
 import abc
-from typing import Optional
+import numpy
+from nitypes.waveform import AnalogWaveform, DigitalWaveform
+from typing import Any, Sequence
+from nidaqmx.constants import WaveformAttributeMode
 
 
 class BaseEventHandler(abc.ABC):
@@ -1845,4 +1850,101 @@ class BaseInterpreter(abc.ABC):
 
     @abc.abstractmethod
     def hash_task_handle(self, task_handle):
-        raise NotImplementedError
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def read_analog_waveform(
+        self,
+        task_handle: object,
+        number_of_samples_per_channel: int,
+        timeout: float,
+        waveform: AnalogWaveform[numpy.float64],
+        waveform_attribute_mode: WaveformAttributeMode
+    ) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def read_analog_waveforms(
+        self,
+        task_handle: object,
+        number_of_samples_per_channel: int,
+        timeout: float,
+        waveforms: Sequence[AnalogWaveform[numpy.float64]],
+        waveform_attribute_mode: WaveformAttributeMode
+    ) -> int:
+        raise NotImplementedError
+        
+    @abc.abstractmethod
+    def read_digital_waveform(
+        self,
+        task_handle: object,
+        number_of_samples_per_channel: int,
+        timeout: float,
+        waveform: DigitalWaveform[Any],
+        waveform_attribute_mode: WaveformAttributeMode
+    ) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def read_digital_waveforms(
+        self,
+        task_handle: object,
+        channel_count: int,
+        number_of_samples_per_channel: int,
+        number_of_signals_per_sample: int,
+        timeout: float,
+        waveforms: Sequence[DigitalWaveform[Any]],
+        waveform_attribute_mode: WaveformAttributeMode,
+    ) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def read_new_digital_waveforms(
+        self,
+        task_handle: object,
+        channel_count: int,
+        number_of_samples_per_channel: int,
+        number_of_signals_per_sample: int,
+        timeout: float,
+        waveform_attribute_mode: WaveformAttributeMode,
+    ) -> Sequence[DigitalWaveform[numpy.uint8]]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def write_analog_waveform(
+        self,
+        task_handle: object,
+        waveform: AnalogWaveform[Any],
+        auto_start: bool,
+        timeout: float
+    ) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def write_analog_waveforms(
+        self,
+        task_handle: object,
+        waveforms: Sequence[AnalogWaveform[Any]],
+        auto_start: bool,
+        timeout: float
+    ) -> int:
+        raise NotImplementedError
+        
+    @abc.abstractmethod
+    def write_digital_waveform(
+        self,
+        task_handle: object,
+        waveform: DigitalWaveform[Any],
+        auto_start: bool,
+        timeout: float,
+    ) -> int:
+        raise NotImplementedError
+        
+    def write_digital_waveforms(
+        self,
+        task_handle: object,
+        waveform: Sequence[DigitalWaveform[Any]],
+        auto_start: bool,
+        timeout: float,
+    ) -> int:
+        raise NotImplementedError

{nidaqmx-1.2.0.dev1 → nidaqmx-1.3.0.dev0}/generated/nidaqmx/_bitfield_utils.py

@@ -1,41 +1,38 @@
-def enum_bitfield_to_list(bitfield_value, bitfield_enum_type,
-                          actual_enum_type):
-    """
-    Converts a bitfield value to a list of enums.
+def enum_bitfield_to_list(bitfield_value, bitfield_enum_type, actual_enum_type):
+    """Converts a bitfield value to a list of enums.
 
     Args:
         bitfield_value (int): Specifies the value of the bitfield.
         bitfield_enum_type (enum.Enum): Specifies the bitfield enum type
             from which to mask and extract the enum values.
         actual_enum_type (enum.Enum): Specifies the actual enum type.
+
     Returns:
         List[enum.Enum]: Indicates the converted list of enums.
     """
     supported_values = []
     for bitfield_mask in bitfield_enum_type:
         if bitfield_value & bitfield_mask.value:
-            enum_value = next(
-                e for e in actual_enum_type if e.name == bitfield_mask.name)
+            enum_value = next(e for e in actual_enum_type if e.name == bitfield_mask.name)
             supported_values.append(enum_value)
 
     return supported_values
 
 
 def enum_list_to_bitfield(enum_list, bitfield_enum_type):
-    """
-    Converts a list of enums to a bitfield value.
+    """Converts a list of enums to a bitfield value.
 
     Args:
         enum_list (List[enum.Enum]): Specifies the list of enums.
         bitfield_enum_type (enum.Enum): Specifies the bitfield enum type
             from which to mask and extract the enum values.
+
     Returns:
         int: Indicates the value of the bitfield.
     """
     bitfield_value = 0
     for enum_value in enum_list:
-        bitfield_mask = next(
-            b for b in bitfield_enum_type if b.name == enum_value.name)
+        bitfield_mask = next(b for b in bitfield_enum_type if b.name == enum_value.name)
         bitfield_value |= bitfield_mask.value
 
-    return bitfield_value
+    return bitfield_value

nidaqmx-1.3.0.dev0/generated/nidaqmx/_dotenvpath.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import inspect
+import sys
+import traceback
+from pathlib import Path
+
+
+def get_dotenv_search_path() -> Path:
+    """Get the search path for loading the `.env` file."""
+    # Prefer to load the `.env` file from the current directory or its parents.
+    # If the current directory doesn't have a `.env` file, fall back to the
+    # script/EXE path or the TestStand code module path.
+    cwd = Path.cwd()
+    if not _has_dotenv_file(cwd):
+        if script_or_exe_path := _get_script_or_exe_path():
+            return script_or_exe_path.resolve().parent
+        if caller_path := _get_caller_path():
+            return caller_path.resolve().parent
+    return cwd
+
+
+def _has_dotenv_file(dir: Path) -> bool:
+    """Check whether the dir or its parents contains a `.env` file."""
+    return (dir / ".env").exists() or any((p / ".env").exists() for p in dir.parents)
+
+
+def _get_script_or_exe_path() -> Path | None:
+    """Get the path of the top-level script or PyInstaller EXE, if possible."""
+    if getattr(sys, "frozen", False):
+        return Path(sys.executable)
+
+    main_module = sys.modules.get("__main__")
+    if main_module:
+        script_path = getattr(main_module, "__file__", "")
+        if script_path:
+            return Path(script_path)
+
+    return None
+
+
+def _get_caller_path() -> Path | None:
+    """Get the path of the module calling into this package, if possible."""
+    package_path = _get_package_path()
+    for frame, _ in traceback.walk_stack(inspect.currentframe()):
+        if frame.f_code.co_filename:
+            module_path = Path(frame.f_code.co_filename)
+            if _exists(module_path) and not module_path.is_relative_to(package_path):
+                return module_path
+
+    return None
+
+
+# Path.exists() throws OSError when the path has invalid file characters.
+# https://github.com/python/cpython/issues/79487
+if sys.version_info >= (3, 10):
+
+    def _exists(path: Path) -> bool:
+        return path.exists()
+
+else:
+
+    def _exists(path: Path) -> bool:
+        import os
+
+        return os.path.exists(path)
+
+
+def _get_package_path() -> Path:
+    """Get the path of this package."""
+    module = sys.modules[__package__]
+    assert module.__file__ and module.__file__.endswith("__init__.py")
+    return Path(module.__file__).parent

nidaqmx-1.3.0.dev0/generated/nidaqmx/_feature_toggles.py

@@ -0,0 +1,162 @@
+"""nidaqmx feature toggles."""
+
+from __future__ import annotations
+
+import functools
+import sys
+from enum import Enum
+from typing import TYPE_CHECKING, Callable, TypeVar
+
+from decouple import AutoConfig, Undefined, undefined
+
+from nidaqmx._dotenvpath import get_dotenv_search_path
+from nidaqmx.errors import FeatureNotSupportedError
+
+if TYPE_CHECKING:
+    if sys.version_info >= (3, 10):
+        from typing import ParamSpec
+    else:
+        from typing_extensions import ParamSpec
+
+    if sys.version_info >= (3, 11):
+        from typing import Self
+    else:
+        from typing_extensions import Self
+
+    _P = ParamSpec("_P")
+    _T = TypeVar("_T")
+
+_PREFIX = "NIDAQMX"
+
+_config = AutoConfig(str(get_dotenv_search_path()))
+
+if TYPE_CHECKING:
+    # Work around decouple's lack of type hints.
+    def _config(
+        option: str,
+        default: _T | Undefined = undefined,
+        cast: Callable[[str], _T] | Undefined = undefined,
+    ) -> _T: ...
+
+
+# Based on the recipe at https://docs.python.org/3/howto/enum.html
+class _OrderedEnum(Enum):
+    def __ge__(self, other: Self) -> bool:
+        if self.__class__ is other.__class__:
+            return self.value >= other.value
+        return NotImplemented
+
+    def __gt__(self, other: Self) -> bool:
+        if self.__class__ is other.__class__:
+            return self.value > other.value
+        return NotImplemented
+
+    def __le__(self, other: Self) -> bool:
+        if self.__class__ is other.__class__:
+            return self.value <= other.value
+        return NotImplemented
+
+    def __lt__(self, other: Self) -> bool:
+        if self.__class__ is other.__class__:
+            return self.value < other.value
+        return NotImplemented
+
+
+class CodeReadiness(_OrderedEnum):
+    """Indicates whether code is ready to be supported."""
+
+    RELEASE = 0
+    NEXT_RELEASE = 1
+    INCOMPLETE = 2
+    PROTOTYPE = 3
+
+
+def _init_code_readiness_level() -> CodeReadiness:
+    if _config(f"{_PREFIX}_ALLOW_INCOMPLETE", default=False, cast=bool):
+        return CodeReadiness.INCOMPLETE
+    elif _config(f"{_PREFIX}_ALLOW_NEXT_RELEASE", default=False, cast=bool):
+        return CodeReadiness.NEXT_RELEASE
+    else:
+        return CodeReadiness.RELEASE
+
+
+# This is not public because `from _feature_toggles import CODE_READINESS_LEVEL`
+# is incompatible with the patching performed by the use_code_readiness mark.
+_CODE_READINESS_LEVEL = _init_code_readiness_level()
+
+
+def get_code_readiness_level() -> CodeReadiness:
+    """Get the current code readiness level.
+
+    You can override this in tests by specifying the ``use_code_readiness``
+    mark.
+    """
+    return _CODE_READINESS_LEVEL
+
+
+class FeatureToggle:
+    """A run-time feature toggle."""
+
+    name: str
+    """The name of the feature."""
+
+    readiness: CodeReadiness
+    """The code readiness at which this feature is enabled."""
+
+    def __init__(self, name: str, readiness: CodeReadiness) -> None:
+        """Initialize the feature toggle."""
+        assert name == name.upper()
+        self.name = name
+        self.readiness = readiness
+        self._is_enabled_override = None
+        # Only read the env var at initialization time.
+        if _config(f"{_PREFIX}_ENABLE_{name}", default=False, cast=bool):
+            self._is_enabled_override = True
+
+    @property
+    def is_enabled(self) -> bool:
+        """Indicates whether the feature is currently enabled.
+
+        You can enable/disable features in tests by specifying the
+        ``enable_feature_toggle`` or ``disable_feature_toggle`` marks.
+        """
+        if self._is_enabled_override is not None:
+            return self._is_enabled_override
+        return self.readiness <= get_code_readiness_level()
+
+    def raise_if_disabled(self) -> None:
+        """Raises an error if the feature is disabled."""
+        if self.is_enabled:
+            return
+
+        env_vars = f"{_PREFIX}_ENABLE_{self.name}"
+        if self.readiness in [CodeReadiness.NEXT_RELEASE, CodeReadiness.INCOMPLETE]:
+            env_vars += f" or {_PREFIX}_ALLOW_{self.readiness.name}"
+        message = (
+            f"The {self.name} feature is not supported at the current code readiness level. "
+            f" To enable it, set {env_vars}."
+        )
+        raise FeatureNotSupportedError(message)
+
+
+def requires_feature(
+    feature_toggle: FeatureToggle,
+) -> Callable[[Callable[_P, _T]], Callable[_P, _T]]:
+    """Decorator specifying that the function requires the specified feature toggle."""
+
+    def decorator(func: Callable[_P, _T]) -> Callable[_P, _T]:
+        @functools.wraps(func)
+        def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _T:
+            feature_toggle.raise_if_disabled()
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+# --------------------------------------
+# Define feature toggle constants here:
+# --------------------------------------
+
+WAVEFORM_SUPPORT = FeatureToggle("WAVEFORM_SUPPORT", CodeReadiness.INCOMPLETE)

{nidaqmx-1.2.0.dev1 → nidaqmx-1.3.0.dev0}/generated/nidaqmx/_grpc_interpreter.py

@@ -5,7 +5,8 @@ import logging
 import threading
 import typing
 import warnings
-from typing import Callable, Generic, TypeVar
+from nitypes.waveform import AnalogWaveform, DigitalWaveform
+from typing import Any, Callable, Generic, Sequence, TypeVar
 
 import google.protobuf.message
 from google.protobuf.timestamp_pb2 import Timestamp as GrpcTimestamp
@@ -17,6 +18,7 @@ from nidaqmx._base_interpreter import BaseEventHandler, BaseInterpreter
 from nidaqmx._stubs import nidaqmx_pb2 as grpc_types
 from nidaqmx._stubs import nidaqmx_pb2_grpc as nidaqmx_grpc
 from nidaqmx._stubs import session_pb2 as session_grpc_types
+from nidaqmx.constants import WaveformAttributeMode
 from nidaqmx.error_codes import DAQmxErrors
 from nidaqmx._grpc_time import convert_time_to_timestamp, convert_timestamp_to_time
 
@@ -3600,6 +3602,94 @@ class GrpcStubInterpreter(BaseInterpreter):
     def internal_get_last_created_chan(self):
         raise NotImplementedError
 
+    def read_analog_waveform(
+        self,
+        task_handle: object,
+        number_of_samples_per_channel: int,
+        timeout: float,
+        waveform: AnalogWaveform[numpy.float64],
+        waveform_attribute_mode: WaveformAttributeMode
+    ) -> int:
+        raise NotImplementedError
+
+    def read_analog_waveforms(
+        self,
+        task_handle: object,
+        number_of_samples_per_channel: int,
+        timeout: float,
+        waveforms: Sequence[AnalogWaveform[numpy.float64]],
+        waveform_attribute_mode: WaveformAttributeMode
+    ) -> int:
+        raise NotImplementedError
+
+    def read_digital_waveform(
+        self,
+        task_handle: object,
+        number_of_samples_per_channel: int,
+        timeout: float,
+        waveform: DigitalWaveform[Any],
+        waveform_attribute_mode: WaveformAttributeMode
+    ) -> int:
+        raise NotImplementedError
+
+    def read_digital_waveforms(
+        self,
+        task_handle: object,
+        channel_count: int,
+        number_of_samples_per_channel: int,
+        number_of_signals_per_sample: int,
+        timeout: float,
+        waveforms: Sequence[DigitalWaveform[Any]],
+        waveform_attribute_mode: WaveformAttributeMode,
+    ) -> int:
+        raise NotImplementedError
+
+    def read_new_digital_waveforms(
+        self,
+        task_handle: object,
+        channel_count: int,
+        number_of_samples_per_channel: int,
+        number_of_signals_per_sample: int,
+        timeout: float,
+        waveform_attribute_mode: WaveformAttributeMode,
+    ) -> Sequence[DigitalWaveform[numpy.uint8]]:
+        raise NotImplementedError
+
+    def write_analog_waveform(
+        self,
+        task_handle: object,
+        waveform: AnalogWaveform[typing.Any],
+        auto_start: bool,
+        timeout: float
+    ) -> int:
+        raise NotImplementedError
+
+    def write_analog_waveforms(
+        self,
+        task_handle: object,
+        waveforms: Sequence[AnalogWaveform[typing.Any]],
+        auto_start: bool,
+        timeout: float
+    ) -> int:
+        raise NotImplementedError
+
+    def write_digital_waveform(
+        self,
+        task_handle: object,
+        waveform: DigitalWaveform[Any],
+        auto_start: bool,
+        timeout: float,
+    ) -> int:
+        raise NotImplementedError
+
+    def write_digital_waveforms(
+        self,
+        task_handle: object,
+        waveform: Sequence[DigitalWaveform[Any]],
+        auto_start: bool,
+        timeout: float,
+    ) -> int:
+        raise NotImplementedError
 
 def _assign_numpy_array(numpy_array, grpc_array):
     """

{nidaqmx-1.2.0.dev1 → nidaqmx-1.3.0.dev0}/generated/nidaqmx/_grpc_time.py

@@ -1,14 +1,11 @@
 from __future__ import annotations
 
-from datetime import timezone
-from datetime import datetime as std_datetime
-from datetime import tzinfo as dt_tzinfo
-from hightime import datetime as ht_datetime
-from hightime import timedelta as ht_timedelta
-from typing import Optional, Union
-from nidaqmx._time import _convert_to_desired_timezone
+from datetime import datetime as std_datetime, timezone, tzinfo as dt_tzinfo
 
 from google.protobuf.timestamp_pb2 import Timestamp as GrpcTimestamp
+from hightime import datetime as ht_datetime, timedelta as ht_timedelta
+
+from nidaqmx._time import _convert_to_desired_timezone
 
 # 66 years, 17 leap days = 24107 days = 2082844800 seconds
 _BIAS_FROM_1970_EPOCH = 2082844800
@@ -22,7 +19,10 @@ _YS_PER_FS = 10**9
 
 _EPOCH_1970 = ht_datetime(1970, 1, 1, tzinfo=timezone.utc)
 
-def convert_time_to_timestamp(dt: std_datetime | ht_datetime, ts: GrpcTimestamp | None = None) -> GrpcTimestamp:
+
+def convert_time_to_timestamp(  # noqa: D103 - Missing docstring in public function (auto-generated noqa)
+    dt: std_datetime | ht_datetime, ts: GrpcTimestamp | None = None
+) -> GrpcTimestamp:
     seconds_since_1970 = 0
 
     if ts is None:
@@ -44,10 +44,13 @@ def convert_time_to_timestamp(dt: std_datetime | ht_datetime, ts: GrpcTimestamp
     ts.FromNanoseconds(seconds_since_1970 * _NS_PER_S + nanos)
     return ts
 
-def convert_timestamp_to_time(ts: GrpcTimestamp, tzinfo: dt_tzinfo | None = None) -> ht_datetime:
+
+def convert_timestamp_to_time(  # noqa: D103 - Missing docstring in public function (auto-generated noqa)
+    ts: GrpcTimestamp, tzinfo: dt_tzinfo | None = None
+) -> ht_datetime:
     total_nanos = ts.ToNanoseconds()
     seconds, nanos = divmod(total_nanos, _NS_PER_S)
     # Convert the nanoseconds to yoctoseconds.
     total_yoctoseconds = int(round(_YS_PER_NS * nanos))
-    dt = _EPOCH_1970 + ht_timedelta(seconds = seconds) + ht_timedelta(yoctoseconds=total_yoctoseconds)
+    dt = _EPOCH_1970 + ht_timedelta(seconds=seconds) + ht_timedelta(yoctoseconds=total_yoctoseconds)
     return _convert_to_desired_timezone(dt, tzinfo)