adafruit · tekktrik · Sep 27, 2022 · Sep 22, 2022 · Sep 26, 2022 · Sep 27, 2022
diff --git a/adafruit_dps310/advanced.py b/adafruit_dps310/advanced.py
@@ -40,14 +40,21 @@
 from adafruit_register.i2c_bits import RWBits
 from adafruit_dps310.basic import DPS310
 
+try:
+    from typing import Iterable, Optional, Tuple, Union
+except ImportError:
+    pass
+
 # pylint: disable=no-member,unnecessary-pass
 
 
 class CV:
     """struct helper"""
 
     @classmethod
-    def add_values(cls, value_tuples):
+    def add_values(
+        cls, value_tuples: Iterable[Tuple[str, int, Union[str, int], Optional[float]]]
+    ):
         """Add CV values to the class"""
         cls.string = {}
         cls.lsb = {}
@@ -59,7 +66,7 @@ def add_values(cls, value_tuples):
             cls.lsb[value] = lsb
 
     @classmethod
-    def is_valid(cls, value):
+    def is_valid(cls, value: int) -> bool:
         """Validate that a given value is a member"""
         return value in cls.string
 
@@ -196,7 +203,7 @@ class DPS310_Advanced(DPS310):
     _pressure_ratebits = RWBits(3, _DPS310_PRSCFG, 4)
     _temp_ratebits = RWBits(3, _DPS310_TMPCFG, 4)
 
-    def initialize(self):
+    def initialize(self) -> None:
         """Initialize the sensor to continuous measurement"""
 
         self.reset()
@@ -212,11 +219,11 @@ def initialize(self):
         self.wait_pressure_ready()
 
     @property
-    def temperature_ready(self):
+    def temperature_ready(self) -> bool:
         """Returns true if there is a temperature reading ready"""
         return self._temp_ready
 
-    def wait_temperature_ready(self):
+    def wait_temperature_ready(self) -> None:
         """Wait until a temperature measurement is available.
 
         To avoid waiting indefinitely this function raises an
@@ -233,11 +240,11 @@ def wait_temperature_ready(self):
             sleep(0.001)
 
     @property
-    def pressure_ready(self):
+    def pressure_ready(self) -> bool:
         """Returns true if pressure readings are ready"""
         return self._pressure_ready
 
-    def wait_pressure_ready(self):
+    def wait_pressure_ready(self) -> None:
         """Wait until a pressure measurement is available
 
         To avoid waiting indefinitely this function raises an
@@ -254,35 +261,35 @@ def wait_pressure_ready(self):
             sleep(0.001)
 
     @property
-    def mode(self):
+    def mode(self) -> int:
         """The measurement mode. Must be a `Mode`. See the `Mode` documentation for details"""
         return self._mode_bits
 
     @mode.setter
-    def mode(self, value):
+    def mode(self, value: int) -> None:
         if not Mode.is_valid(value):
             raise AttributeError("mode must be an `Mode`")
 
         self._mode_bits = value
 
     @property
-    def pressure_rate(self):
+    def pressure_rate(self) -> int:
         """Configure the pressure measurement rate. Must be a `Rate`"""
         return self._pressure_ratebits
 
     @pressure_rate.setter
-    def pressure_rate(self, value):
+    def pressure_rate(self, value: int) -> None:
         if not Rate.is_valid(value):
             raise AttributeError("pressure_rate must be a Rate")
         self._pressure_ratebits = value
 
     @property
-    def pressure_oversample_count(self):
+    def pressure_oversample_count(self) -> int:
         """The number of samples taken per pressure measurement. Must be a ``SampleCount``"""
         return self._pressure_osbits
 
     @pressure_oversample_count.setter
-    def pressure_oversample_count(self, value):
+    def pressure_oversample_count(self, value: int) -> None:
         if not SampleCount.is_valid(value):
             raise AttributeError("pressure_oversample_count must be a SampleCount")
 
@@ -291,23 +298,23 @@ def pressure_oversample_count(self, value):
         self._pressure_scale = self._oversample_scalefactor[value]
 
     @property
-    def temperature_rate(self):
+    def temperature_rate(self) -> int:
         """Configure the temperature measurement rate. Must be a `Rate`"""
         return self._temp_ratebits
 
     @temperature_rate.setter
-    def temperature_rate(self, value):
+    def temperature_rate(self, value: int) -> None:
         if not Rate.is_valid(value):
             raise AttributeError("temperature_rate must be a Rate")
         self._temp_ratebits = value
 
     @property
-    def temperature_oversample_count(self):
+    def temperature_oversample_count(self) -> int:
         """The number of samples taken per temperature measurement. Must be a ``SampleCount``"""
         return self._temp_osbits
 
     @temperature_oversample_count.setter
-    def temperature_oversample_count(self, value):
+    def temperature_oversample_count(self, value: int) -> None:
         if not SampleCount.is_valid(value):
             raise AttributeError("temperature_oversample_count must be a SampleCount")
 

diff --git a/adafruit_dps310/basic.py b/adafruit_dps310/basic.py
@@ -43,6 +43,12 @@
 from adafruit_register.i2c_bit import RWBit, ROBit
 from adafruit_register.i2c_bits import RWBits, ROBits
 
+try:
+    import typing  # pylint: disable=unused-import
+    from busio import I2C
+except ImportError:
+    pass
+
 _DPS310_DEFAULT_ADDRESS = const(0x77)  # DPS310 default i2c address
 _DPS310_DEVICE_ID = const(0x10)  # DPS310 device identifier
 
@@ -118,7 +124,7 @@ class DPS310:
     _reg0f = RWBits(8, 0x0F, 0)
     _reg62 = RWBits(8, 0x62, 0)
 
-    def __init__(self, i2c_bus, address=_DPS310_DEFAULT_ADDRESS):
+    def __init__(self, i2c_bus: I2C, address: int = _DPS310_DEFAULT_ADDRESS) -> None:
         self.i2c_device = i2c_device.I2CDevice(i2c_bus, address)
 
         if self._device_id != _DPS310_DEVICE_ID:
@@ -150,7 +156,7 @@ def __init__(self, i2c_bus, address=_DPS310_DEFAULT_ADDRESS):
 
         self.initialize()
 
-    def initialize(self):
+    def initialize(self) -> None:
         """Initialize the sensor to continuous measurement"""
 
         self.reset()
@@ -171,7 +177,7 @@ def initialize(self):
 
     # (https://github.com/Infineon/DPS310-Pressure-Sensor#temperature-measurement-issue)
     # similar to DpsClass::correctTemp(void) from infineon's c++ library
-    def _correct_temp(self):
+    def _correct_temp(self) -> None:
         """Correct temperature readings on ICs with a fuse bit problem"""
         self._reg0e = 0xA5
         self._reg0f = 0x96
@@ -184,7 +190,7 @@ def _correct_temp(self):
         # and used for compensation when calculating pressure
         _unused = self._raw_temperature
 
-    def reset(self):
+    def reset(self) -> None:
         """Reset the sensor"""
         self._reset_register = 0x89
         # wait for hardware reset to finish
@@ -197,7 +203,7 @@ def reset(self):
         self._temp_measurement_src_bit = self._calib_coeff_temp_src_bit
 
     @property
-    def pressure(self):
+    def pressure(self) -> float:
         """Returns the current pressure reading in hectoPascals (hPa)"""
 
         temp_reading = self._raw_temperature
@@ -221,7 +227,7 @@ def pressure(self):
         return final_pressure
 
     @property
-    def altitude(self):
+    def altitude(self) -> float:
         """The altitude in meters based on the sea level pressure
         (:attr:`sea_level_pressure`) - which you must enter
         ahead of time
@@ -231,43 +237,43 @@ def altitude(self):
         )
 
     @property
-    def temperature(self):
+    def temperature(self) -> float:
         """The current temperature reading in degrees Celsius"""
         _scaled_rawtemp = self._raw_temperature / self._temp_scale
         _temperature = _scaled_rawtemp * self._c1 + self._c0 / 2.0
         return _temperature
 
     @property
-    def sea_level_pressure(self):
+    def sea_level_pressure(self) -> float:
         """The local sea level pressure in hectoPascals (aka millibars). This is used
         for calculation of :attr:`altitude`. Values are typically in the range
         980 - 1030."""
         return self._sea_level_pressure
 
     @sea_level_pressure.setter
-    def sea_level_pressure(self, value):
+    def sea_level_pressure(self, value: float) -> None:
         self._sea_level_pressure = value
 
-    def wait_temperature_ready(self):
+    def wait_temperature_ready(self) -> None:
         """Wait until a temperature measurement is available."""
 
         while self._temp_ready is False:
             sleep(0.001)
 
-    def wait_pressure_ready(self):
+    def wait_pressure_ready(self) -> None:
         """Wait until a pressure measurement is available"""
 
         while self._pressure_ready is False:
             sleep(0.001)
 
     @staticmethod
-    def _twos_complement(val, bits):
+    def _twos_complement(val: int, bits: int) -> int:
         if val & (1 << (bits - 1)):
             val -= 1 << bits
 
         return val
 
-    def _read_calibration(self):
+    def _read_calibration(self) -> None:
 
         while not self._coefficients_ready:
             sleep(0.001)