Merge pull request #17 from patenaud/type_annotations

Added type annotations

Author: FoamyGuy

adafruit_ov7670.py

@@ -35,9 +35,16 @@
 import imagecapture
 import pwmio
 from adafruit_bus_device.i2c_device import I2CDevice
-
 from micropython import const
 
+try:
+    from typing import List, Optional
+    from busio import I2C
+    from microcontroller import Pin
+    from circuitpython_typing import WriteableBuffer
+except ImportError:
+    pass
+
 # Supported color formats
 OV7670_COLOR_RGB = 0
 """RGB565 big-endian"""
@@ -503,19 +510,21 @@
 class OV7670:  # pylint: disable=too-many-instance-attributes
     """Library for the OV7670 digital camera"""
 
+    # pylint: disable=too-many-arguments
+
     def __init__(
         self,
-        i2c_bus,
-        data_pins,
-        clock,
-        vsync,
-        href,
-        shutdown=None,
-        reset=None,
-        mclk=None,
-        mclk_frequency=16_000_000,
-        i2c_address=0x21,
-    ):  # pylint: disable=too-many-arguments
+        i2c_bus: I2C,
+        data_pins: List[Pin],
+        clock: Pin,
+        vsync: Pin,
+        href: Pin,
+        shutdown: Optional[Pin] = None,
+        reset: Optional[Pin] = None,
+        mclk: Optional[Pin] = None,
+        mclk_frequency: int = 16_000_000,
+        i2c_address: int = 0x21,
+    ) -> None:
         """
         Args:
             i2c_bus (busio.I2C): The I2C bus used to configure the OV7670
@@ -584,7 +593,7 @@ def __init__(
             data_pins=data_pins, clock=clock, vsync=vsync, href=href
         )
 
-    def capture(self, buf):
+    def capture(self, buf: WriteableBuffer) -> None:
         """Capture an image into the buffer.
 
         Args:
@@ -594,7 +603,7 @@ def capture(self, buf):
         self._imagecapture.capture(buf)
 
     @property
-    def mclk_frequency(self):
+    def mclk_frequency(self) -> Optional[int]:
         """Get the actual frequency the generated mclk, or None"""
         return self._mclk_pwm.frequency if self._mclk_pwm else None
 
@@ -611,16 +620,16 @@ def height(self):
         return 480 >> self._size
 
     @property
-    def colorspace(self):
+    def colorspace(self) -> int:
         """Get or set the colorspace, one of the ``OV7670_COLOR_`` constants."""
         return self._colorspace
 
     @colorspace.setter
-    def colorspace(self, colorspace):
+    def colorspace(self, colorspace: int) -> None:
         self._colorspace = colorspace
         self._write_list(_OV7670_rgb if colorspace == OV7670_COLOR_RGB else _OV7670_yuv)
 
-    def deinit(self):
+    def deinit(self) -> None:
         """Deinitialize the camera"""
         self._imagecapture.deinit()
         if self._mclk_pwm:
@@ -631,7 +640,7 @@ def deinit(self):
             self._reset.deinit()
 
     @property
-    def size(self):
+    def size(self) -> int:
         """Get or set the captured image size, one of the ``OV7670_SIZE_`` constants."""
         return self._size
 
@@ -642,11 +651,11 @@ def size(self, size):
 
     @property
     def test_pattern(self):
-        """Get or set the test pattern, one of the ``OV7670_TES_PATTERN_`` constants."""
+        """Get or set the test pattern, one of the ``OV7670_TEST_PATTERN_`` constants."""
         return self._test_pattern
 
     @test_pattern.setter
-    def test_pattern(self, pattern):
+    def test_pattern(self, pattern: int) -> None:
         # Modify only test pattern bits (not scaling bits)
         xsc = self._read_register(_OV7670_REG_SCALING_XSC) & ~0x80
         ysc = self._read_register(_OV7670_REG_SCALING_YSC) & ~0x80
@@ -658,7 +667,7 @@ def test_pattern(self, pattern):
         self._write_register(_OV7670_REG_SCALING_XSC, xsc)
         self._write_register(_OV7670_REG_SCALING_YSC, ysc)
 
-    def _set_flip(self):
+    def _set_flip(self) -> None:
         mvfp = self._read_register(_OV7670_REG_MVFP)
         if self._flip_x:
             mvfp |= _OV7670_MVFP_MIRROR
@@ -671,60 +680,60 @@ def _set_flip(self):
         self._write_register(_OV7670_REG_MVFP, mvfp)
 
     @property
-    def flip_x(self):
+    def flip_x(self) -> bool:
         """Get or set the X-flip flag"""
         return self._flip_x
 
     @flip_x.setter
-    def flip_x(self, value):
+    def flip_x(self, value: bool) -> None:
         self._flip_x = bool(value)
         self._set_flip()
 
     @property
-    def flip_y(self):
+    def flip_y(self) -> bool:
         """Get or set the Y-flip flag"""
         return self._flip_y
 
     @flip_y.setter
-    def flip_y(self, value):
+    def flip_y(self, value: bool) -> None:
         self._flip_y = bool(value)
         self._set_flip()
 
     @property
-    def night(self):
+    def night(self) -> int:
         """Get or set the night-vision mode, one of the ``OV7670_NIGHT_MODE_`` constants."""
         return self._night
 
     @night.setter
-    def night(self, value):
+    def night(self, value: int) -> None:
         com11 = self._read_register(_OV7670_REG_COM11)
         com11 = (com11 & 0b00011111) | value
         self._write_register(_OV7670_REG_COM11, com11)
         self._night = value
 
     @property
-    def product_id(self):
+    def product_id(self) -> int:
         """Get the product id (PID) register.  The expected value is 0x76."""
         return self._read_register(_OV7670_REG_PID)
 
     @property
-    def product_version(self):
+    def product_version(self) -> int:
         """Get the version (VER) register.  The expected value is 0x73."""
         return self._read_register(_OV7670_REG_VER)
 
-    def _write_list(self, reg_list):
+    def _write_list(self, reg_list: bytes) -> None:
         for i in range(0, len(reg_list), 2):
             self._write_register(reg_list[i], reg_list[i + 1])
             time.sleep(0.001)
 
-    def _write_register(self, reg, value):
+    def _write_register(self, reg: int, value: int) -> None:
         b = bytearray(2)
         b[0] = reg
         b[1] = value
         with self._i2c_device as i2c:
             i2c.write(b)
 
-    def _read_register(self, reg):
+    def _read_register(self, reg: int) -> int:
         b = bytearray(1)
         b[0] = reg
         with self._i2c_device as i2c:
@@ -733,8 +742,8 @@ def _read_register(self, reg):
         return b[0]
 
     def _frame_control(
-        self, size, vstart, hstart, edge_offset, pclk_delay
-    ):  # pylint: disable=too-many-arguments
+        self, size: int, vstart: int, hstart: int, edge_offset: int, pclk_delay: int
+    ) -> None:  # pylint: disable=too-many-arguments
 
         # Enable downsampling if sub-VGA, and zoom if 1:16 scale
         value = _OV7670_COM3_DCWEN if (size > OV7670_SIZE_DIV1) else 0