          self.image = image[self.top: self.bottom,
                             self.left: self.right]
  
      # <<< Aligned Face methods and properties >>> #
      def load_aligned(self, image, size=256, dtype=None, centering="head", force=False):
          """ Align a face from a given image.
  
          Aligning a face is a relatively expensive task and is not required for all uses of
          the :class:`~lib.align.DetectedFace` object, so call this function explicitly to
          load an aligned face.
 
</s> remove         logger.trace("Cropping face from image")
 </s> add         logger.trace("Cropping face from image")  # type: ignore </s> remove     def _image_to_face(self, image):
 </s> add     def _image_to_face(self, image: np.ndarray) -> None: </s> remove         return DetectedFace(x=int(round(left)),
                            w=int(round(right - left)),
                            y=int(round(top)),
                            h=int(round(bottom - top)))
 </s> add         return DetectedFace(left=int(round(left)),
                            width=int(round(right - left)),
                            top=int(round(top)),
                            height=int(round(bottom - top))) </s> remove 
 </s> add         is_aligned: bool, optional
            Indicates that the :attr:`image` is an aligned face rather than a frame.
            Default: ``False``
        is_legacy: bool, optional
            Only used if `is_aligned` is ``True``. ``True`` indicates that the aligned image being
            loaded is a legacy extracted face rather than a current head extracted face
    def load_aligned(self,
                     image: Optional[np.ndarray],
                     size: int = 256,
                     dtype: Optional[str] = None,
                     centering: "CenteringType" = "head",
                     coverage_ratio: float = 1.0,
                     force: bool = False,
                     is_aligned: bool = False,
                     is_legacy: bool = False) -> None:
          self.image = image[self.top: self.bottom,
                             self.left: self.right]
  
      # <<< Aligned Face methods and properties >>> #
    def load_aligned(self,
                     image: Optional[np.ndarray],
                     size: int = 256,
                     dtype: Optional[str] = None,
                     centering: "CenteringType" = "head",
                     coverage_ratio: float = 1.0,
                     force: bool = False,
                     is_aligned: bool = False,
                     is_legacy: bool = False) -> None:
          """ Align a face from a given image.
  
          Aligning a face is a relatively expensive task and is not required for all uses of
          the :class:`~lib.align.DetectedFace` object, so call this function explicitly to
          load an aligned face.
keep keep keep keep replace keep keep keep keep keep
 lib.align updates:
  - alignments.py
    - Add typed dicts for imported alignments
    - Explicitly check for presence of thumb value in alignments dict
    - linting
  - detected_face.py
    - Typing
    - Linting
    - Legacy support for pre-aligned face
    - Update dependencies to new property names 
lib/align/detected_face.py