diff --git a/MODELS.md b/MODELS.md
index 7ffa396..86338bd 100644
--- a/MODELS.md
+++ b/MODELS.md
@@ -208,8 +208,9 @@ landmarks = landmarker.get_landmarks(image, bbox)
 from uniface import AgeGender
 
 predictor = AgeGender()
-gender, age = predictor.predict(image, bbox)
-# Returns: ("Male"/"Female", age_in_years)
+gender_id, age = predictor.predict(image, bbox)
+# Returns: (gender_id, age_in_years)
+# gender_id: 0 for Female, 1 for Male
 ```
 
 ---
diff --git a/QUICKSTART.md b/QUICKSTART.md
index c065736..ab502ea 100644
--- a/QUICKSTART.md
+++ b/QUICKSTART.md
@@ -45,6 +45,7 @@ for i, face in enumerate(faces):
 ```
 
 **Output:**
+
 ```
 Face 1:
   Confidence: 0.99
@@ -122,6 +123,7 @@ else:
 ```
 
 **Similarity thresholds:**
+
 - `> 0.6`: Same person (high confidence)
 - `0.4 - 0.6`: Uncertain (manual review)
 - `< 0.4`: Different people
@@ -186,11 +188,13 @@ faces = detector.detect(image)
 
 # Predict attributes
 for i, face in enumerate(faces):
-    gender, age = age_gender.predict(image, face['bbox'])
+    gender_id, age = age_gender.predict(image, face['bbox'])
+    gender = 'Female' if gender_id == 0 else 'Male'
     print(f"Face {i+1}: {gender}, {age} years old")
 ```
 
 **Output:**
+
 ```
 Face 1: Male, 32 years old
 Face 2: Female, 28 years old
@@ -369,4 +373,3 @@ from uniface import retinaface  # Module, not class
 ---
 
 Happy coding! 🚀
-
diff --git a/README.md b/README.md
index 5f2c290..e02d061 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,11 @@
 # UniFace: All-in-One Face Analysis Library
 
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-![Python](https://img.shields.io/badge/Python-3.10%2B-blue)
-[![PyPI Version](https://img.shields.io/pypi/v/uniface.svg)](https://pypi.org/project/uniface/)
+[![Python](https://img.shields.io/badge/Python-3.10%2B-blue)](https://www.python.org/)
+[![PyPI](https://img.shields.io/pypi/v/uniface.svg)](https://pypi.org/project/uniface/)
 [![CI](https://github.com/yakhyo/uniface/actions/workflows/ci.yml/badge.svg)](https://github.com/yakhyo/uniface/actions)
 [![Downloads](https://pepy.tech/badge/uniface)](https://pepy.tech/project/uniface)
+[![Ruff](https://img.shields.io/badge/Ruff-Checked-red)](https://github.com/astral-sh/ruff)
 
 <div align="center">
     <img src=".github/logos/logo_web.webp" width=75%>
@@ -56,6 +57,7 @@ pip install uniface[gpu]
 ```
 
 **Requirements:**
+
 - CUDA 11.x or 12.x
 - cuDNN 8.x
 - See [ONNX Runtime GPU requirements](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html)
@@ -145,7 +147,8 @@ detector = RetinaFace()
 age_gender = AgeGender()
 
 faces = detector.detect(image)
-gender, age = age_gender.predict(image, faces[0]['bbox'])
+gender_id, age = age_gender.predict(image, faces[0]['bbox'])
+gender = 'Female' if gender_id == 0 else 'Male'
 print(f"{gender}, {age} years old")
 ```
 
@@ -217,17 +220,18 @@ faces = detect_faces(image, method='retinaface', conf_thresh=0.8)
 
 ### Face Detection (WIDER FACE Dataset)
 
-| Model              | Easy   | Medium | Hard   | Use Case                |
-|--------------------|--------|--------|--------|-------------------------|
-| retinaface_mnet025 | 88.48% | 87.02% | 80.61% | Mobile/Edge devices     |
-| retinaface_mnet_v2 | 91.70% | 91.03% | 86.60% | Balanced (recommended)  |
-| retinaface_r34     | 94.16% | 93.12% | 88.90% | High accuracy           |
-| scrfd_500m         | 90.57% | 88.12% | 68.51% | Real-time applications  |
-| scrfd_10g          | 95.16% | 93.87% | 83.05% | Best accuracy/speed     |
+| Model              | Easy   | Medium | Hard   | Use Case               |
+| ------------------ | ------ | ------ | ------ | ---------------------- |
+| retinaface_mnet025 | 88.48% | 87.02% | 80.61% | Mobile/Edge devices    |
+| retinaface_mnet_v2 | 91.70% | 91.03% | 86.60% | Balanced (recommended) |
+| retinaface_r34     | 94.16% | 93.12% | 88.90% | High accuracy          |
+| scrfd_500m         | 90.57% | 88.12% | 68.51% | Real-time applications |
+| scrfd_10g          | 95.16% | 93.87% | 83.05% | Best accuracy/speed    |
 
-*Accuracy values from original papers: [RetinaFace](https://arxiv.org/abs/1905.00641), [SCRFD](https://arxiv.org/abs/2105.04714)*
+_Accuracy values from original papers: [RetinaFace](https://arxiv.org/abs/1905.00641), [SCRFD](https://arxiv.org/abs/2105.04714)_
 
 **Benchmark on your hardware:**
+
 ```bash
 python scripts/run_detection.py --image assets/test.jpg --iterations 100
 ```
@@ -412,6 +416,7 @@ ruff check . --fix
 ```
 
 Ruff configuration is in `pyproject.toml`. Key settings:
+
 - Line length: 120
 - Python target: 3.10+
 - Import sorting: `uniface` as first-party
@@ -454,4 +459,3 @@ uniface/
 ## Contributing
 
 Contributions are welcome! Please open an issue or submit a pull request on [GitHub](https://github.com/yakhyo/uniface).
-
diff --git a/examples/face_alignment.ipynb b/examples/face_alignment.ipynb
index abae664..0c87540 100644
--- a/examples/face_alignment.ipynb
+++ b/examples/face_alignment.ipynb
@@ -43,7 +43,7 @@
     "\n",
     "from uniface.detection import RetinaFace\n",
     "from uniface.face_utils import face_alignment\n",
-    "from uniface.visualization import draw_detections\n"
+    "from uniface.visualization import draw_detections"
    ]
   },
   {
@@ -82,7 +82,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -95,11 +95,11 @@
    ],
    "source": [
     "image_paths = [\n",
-    "    \"../assets/test_images/image0.jpg\",\n",
-    "    \"../assets/test_images/image1.jpg\",\n",
-    "    \"../assets/test_images/image2.jpg\",\n",
-    "    \"../assets/test_images/image3.jpg\",\n",
-    "    \"../assets/test_images/image4.jpg\",\n",
+    "    '../assets/test_images/image0.jpg',\n",
+    "    '../assets/test_images/image1.jpg',\n",
+    "    '../assets/test_images/image2.jpg',\n",
+    "    '../assets/test_images/image3.jpg',\n",
+    "    '../assets/test_images/image4.jpg',\n",
     "]\n",
     "\n",
     "original_images = []\n",
@@ -110,24 +110,24 @@
     "    # Load image\n",
     "    image = cv2.imread(image_path)\n",
     "    if image is None:\n",
-    "        print(f\"Error: Could not read {image_path}\")\n",
+    "        print(f'Error: Could not read {image_path}')\n",
     "        continue\n",
     "\n",
     "    # Detect faces\n",
     "    faces = detector.detect(image)\n",
     "    if not faces:\n",
-    "        print(f\"No faces detected in {image_path}\")\n",
+    "        print(f'No faces detected in {image_path}')\n",
     "        continue\n",
     "\n",
     "    # Draw detections\n",
     "    bbox_image = image.copy()\n",
-    "    bboxes = [f[\"bbox\"] for f in faces]\n",
-    "    scores = [f[\"confidence\"] for f in faces]\n",
-    "    landmarks = [f[\"landmarks\"] for f in faces]\n",
+    "    bboxes = [f['bbox'] for f in faces]\n",
+    "    scores = [f['confidence'] for f in faces]\n",
+    "    landmarks = [f['landmarks'] for f in faces]\n",
     "    draw_detections(bbox_image, bboxes, scores, landmarks, vis_threshold=0.6)\n",
     "\n",
     "    # Align first detected face (returns aligned image and inverse transform matrix)\n",
-    "    first_landmarks = np.array(faces[0][\"landmarks\"])\n",
+    "    first_landmarks = faces[0]['landmarks']\n",
     "    aligned_image, _ = face_alignment(image, first_landmarks, image_size=112)\n",
     "\n",
     "    # Convert BGR to RGB for visualization\n",
@@ -135,7 +135,7 @@
     "    detection_images.append(cv2.cvtColor(bbox_image, cv2.COLOR_BGR2RGB))\n",
     "    aligned_images.append(cv2.cvtColor(aligned_image, cv2.COLOR_BGR2RGB))\n",
     "\n",
-    "print(f\"Processed {len(original_images)} images\")"
+    "print(f'Processed {len(original_images)} images')"
    ]
   },
   {
@@ -164,14 +164,14 @@
    "source": [
     "fig, axes = plt.subplots(3, len(original_images), figsize=(15, 10))\n",
     "\n",
-    "row_titles = [\"Original\", \"Detection\", \"Aligned\"]\n",
+    "row_titles = ['Original', 'Detection', 'Aligned']\n",
     "\n",
     "for row, images in enumerate([original_images, detection_images, aligned_images]):\n",
     "    for col, img in enumerate(images):\n",
     "        axes[row, col].imshow(img)\n",
-    "        axes[row, col].axis(\"off\")\n",
+    "        axes[row, col].axis('off')\n",
     "        if col == 0:\n",
-    "            axes[row, col].set_title(row_titles[row], fontsize=12, loc=\"left\")\n",
+    "            axes[row, col].set_title(row_titles[row], fontsize=12, loc='left')\n",
     "\n",
     "plt.tight_layout()\n",
     "plt.show()"
diff --git a/examples/face_analyzer.ipynb b/examples/face_analyzer.ipynb
new file mode 100644
index 0000000..a5543ae
--- /dev/null
+++ b/examples/face_analyzer.ipynb
@@ -0,0 +1,322 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cbbdf3a2",
+   "metadata": {},
+   "source": [
+    "# Face Analysis with UniFace\n",
+    "\n",
+    "This notebook demonstrates comprehensive face analysis using the **FaceAnalyzer** class.\n",
+    "\n",
+    "## 1. Install UniFace\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bb0037e2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install -q uniface\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb93156a",
+   "metadata": {},
+   "source": [
+    "## 2. Import Libraries\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "df9115e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from uniface import FaceAnalyzer, RetinaFace, ArcFace, AgeGender\n",
+    "from uniface.visualization import draw_detections\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3883457d",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "49346c0d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ Model loaded (CoreML (Apple Silicon))\n",
+      "✓ Model loaded (CoreML (Apple Silicon))\n",
+      "✓ Model loaded (CoreML (Apple Silicon))\n"
+     ]
+    }
+   ],
+   "source": [
+    "analyzer = FaceAnalyzer(\n",
+    "    detector=RetinaFace(),\n",
+    "    recognizer=ArcFace(),\n",
+    "    age_gender=AgeGender()\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bddc7700",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "1d32a1da",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "../assets/test_images/image0.jpg: Detected 1 face(s)\n",
+      "  Face 1: Female, 28y, conf=1.000\n",
+      "\n",
+      "../assets/test_images/image1.jpg: Detected 1 face(s)\n",
+      "  Face 1: Female, 29y, conf=1.000\n",
+      "\n",
+      "../assets/test_images/image2.jpg: Detected 1 face(s)\n",
+      "  Face 1: Female, 28y, conf=1.000\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_paths = [\n",
+    "    '../assets/test_images/image0.jpg',\n",
+    "    '../assets/test_images/image1.jpg',\n",
+    "    '../assets/test_images/image2.jpg',\n",
+    "]\n",
+    "\n",
+    "results = []\n",
+    "\n",
+    "for image_path in image_paths:\n",
+    "    # Load image\n",
+    "    image = cv2.imread(image_path)\n",
+    "    if image is None:\n",
+    "        print(f'Error: Could not read {image_path}')\n",
+    "        continue\n",
+    "\n",
+    "    # Analyze faces\n",
+    "    faces = analyzer.analyze(image)\n",
+    "\n",
+    "    print(f'\\n{image_path}: Detected {len(faces)} face(s)')\n",
+    "    for i, face in enumerate(faces, 1):\n",
+    "        print(f'  Face {i}: {face.gender}, {face.age}y, conf={face.confidence:.3f}')\n",
+    "\n",
+    "    # Prepare visualization\n",
+    "    vis_image = image.copy()\n",
+    "    bboxes = [f.bbox for f in faces]\n",
+    "    scores = [f.confidence for f in faces]\n",
+    "    landmarks = [f.landmarks for f in faces]\n",
+    "    draw_detections(vis_image, bboxes, scores, landmarks, vis_threshold=0.5)\n",
+    "\n",
+    "    # Add age/gender labels\n",
+    "    for i, face in enumerate(faces, 1):\n",
+    "        x1, y1 = int(face.bbox[0]), int(face.bbox[1])\n",
+    "        text = f'{face.gender}, {face.age}y'\n",
+    "        cv2.putText(vis_image, text, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)\n",
+    "\n",
+    "    results.append((image_path, cv2.cvtColor(vis_image, cv2.COLOR_BGR2RGB), faces))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "24f7d83a",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "5d072b12",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(1, len(results), figsize=(15, 5))\n",
+    "\n",
+    "for idx, (path, vis_image, faces) in enumerate(results):\n",
+    "    axes[idx].imshow(vis_image)\n",
+    "    axes[idx].axis('off')\n",
+    "    axes[idx].set_title(f'{len(faces)} face(s)', fontsize=10)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ab7272c",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "f5009932",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Face Attributes:\n",
+      "  - Bounding box: [88, 54, 442, 444]\n",
+      "  - Confidence: 1.000\n",
+      "  - Landmarks shape: (5, 2)\n",
+      "  - Age: 28 years\n",
+      "  - Gender string: Female\n",
+      "  - Embedding shape: (1, 512)\n",
+      "  - Embedding norm: 1D, L2-norm ≈ 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Get first face from first image\n",
+    "_, _, faces = results[0]\n",
+    "if faces:\n",
+    "    face = faces[0]\n",
+    "\n",
+    "    print('Face Attributes:')\n",
+    "    print(f'  - Bounding box: {face.bbox.astype(int).tolist()}')\n",
+    "    print(f'  - Confidence: {face.confidence:.3f}')\n",
+    "    print(f'  - Landmarks shape: {face.landmarks.shape}')\n",
+    "    print(f'  - Age: {face.age} years')\n",
+    "    print(f'  - Gender string: {face.gender}')\n",
+    "    print(f'  - Embedding shape: {face.embedding.shape}')\n",
+    "    print(f'  - Embedding norm: {face.embedding.shape[0]}D, L2-norm ≈ 1.0')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "154247c1",
+   "metadata": {},
+   "source": [
+    "## Notes\n",
+    "\n",
+    "- `analyzer.analyze()` performs detection, recognition, and attribute prediction in one call\n",
+    "- Gender is returned as integer ID: `0` for Female, `1` for Male\n",
+    "- Use `face.gender` property to get string representation (\"Female\" or \"Male\")\n",
+    "- Face embeddings are normalized (L2-norm ≈ 1.0) for similarity computation\n",
+    "- Use `face.compute_similarity(other_face)` to compare faces\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "c3cadebf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "face1 = faces[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "d7bb6975",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "face2 = faces[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "d3f5f834",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1, 512)"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "face1.embedding.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "1c8b72df",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9999901056289673"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "face1.compute_similarity(face2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4a970f13",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/face_detection.ipynb b/examples/face_detection.ipynb
index 6fd9416..6e18ed1 100644
--- a/examples/face_detection.ipynb
+++ b/examples/face_detection.ipynb
@@ -38,7 +38,7 @@
     "from PIL import Image\n",
     "\n",
     "from uniface.detection import RetinaFace\n",
-    "from uniface.visualization import draw_detections\n"
+    "from uniface.visualization import draw_detections"
    ]
   },
   {
@@ -94,7 +94,7 @@
     }
    ],
    "source": [
-    "image_path = \"../assets/test.jpg\"\n",
+    "image_path = '../assets/test.jpg'\n",
     "pil_image = Image.open(image_path)\n",
     "pil_image"
    ]
@@ -136,12 +136,12 @@
     "\n",
     "# Detect faces - returns list of face dictionaries\n",
     "faces = detector.detect(image)\n",
-    "print(f\"Detected {len(faces)} face(s)\")\n",
+    "print(f'Detected {len(faces)} face(s)')\n",
     "\n",
     "# Unpack face data for visualization\n",
-    "bboxes = [f[\"bbox\"] for f in faces]\n",
-    "scores = [f[\"confidence\"] for f in faces]\n",
-    "landmarks = [f[\"landmarks\"] for f in faces]\n",
+    "bboxes = [f['bbox'] for f in faces]\n",
+    "scores = [f['confidence'] for f in faces]\n",
+    "landmarks = [f['landmarks'] for f in faces]\n",
     "\n",
     "# Draw detections\n",
     "draw_detections(image, bboxes, scores, landmarks, vis_threshold=0.6)\n",
@@ -190,11 +190,11 @@
     "image = cv2.imread(image_path)\n",
     "\n",
     "faces = detector.detect(image, max_num=2)\n",
-    "print(f\"Detected {len(faces)} face(s)\")\n",
+    "print(f'Detected {len(faces)} face(s)')\n",
     "\n",
-    "bboxes = [f[\"bbox\"] for f in faces]\n",
-    "scores = [f[\"confidence\"] for f in faces]\n",
-    "landmarks = [f[\"landmarks\"] for f in faces]\n",
+    "bboxes = [f['bbox'] for f in faces]\n",
+    "scores = [f['confidence'] for f in faces]\n",
+    "landmarks = [f['landmarks'] for f in faces]\n",
     "\n",
     "draw_detections(image, bboxes, scores, landmarks, vis_threshold=0.6)\n",
     "\n",
@@ -237,11 +237,11 @@
     "image = cv2.imread(image_path)\n",
     "\n",
     "faces = detector.detect(image, max_num=5)\n",
-    "print(f\"Detected {len(faces)} face(s)\")\n",
+    "print(f'Detected {len(faces)} face(s)')\n",
     "\n",
-    "bboxes = [f[\"bbox\"] for f in faces]\n",
-    "scores = [f[\"confidence\"] for f in faces]\n",
-    "landmarks = [f[\"landmarks\"] for f in faces]\n",
+    "bboxes = [f['bbox'] for f in faces]\n",
+    "scores = [f['confidence'] for f in faces]\n",
+    "landmarks = [f['landmarks'] for f in faces]\n",
     "\n",
     "draw_detections(image, bboxes, scores, landmarks, vis_threshold=0.6)\n",
     "\n",
diff --git a/pyproject.toml b/pyproject.toml
index 6bc91cd..f829d8f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,12 +1,41 @@
 [project]
 name = "uniface"
-version = "1.1.1"
+version = "1.1.2"
 description = "UniFace: A Comprehensive Library for Face Detection, Recognition, Landmark Analysis, Age, and Gender Detection"
 readme = "README.md"
 license = { text = "MIT" }
-authors = [
-    { name = "Yakhyokhuja Valikhujaev", email = "yakhyo9696@gmail.com" }
+authors = [{ name = "Yakhyokhuja Valikhujaev", email = "yakhyo9696@gmail.com" }]
+maintainers = [
+    { name = "Yakhyokhuja Valikhujaev", email = "yakhyo9696@gmail.com" },
 ]
+
+requires-python = ">=3.10,<3.14"
+keywords = [
+    "face-detection",
+    "face-recognition",
+    "facial-landmarks",
+    "age-detection",
+    "gender-detection",
+    "computer-vision",
+    "deep-learning",
+    "onnx",
+    "onnxruntime",
+    "face-analysis",
+]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
 dependencies = [
     "numpy>=1.21.0",
     "opencv-python>=4.5.0",
@@ -14,9 +43,8 @@ dependencies = [
     "onnxruntime>=1.16.0",
     "scikit-image>=0.19.0",
     "requests>=2.28.0",
-    "tqdm>=4.64.0"
+    "tqdm>=4.64.0",
 ]
-requires-python = ">=3.10"
 
 [project.optional-dependencies]
 dev = ["pytest>=7.0.0", "ruff>=0.4.0"]
@@ -25,23 +53,46 @@ gpu = ["onnxruntime-gpu>=1.16.0"]
 [project.urls]
 Homepage = "https://github.com/yakhyo/uniface"
 Repository = "https://github.com/yakhyo/uniface"
+Documentation = "https://github.com/yakhyo/uniface/blob/main/README.md"
+"Quick Start" = "https://github.com/yakhyo/uniface/blob/main/QUICKSTART.md"
+"Model Zoo" = "https://github.com/yakhyo/uniface/blob/main/MODELS.md"
 
 [build-system]
 requires = ["setuptools>=64", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
-packages = { find = {} }
+packages = { find = { where = ["."], include = ["uniface*"] } }
 
 [tool.setuptools.package-data]
-"uniface" = ["*.txt", "*.md"]
+uniface = ["py.typed"]
 
 [tool.ruff]
 line-length = 120
 target-version = "py310"
+exclude = [
+    ".git",
+    ".ruff_cache",
+    "__pycache__",
+    "build",
+    "dist",
+    "*.egg-info",
+    ".venv",
+    "venv",
+    ".pytest_cache",
+    ".mypy_cache",
+    "*.ipynb",
+]
+
+[tool.ruff.format]
+quote-style = "single"
+
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "W"]
 
+[tool.ruff.lint.flake8-quotes]
+docstring-quotes = "double"
+
 [tool.ruff.lint.isort]
 known-first-party = ["uniface"]
diff --git a/scripts/README.md b/scripts/README.md
index 9052f3b..9c9f3c7 100644
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -8,8 +8,10 @@ Scripts for testing UniFace features.
 |--------|-------------|
 | `run_detection.py` | Face detection on image or webcam |
 | `run_age_gender.py` | Age and gender prediction |
+| `run_emotion.py` | Emotion detection (7 or 8 emotions) |
 | `run_landmarks.py` | 106-point facial landmark detection |
 | `run_recognition.py` | Face embedding extraction and comparison |
+| `run_face_analyzer.py` | Complete face analysis (detection + recognition + attributes) |
 | `run_face_search.py` | Real-time face matching against reference |
 | `run_video_detection.py` | Face detection on video files |
 | `batch_process.py` | Batch process folder of images |
@@ -27,6 +29,10 @@ python scripts/run_detection.py --webcam
 python scripts/run_age_gender.py --image assets/test.jpg
 python scripts/run_age_gender.py --webcam
 
+# Emotion detection
+python scripts/run_emotion.py --image assets/test.jpg
+python scripts/run_emotion.py --webcam
+
 # Landmarks
 python scripts/run_landmarks.py --image assets/test.jpg
 python scripts/run_landmarks.py --webcam
diff --git a/scripts/batch_process.py b/scripts/batch_process.py
index d67d21e..f06b751 100644
--- a/scripts/batch_process.py
+++ b/scripts/batch_process.py
@@ -14,8 +14,8 @@ from uniface.visualization import draw_detections
 def get_image_files(input_dir: Path, extensions: tuple) -> list:
     files = []
     for ext in extensions:
-        files.extend(input_dir.glob(f"*.{ext}"))
-        files.extend(input_dir.glob(f"*.{ext.upper()}"))
+        files.extend(input_dir.glob(f'*.{ext}'))
+        files.extend(input_dir.glob(f'*.{ext.upper()}'))
     return sorted(files)
 
 
@@ -28,14 +28,14 @@ def process_image(detector, image_path: Path, output_path: Path, threshold: floa
     faces = detector.detect(image)
 
     # unpack face data for visualization
-    bboxes = [f["bbox"] for f in faces]
-    scores = [f["confidence"] for f in faces]
-    landmarks = [f["landmarks"] for f in faces]
+    bboxes = [f['bbox'] for f in faces]
+    scores = [f['confidence'] for f in faces]
+    landmarks = [f['landmarks'] for f in faces]
     draw_detections(image, bboxes, scores, landmarks, vis_threshold=threshold)
 
     cv2.putText(
         image,
-        f"Faces: {len(faces)}",
+        f'Faces: {len(faces)}',
         (10, 30),
         cv2.FONT_HERSHEY_SIMPLEX,
         1,
@@ -48,12 +48,12 @@ def process_image(detector, image_path: Path, output_path: Path, threshold: floa
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Batch process images with face detection")
-    parser.add_argument("--input", type=str, required=True, help="Input directory")
-    parser.add_argument("--output", type=str, required=True, help="Output directory")
-    parser.add_argument("--detector", type=str, default="retinaface", choices=["retinaface", "scrfd"])
-    parser.add_argument("--threshold", type=float, default=0.6, help="Visualization threshold")
-    parser.add_argument("--extensions", type=str, default="jpg,jpeg,png,bmp", help="Image extensions")
+    parser = argparse.ArgumentParser(description='Batch process images with face detection')
+    parser.add_argument('--input', type=str, required=True, help='Input directory')
+    parser.add_argument('--output', type=str, required=True, help='Output directory')
+    parser.add_argument('--detector', type=str, default='retinaface', choices=['retinaface', 'scrfd'])
+    parser.add_argument('--threshold', type=float, default=0.6, help='Visualization threshold')
+    parser.add_argument('--extensions', type=str, default='jpg,jpeg,png,bmp', help='Image extensions')
     args = parser.parse_args()
 
     input_path = Path(args.input)
@@ -65,21 +65,21 @@ def main():
 
     output_path.mkdir(parents=True, exist_ok=True)
 
-    extensions = tuple(ext.strip() for ext in args.extensions.split(","))
+    extensions = tuple(ext.strip() for ext in args.extensions.split(','))
     image_files = get_image_files(input_path, extensions)
 
     if not image_files:
-        print(f"No images found with extensions {extensions}")
+        print(f'No images found with extensions {extensions}')
         return
 
-    print(f"Found {len(image_files)} images")
+    print(f'Found {len(image_files)} images')
 
-    detector = RetinaFace() if args.detector == "retinaface" else SCRFD()
+    detector = RetinaFace() if args.detector == 'retinaface' else SCRFD()
 
     success, errors, total_faces = 0, 0, 0
 
-    for img_path in tqdm(image_files, desc="Processing", unit="img"):
-        out_path = output_path / f"{img_path.stem}_detected{img_path.suffix}"
+    for img_path in tqdm(image_files, desc='Processing', unit='img'):
+        out_path = output_path / f'{img_path.stem}_detected{img_path.suffix}'
         result = process_image(detector, img_path, out_path, args.threshold)
 
         if result >= 0:
@@ -87,10 +87,10 @@ def main():
             total_faces += result
         else:
             errors += 1
-            print(f"\nFailed: {img_path.name}")
+            print(f'\nFailed: {img_path.name}')
 
-    print(f"\nDone! {success} processed, {errors} errors, {total_faces} faces total")
+    print(f'\nDone! {success} processed, {errors} errors, {total_faces} faces total')
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/scripts/download_model.py b/scripts/download_model.py
index c3768b0..28f5735 100644
--- a/scripts/download_model.py
+++ b/scripts/download_model.py
@@ -13,48 +13,48 @@ from uniface.constants import (
 from uniface.model_store import verify_model_weights
 
 MODEL_TYPES = {
-    "retinaface": RetinaFaceWeights,
-    "sphereface": SphereFaceWeights,
-    "mobileface": MobileFaceWeights,
-    "arcface": ArcFaceWeights,
-    "scrfd": SCRFDWeights,
-    "ddamfn": DDAMFNWeights,
-    "agegender": AgeGenderWeights,
-    "landmark": LandmarkWeights,
+    'retinaface': RetinaFaceWeights,
+    'sphereface': SphereFaceWeights,
+    'mobileface': MobileFaceWeights,
+    'arcface': ArcFaceWeights,
+    'scrfd': SCRFDWeights,
+    'ddamfn': DDAMFNWeights,
+    'agegender': AgeGenderWeights,
+    'landmark': LandmarkWeights,
 }
 
 
 def download_models(model_enum):
     for weight in model_enum:
-        print(f"Downloading: {weight.value}")
+        print(f'Downloading: {weight.value}')
         try:
             verify_model_weights(weight)
-            print(f"  Done: {weight.value}")
+            print(f'  Done: {weight.value}')
         except Exception as e:
-            print(f"  Failed: {e}")
+            print(f'  Failed: {e}')
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Download model weights")
+    parser = argparse.ArgumentParser(description='Download model weights')
     parser.add_argument(
-        "--model-type",
+        '--model-type',
         type=str,
         choices=list(MODEL_TYPES.keys()),
-        help="Model type to download. If not specified, downloads all.",
+        help='Model type to download. If not specified, downloads all.',
     )
     args = parser.parse_args()
 
     if args.model_type:
-        print(f"Downloading {args.model_type} models...")
+        print(f'Downloading {args.model_type} models...')
         download_models(MODEL_TYPES[args.model_type])
     else:
-        print("Downloading all models...")
+        print('Downloading all models...')
         for name, model_enum in MODEL_TYPES.items():
-            print(f"\n{name}:")
+            print(f'\n{name}:')
             download_models(model_enum)
 
-    print("\nDone!")
+    print('\nDone!')
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/scripts/run_age_gender.py b/scripts/run_age_gender.py
index 3681cb5..06bf9a7 100644
--- a/scripts/run_age_gender.py
+++ b/scripts/run_age_gender.py
@@ -12,10 +12,11 @@ from uniface import SCRFD, AgeGender, RetinaFace
 from uniface.visualization import draw_detections
 
 
-def draw_age_gender_label(image, bbox, gender: str, age: int):
+def draw_age_gender_label(image, bbox, gender_id: int, age: int):
     """Draw age/gender label above the bounding box."""
     x1, y1 = int(bbox[0]), int(bbox[1])
-    text = f"{gender}, {age}y"
+    gender_str = 'Female' if gender_id == 0 else 'Male'
+    text = f'{gender_str}, {age}y'
     (tw, th), _ = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
     cv2.rectangle(image, (x1, y1 - th - 10), (x1 + tw + 10, y1), (0, 255, 0), -1)
     cv2.putText(image, text, (x1 + 5, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 0), 2)
@@ -25,7 +26,7 @@ def process_image(
     detector,
     age_gender,
     image_path: str,
-    save_dir: str = "outputs",
+    save_dir: str = 'outputs',
     threshold: float = 0.6,
 ):
     image = cv2.imread(image_path)
@@ -34,31 +35,32 @@ def process_image(
         return
 
     faces = detector.detect(image)
-    print(f"Detected {len(faces)} face(s)")
+    print(f'Detected {len(faces)} face(s)')
 
     if not faces:
         return
 
-    bboxes = [f["bbox"] for f in faces]
-    scores = [f["confidence"] for f in faces]
-    landmarks = [f["landmarks"] for f in faces]
+    bboxes = [f['bbox'] for f in faces]
+    scores = [f['confidence'] for f in faces]
+    landmarks = [f['landmarks'] for f in faces]
     draw_detections(image, bboxes, scores, landmarks, vis_threshold=threshold)
 
     for i, face in enumerate(faces):
-        gender, age = age_gender.predict(image, face["bbox"])
-        print(f"  Face {i + 1}: {gender}, {age} years old")
-        draw_age_gender_label(image, face["bbox"], gender, age)
+        gender_id, age = age_gender.predict(image, face['bbox'])
+        gender_str = 'Female' if gender_id == 0 else 'Male'
+        print(f'  Face {i + 1}: {gender_str}, {age} years old')
+        draw_age_gender_label(image, face['bbox'], gender_id, age)
 
     os.makedirs(save_dir, exist_ok=True)
-    output_path = os.path.join(save_dir, f"{Path(image_path).stem}_age_gender.jpg")
+    output_path = os.path.join(save_dir, f'{Path(image_path).stem}_age_gender.jpg')
     cv2.imwrite(output_path, image)
-    print(f"Output saved: {output_path}")
+    print(f'Output saved: {output_path}')
 
 
 def run_webcam(detector, age_gender, threshold: float = 0.6):
     cap = cv2.VideoCapture(0)  # 0 = default webcam
     if not cap.isOpened():
-        print("Cannot open webcam")
+        print('Cannot open webcam')
         return
 
     print("Press 'q' to quit")
@@ -72,27 +74,27 @@ def run_webcam(detector, age_gender, threshold: float = 0.6):
         faces = detector.detect(frame)
 
         # unpack face data for visualization
-        bboxes = [f["bbox"] for f in faces]
-        scores = [f["confidence"] for f in faces]
-        landmarks = [f["landmarks"] for f in faces]
+        bboxes = [f['bbox'] for f in faces]
+        scores = [f['confidence'] for f in faces]
+        landmarks = [f['landmarks'] for f in faces]
         draw_detections(frame, bboxes, scores, landmarks, vis_threshold=threshold)
 
         for face in faces:
-            gender, age = age_gender.predict(frame, face["bbox"])  # predict per face
-            draw_age_gender_label(frame, face["bbox"], gender, age)
+            gender_id, age = age_gender.predict(frame, face['bbox'])  # predict per face
+            draw_age_gender_label(frame, face['bbox'], gender_id, age)
 
         cv2.putText(
             frame,
-            f"Faces: {len(faces)}",
+            f'Faces: {len(faces)}',
             (10, 30),
             cv2.FONT_HERSHEY_SIMPLEX,
             1,
             (0, 255, 0),
             2,
         )
-        cv2.imshow("Age & Gender Detection", frame)
+        cv2.imshow('Age & Gender Detection', frame)
 
-        if cv2.waitKey(1) & 0xFF == ord("q"):
+        if cv2.waitKey(1) & 0xFF == ord('q'):
             break
 
     cap.release()
@@ -100,18 +102,18 @@ def run_webcam(detector, age_gender, threshold: float = 0.6):
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Run age and gender detection")
-    parser.add_argument("--image", type=str, help="Path to input image")
-    parser.add_argument("--webcam", action="store_true", help="Use webcam")
-    parser.add_argument("--detector", type=str, default="retinaface", choices=["retinaface", "scrfd"])
-    parser.add_argument("--threshold", type=float, default=0.6, help="Visualization threshold")
-    parser.add_argument("--save_dir", type=str, default="outputs")
+    parser = argparse.ArgumentParser(description='Run age and gender detection')
+    parser.add_argument('--image', type=str, help='Path to input image')
+    parser.add_argument('--webcam', action='store_true', help='Use webcam')
+    parser.add_argument('--detector', type=str, default='retinaface', choices=['retinaface', 'scrfd'])
+    parser.add_argument('--threshold', type=float, default=0.6, help='Visualization threshold')
+    parser.add_argument('--save_dir', type=str, default='outputs')
     args = parser.parse_args()
 
     if not args.image and not args.webcam:
-        parser.error("Either --image or --webcam must be specified")
+        parser.error('Either --image or --webcam must be specified')
 
-    detector = RetinaFace() if args.detector == "retinaface" else SCRFD()
+    detector = RetinaFace() if args.detector == 'retinaface' else SCRFD()
     age_gender = AgeGender()
 
     if args.webcam:
@@ -120,5 +122,5 @@ def main():
         process_image(detector, age_gender, args.image, args.save_dir, args.threshold)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/scripts/run_detection.py b/scripts/run_detection.py
index d946864..ac8a8b5 100644
--- a/scripts/run_detection.py
+++ b/scripts/run_detection.py
@@ -11,7 +11,7 @@ from uniface.detection import SCRFD, RetinaFace
 from uniface.visualization import draw_detections
 
 
-def process_image(detector, image_path: str, threshold: float = 0.6, save_dir: str = "outputs"):
+def process_image(detector, image_path: str, threshold: float = 0.6, save_dir: str = 'outputs'):
     image = cv2.imread(image_path)
     if image is None:
         print(f"Error: Failed to load image from '{image_path}'")
@@ -20,21 +20,21 @@ def process_image(detector, image_path: str, threshold: float = 0.6, save_dir: s
     faces = detector.detect(image)
 
     if faces:
-        bboxes = [face["bbox"] for face in faces]
-        scores = [face["confidence"] for face in faces]
-        landmarks = [face["landmarks"] for face in faces]
+        bboxes = [face['bbox'] for face in faces]
+        scores = [face['confidence'] for face in faces]
+        landmarks = [face['landmarks'] for face in faces]
         draw_detections(image, bboxes, scores, landmarks, vis_threshold=threshold)
 
     os.makedirs(save_dir, exist_ok=True)
-    output_path = os.path.join(save_dir, f"{os.path.splitext(os.path.basename(image_path))[0]}_out.jpg")
+    output_path = os.path.join(save_dir, f'{os.path.splitext(os.path.basename(image_path))[0]}_out.jpg')
     cv2.imwrite(output_path, image)
-    print(f"Output saved: {output_path}")
+    print(f'Output saved: {output_path}')
 
 
 def run_webcam(detector, threshold: float = 0.6):
     cap = cv2.VideoCapture(0)  # 0 = default webcam
     if not cap.isOpened():
-        print("Cannot open webcam")
+        print('Cannot open webcam')
         return
 
     print("Press 'q' to quit")
@@ -48,23 +48,23 @@ def run_webcam(detector, threshold: float = 0.6):
         faces = detector.detect(frame)
 
         # unpack face data for visualization
-        bboxes = [f["bbox"] for f in faces]
-        scores = [f["confidence"] for f in faces]
-        landmarks = [f["landmarks"] for f in faces]
+        bboxes = [f['bbox'] for f in faces]
+        scores = [f['confidence'] for f in faces]
+        landmarks = [f['landmarks'] for f in faces]
         draw_detections(frame, bboxes, scores, landmarks, vis_threshold=threshold)
 
         cv2.putText(
             frame,
-            f"Faces: {len(faces)}",
+            f'Faces: {len(faces)}',
             (10, 30),
             cv2.FONT_HERSHEY_SIMPLEX,
             1,
             (0, 255, 0),
             2,
         )
-        cv2.imshow("Face Detection", frame)
+        cv2.imshow('Face Detection', frame)
 
-        if cv2.waitKey(1) & 0xFF == ord("q"):
+        if cv2.waitKey(1) & 0xFF == ord('q'):
             break
 
     cap.release()
@@ -72,18 +72,18 @@ def run_webcam(detector, threshold: float = 0.6):
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Run face detection")
-    parser.add_argument("--image", type=str, help="Path to input image")
-    parser.add_argument("--webcam", action="store_true", help="Use webcam")
-    parser.add_argument("--method", type=str, default="retinaface", choices=["retinaface", "scrfd"])
-    parser.add_argument("--threshold", type=float, default=0.6, help="Visualization threshold")
-    parser.add_argument("--save_dir", type=str, default="outputs")
+    parser = argparse.ArgumentParser(description='Run face detection')
+    parser.add_argument('--image', type=str, help='Path to input image')
+    parser.add_argument('--webcam', action='store_true', help='Use webcam')
+    parser.add_argument('--method', type=str, default='retinaface', choices=['retinaface', 'scrfd'])
+    parser.add_argument('--threshold', type=float, default=0.6, help='Visualization threshold')
+    parser.add_argument('--save_dir', type=str, default='outputs')
     args = parser.parse_args()
 
     if not args.image and not args.webcam:
-        parser.error("Either --image or --webcam must be specified")
+        parser.error('Either --image or --webcam must be specified')
 
-    detector = RetinaFace() if args.method == "retinaface" else SCRFD()
+    detector = RetinaFace() if args.method == 'retinaface' else SCRFD()
 
     if args.webcam:
         run_webcam(detector, args.threshold)
@@ -91,5 +91,5 @@ def main():
         process_image(detector, args.image, args.threshold, args.save_dir)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/scripts/run_emotion.py b/scripts/run_emotion.py
new file mode 100644
index 0000000..a11253f
--- /dev/null
+++ b/scripts/run_emotion.py
@@ -0,0 +1,124 @@
+# Emotion detection on detected faces
+# Usage: python run_emotion.py --image path/to/image.jpg
+#        python run_emotion.py --webcam
+
+import argparse
+import os
+from pathlib import Path
+
+import cv2
+
+from uniface import SCRFD, Emotion, RetinaFace
+from uniface.visualization import draw_detections
+
+
+def draw_emotion_label(image, bbox, emotion: str, confidence: float):
+    """Draw emotion label above the bounding box."""
+    x1, y1 = int(bbox[0]), int(bbox[1])
+    text = f'{emotion} ({confidence:.2f})'
+    (tw, th), _ = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
+    cv2.rectangle(image, (x1, y1 - th - 10), (x1 + tw + 10, y1), (255, 0, 0), -1)
+    cv2.putText(image, text, (x1 + 5, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+
+
+def process_image(
+    detector,
+    emotion_predictor,
+    image_path: str,
+    save_dir: str = 'outputs',
+    threshold: float = 0.6,
+):
+    image = cv2.imread(image_path)
+    if image is None:
+        print(f"Error: Failed to load image from '{image_path}'")
+        return
+
+    faces = detector.detect(image)
+    print(f'Detected {len(faces)} face(s)')
+
+    if not faces:
+        return
+
+    bboxes = [f['bbox'] for f in faces]
+    scores = [f['confidence'] for f in faces]
+    landmarks = [f['landmarks'] for f in faces]
+    draw_detections(image, bboxes, scores, landmarks, vis_threshold=threshold)
+
+    for i, face in enumerate(faces):
+        emotion, confidence = emotion_predictor.predict(image, face['landmarks'])
+        print(f'  Face {i + 1}: {emotion} (confidence: {confidence:.3f})')
+        draw_emotion_label(image, face['bbox'], emotion, confidence)
+
+    os.makedirs(save_dir, exist_ok=True)
+    output_path = os.path.join(save_dir, f'{Path(image_path).stem}_emotion.jpg')
+    cv2.imwrite(output_path, image)
+    print(f'Output saved: {output_path}')
+
+
+def run_webcam(detector, emotion_predictor, threshold: float = 0.6):
+    cap = cv2.VideoCapture(0)  # 0 = default webcam
+    if not cap.isOpened():
+        print('Cannot open webcam')
+        return
+
+    print("Press 'q' to quit")
+
+    while True:
+        ret, frame = cap.read()
+        frame = cv2.flip(frame, 1)  # mirror for natural interaction
+        if not ret:
+            break
+
+        faces = detector.detect(frame)
+
+        # unpack face data for visualization
+        bboxes = [f['bbox'] for f in faces]
+        scores = [f['confidence'] for f in faces]
+        landmarks = [f['landmarks'] for f in faces]
+        draw_detections(frame, bboxes, scores, landmarks, vis_threshold=threshold)
+
+        for face in faces:
+            emotion, confidence = emotion_predictor.predict(frame, face['landmarks'])
+            draw_emotion_label(frame, face['bbox'], emotion, confidence)
+
+        cv2.putText(
+            frame,
+            f'Faces: {len(faces)}',
+            (10, 30),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1,
+            (0, 255, 0),
+            2,
+        )
+        cv2.imshow('Emotion Detection', frame)
+
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Run emotion detection')
+    parser.add_argument('--image', type=str, help='Path to input image')
+    parser.add_argument('--webcam', action='store_true', help='Use webcam')
+    parser.add_argument('--detector', type=str, default='retinaface', choices=['retinaface', 'scrfd'])
+    parser.add_argument('--threshold', type=float, default=0.6, help='Visualization threshold')
+    parser.add_argument('--save_dir', type=str, default='outputs')
+    args = parser.parse_args()
+
+    if not args.image and not args.webcam:
+        parser.error('Either --image or --webcam must be specified')
+
+    detector = RetinaFace() if args.detector == 'retinaface' else SCRFD()
+    emotion_predictor = Emotion()
+
+    if args.webcam:
+        run_webcam(detector, emotion_predictor, args.threshold)
+    else:
+        process_image(detector, emotion_predictor, args.image, args.save_dir, args.threshold)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/run_face_analyzer.py b/scripts/run_face_analyzer.py
new file mode 100644
index 0000000..3f10f20
--- /dev/null
+++ b/scripts/run_face_analyzer.py
@@ -0,0 +1,116 @@
+# Face analysis using FaceAnalyzer
+# Usage: python run_face_analyzer.py --image path/to/image.jpg
+
+import argparse
+import os
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+from uniface import AgeGender, ArcFace, FaceAnalyzer, RetinaFace
+from uniface.visualization import draw_detections
+
+
+def draw_face_info(image, face, face_id):
+    """Draw face ID and attributes above bounding box."""
+    x1, y1, x2, y2 = map(int, face.bbox)
+    lines = [f'ID: {face_id}', f'Conf: {face.confidence:.2f}']
+    if face.age and face.gender:
+        lines.append(f'{face.gender}, {face.age}y')
+
+    for i, line in enumerate(lines):
+        y_pos = y1 - 10 - (len(lines) - 1 - i) * 25
+        if y_pos < 20:
+            y_pos = y2 + 20 + i * 25
+        (tw, th), _ = cv2.getTextSize(line, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
+        cv2.rectangle(image, (x1, y_pos - th - 5), (x1 + tw + 10, y_pos + 5), (0, 255, 0), -1)
+        cv2.putText(image, line, (x1 + 5, y_pos), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 0), 2)
+
+
+def process_image(analyzer, image_path: str, save_dir: str = 'outputs', show_similarity: bool = True):
+    image = cv2.imread(image_path)
+    if image is None:
+        print(f"Error: Failed to load image from '{image_path}'")
+        return
+
+    faces = analyzer.analyze(image)
+    print(f'Detected {len(faces)} face(s)')
+
+    if not faces:
+        return
+
+    for i, face in enumerate(faces, 1):
+        info = f'  Face {i}: {face.gender}, {face.age}y' if face.age and face.gender else f'  Face {i}'
+        if face.embedding is not None:
+            info += f' (embedding: {face.embedding.shape})'
+        print(info)
+
+    if show_similarity and len(faces) >= 2:
+        print('\nSimilarity Matrix:')
+        n = len(faces)
+        sim_matrix = np.zeros((n, n))
+
+        for i in range(n):
+            for j in range(i, n):
+                if i == j:
+                    sim_matrix[i][j] = 1.0
+                else:
+                    sim = faces[i].compute_similarity(faces[j])
+                    sim_matrix[i][j] = sim
+                    sim_matrix[j][i] = sim
+
+        print('     ', end='')
+        for i in range(n):
+            print(f'  F{i + 1:2d}  ', end='')
+        print('\n     ' + '-' * (7 * n))
+
+        for i in range(n):
+            print(f'F{i + 1:2d} | ', end='')
+            for j in range(n):
+                print(f'{sim_matrix[i][j]:6.3f} ', end='')
+            print()
+
+        pairs = [(i, j, sim_matrix[i][j]) for i in range(n) for j in range(i + 1, n)]
+        pairs.sort(key=lambda x: x[2], reverse=True)
+
+        print('\nTop matches (>0.4 = same person):')
+        for i, j, sim in pairs[:3]:
+            status = 'Same' if sim > 0.4 else 'Different'
+            print(f'  Face {i + 1} ↔ Face {j + 1}: {sim:.3f} ({status})')
+
+    bboxes = [f.bbox for f in faces]
+    scores = [f.confidence for f in faces]
+    landmarks = [f.landmarks for f in faces]
+    draw_detections(image, bboxes, scores, landmarks)
+
+    for i, face in enumerate(faces, 1):
+        draw_face_info(image, face, i)
+
+    os.makedirs(save_dir, exist_ok=True)
+    output_path = os.path.join(save_dir, f'{Path(image_path).stem}_analysis.jpg')
+    cv2.imwrite(output_path, image)
+    print(f'Output saved: {output_path}')
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Face analysis with detection, recognition, and attributes')
+    parser.add_argument('--image', type=str, required=True, help='Path to input image')
+    parser.add_argument('--save_dir', type=str, default='outputs', help='Output directory')
+    parser.add_argument('--no-similarity', action='store_true', help='Skip similarity matrix computation')
+    args = parser.parse_args()
+
+    if not os.path.exists(args.image):
+        print(f'Error: Image not found: {args.image}')
+        return
+
+    detector = RetinaFace()
+    recognizer = ArcFace()
+    age_gender = AgeGender()
+    analyzer = FaceAnalyzer(detector, recognizer, age_gender)
+
+    process_image(analyzer, args.image, args.save_dir, show_similarity=not args.no_similarity)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/run_face_search.py b/scripts/run_face_search.py
index 3a026a2..de63d2c 100644
--- a/scripts/run_face_search.py
+++ b/scripts/run_face_search.py
@@ -12,9 +12,9 @@ from uniface.recognition import ArcFace, MobileFace, SphereFace
 
 
 def get_recognizer(name: str):
-    if name == "arcface":
+    if name == 'arcface':
         return ArcFace()
-    elif name == "mobileface":
+    elif name == 'mobileface':
         return MobileFace()
     else:
         return SphereFace()
@@ -23,20 +23,20 @@ def get_recognizer(name: str):
 def extract_reference_embedding(detector, recognizer, image_path: str) -> np.ndarray:
     image = cv2.imread(image_path)
     if image is None:
-        raise RuntimeError(f"Failed to load image: {image_path}")
+        raise RuntimeError(f'Failed to load image: {image_path}')
 
     faces = detector.detect(image)
     if not faces:
-        raise RuntimeError("No faces found in reference image.")
+        raise RuntimeError('No faces found in reference image.')
 
-    landmarks = np.array(faces[0]["landmarks"])
+    landmarks = faces[0]['landmarks']
     return recognizer.get_normalized_embedding(image, landmarks)
 
 
 def run_webcam(detector, recognizer, ref_embedding: np.ndarray, threshold: float = 0.4):
     cap = cv2.VideoCapture(0)  # 0 = default webcam
     if not cap.isOpened():
-        raise RuntimeError("Webcam could not be opened.")
+        raise RuntimeError('Webcam could not be opened.')
 
     print("Press 'q' to quit")
 
@@ -49,22 +49,22 @@ def run_webcam(detector, recognizer, ref_embedding: np.ndarray, threshold: float
         faces = detector.detect(frame)
 
         for face in faces:
-            bbox = face["bbox"]
-            landmarks = np.array(face["landmarks"])
+            bbox = face['bbox']
+            landmarks = face['landmarks']
             x1, y1, x2, y2 = map(int, bbox)
 
             embedding = recognizer.get_normalized_embedding(frame, landmarks)
             sim = compute_similarity(ref_embedding, embedding)  # compare with reference
 
             # green = match, red = unknown
-            label = f"Match ({sim:.2f})" if sim > threshold else f"Unknown ({sim:.2f})"
+            label = f'Match ({sim:.2f})' if sim > threshold else f'Unknown ({sim:.2f})'
             color = (0, 255, 0) if sim > threshold else (0, 0, 255)
 
             cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
             cv2.putText(frame, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
 
-        cv2.imshow("Face Recognition", frame)
-        if cv2.waitKey(1) & 0xFF == ord("q"):
+        cv2.imshow('Face Recognition', frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
             break
 
     cap.release()
@@ -72,26 +72,26 @@ def run_webcam(detector, recognizer, ref_embedding: np.ndarray, threshold: float
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Face search using a reference image")
-    parser.add_argument("--image", type=str, required=True, help="Reference face image")
-    parser.add_argument("--threshold", type=float, default=0.4, help="Match threshold")
-    parser.add_argument("--detector", type=str, default="scrfd", choices=["retinaface", "scrfd"])
+    parser = argparse.ArgumentParser(description='Face search using a reference image')
+    parser.add_argument('--image', type=str, required=True, help='Reference face image')
+    parser.add_argument('--threshold', type=float, default=0.4, help='Match threshold')
+    parser.add_argument('--detector', type=str, default='scrfd', choices=['retinaface', 'scrfd'])
     parser.add_argument(
-        "--recognizer",
+        '--recognizer',
         type=str,
-        default="arcface",
-        choices=["arcface", "mobileface", "sphereface"],
+        default='arcface',
+        choices=['arcface', 'mobileface', 'sphereface'],
     )
     args = parser.parse_args()
 
-    detector = RetinaFace() if args.detector == "retinaface" else SCRFD()
+    detector = RetinaFace() if args.detector == 'retinaface' else SCRFD()
     recognizer = get_recognizer(args.recognizer)
 
-    print(f"Loading reference: {args.image}")
+    print(f'Loading reference: {args.image}')
     ref_embedding = extract_reference_embedding(detector, recognizer, args.image)
 
     run_webcam(detector, recognizer, ref_embedding, args.threshold)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/scripts/run_landmarks.py b/scripts/run_landmarks.py
index 3f979a7..677d929 100644
--- a/scripts/run_landmarks.py
+++ b/scripts/run_landmarks.py
@@ -11,32 +11,32 @@ import cv2
 from uniface import SCRFD, Landmark106, RetinaFace
 
 
-def process_image(detector, landmarker, image_path: str, save_dir: str = "outputs"):
+def process_image(detector, landmarker, image_path: str, save_dir: str = 'outputs'):
     image = cv2.imread(image_path)
     if image is None:
         print(f"Error: Failed to load image from '{image_path}'")
         return
 
     faces = detector.detect(image)
-    print(f"Detected {len(faces)} face(s)")
+    print(f'Detected {len(faces)} face(s)')
 
     if not faces:
         return
 
     for i, face in enumerate(faces):
-        bbox = face["bbox"]
+        bbox = face['bbox']
         x1, y1, x2, y2 = map(int, bbox)
         cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
 
         landmarks = landmarker.get_landmarks(image, bbox)
-        print(f"  Face {i + 1}: {len(landmarks)} landmarks")
+        print(f'  Face {i + 1}: {len(landmarks)} landmarks')
 
         for x, y in landmarks.astype(int):
             cv2.circle(image, (x, y), 1, (0, 255, 0), -1)
 
         cv2.putText(
             image,
-            f"Face {i + 1}",
+            f'Face {i + 1}',
             (x1, y1 - 10),
             cv2.FONT_HERSHEY_SIMPLEX,
             0.5,
@@ -45,15 +45,15 @@ def process_image(detector, landmarker, image_path: str, save_dir: str = "output
         )
 
     os.makedirs(save_dir, exist_ok=True)
-    output_path = os.path.join(save_dir, f"{Path(image_path).stem}_landmarks.jpg")
+    output_path = os.path.join(save_dir, f'{Path(image_path).stem}_landmarks.jpg')
     cv2.imwrite(output_path, image)
-    print(f"Output saved: {output_path}")
+    print(f'Output saved: {output_path}')
 
 
 def run_webcam(detector, landmarker):
     cap = cv2.VideoCapture(0)  # 0 = default webcam
     if not cap.isOpened():
-        print("Cannot open webcam")
+        print('Cannot open webcam')
         return
 
     print("Press 'q' to quit")
@@ -67,7 +67,7 @@ def run_webcam(detector, landmarker):
         faces = detector.detect(frame)
 
         for face in faces:
-            bbox = face["bbox"]
+            bbox = face['bbox']
             x1, y1, x2, y2 = map(int, bbox)
             cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
 
@@ -77,16 +77,16 @@ def run_webcam(detector, landmarker):
 
         cv2.putText(
             frame,
-            f"Faces: {len(faces)}",
+            f'Faces: {len(faces)}',
             (10, 30),
             cv2.FONT_HERSHEY_SIMPLEX,
             1,
             (0, 255, 0),
             2,
         )
-        cv2.imshow("106-Point Landmarks", frame)
+        cv2.imshow('106-Point Landmarks', frame)
 
-        if cv2.waitKey(1) & 0xFF == ord("q"):
+        if cv2.waitKey(1) & 0xFF == ord('q'):
             break
 
     cap.release()
@@ -94,17 +94,17 @@ def run_webcam(detector, landmarker):
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Run facial landmark detection")
-    parser.add_argument("--image", type=str, help="Path to input image")
-    parser.add_argument("--webcam", action="store_true", help="Use webcam")
-    parser.add_argument("--detector", type=str, default="retinaface", choices=["retinaface", "scrfd"])
-    parser.add_argument("--save_dir", type=str, default="outputs")
+    parser = argparse.ArgumentParser(description='Run facial landmark detection')
+    parser.add_argument('--image', type=str, help='Path to input image')
+    parser.add_argument('--webcam', action='store_true', help='Use webcam')
+    parser.add_argument('--detector', type=str, default='retinaface', choices=['retinaface', 'scrfd'])
+    parser.add_argument('--save_dir', type=str, default='outputs')
     args = parser.parse_args()
 
     if not args.image and not args.webcam:
-        parser.error("Either --image or --webcam must be specified")
+        parser.error('Either --image or --webcam must be specified')
 
-    detector = RetinaFace() if args.detector == "retinaface" else SCRFD()
+    detector = RetinaFace() if args.detector == 'retinaface' else SCRFD()
     landmarker = Landmark106()
 
     if args.webcam:
@@ -113,5 +113,5 @@ def main():
         process_image(detector, landmarker, args.image, args.save_dir)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/scripts/run_recognition.py b/scripts/run_recognition.py
index 48c0b94..f3a88f6 100644
--- a/scripts/run_recognition.py
+++ b/scripts/run_recognition.py
@@ -13,9 +13,9 @@ from uniface.recognition import ArcFace, MobileFace, SphereFace
 
 
 def get_recognizer(name: str):
-    if name == "arcface":
+    if name == 'arcface':
         return ArcFace()
-    elif name == "mobileface":
+    elif name == 'mobileface':
         return MobileFace()
     else:
         return SphereFace()
@@ -29,18 +29,18 @@ def run_inference(detector, recognizer, image_path: str):
 
     faces = detector.detect(image)
     if not faces:
-        print("No faces detected.")
+        print('No faces detected.')
         return
 
-    print(f"Detected {len(faces)} face(s). Extracting embedding for the first face...")
+    print(f'Detected {len(faces)} face(s). Extracting embedding for the first face...')
 
-    landmarks = np.array(faces[0]["landmarks"])  # 5-point landmarks for alignment
+    landmarks = faces[0]['landmarks']  # 5-point landmarks for alignment (already np.ndarray)
     embedding = recognizer.get_embedding(image, landmarks)
     norm_embedding = recognizer.get_normalized_embedding(image, landmarks)  # L2 normalized
 
-    print(f"  Embedding shape: {embedding.shape}")
-    print(f"  L2 norm (raw): {np.linalg.norm(embedding):.4f}")
-    print(f"  L2 norm (normalized): {np.linalg.norm(norm_embedding):.4f}")
+    print(f'  Embedding shape: {embedding.shape}')
+    print(f'  L2 norm (raw): {np.linalg.norm(embedding):.4f}')
+    print(f'  L2 norm (normalized): {np.linalg.norm(norm_embedding):.4f}')
 
 
 def compare_faces(detector, recognizer, image1_path: str, image2_path: str, threshold: float = 0.35):
@@ -48,18 +48,18 @@ def compare_faces(detector, recognizer, image1_path: str, image2_path: str, thre
     img2 = cv2.imread(image2_path)
 
     if img1 is None or img2 is None:
-        print("Error: Failed to load one or both images")
+        print('Error: Failed to load one or both images')
         return
 
     faces1 = detector.detect(img1)
     faces2 = detector.detect(img2)
 
     if not faces1 or not faces2:
-        print("Error: No faces detected in one or both images")
+        print('Error: No faces detected in one or both images')
         return
 
-    landmarks1 = np.array(faces1[0]["landmarks"])
-    landmarks2 = np.array(faces2[0]["landmarks"])
+    landmarks1 = faces1[0]['landmarks']
+    landmarks2 = faces2[0]['landmarks']
 
     embedding1 = recognizer.get_normalized_embedding(img1, landmarks1)
     embedding2 = recognizer.get_normalized_embedding(img2, landmarks2)
@@ -68,26 +68,26 @@ def compare_faces(detector, recognizer, image1_path: str, image2_path: str, thre
     similarity = compute_similarity(embedding1, embedding2, normalized=True)
     is_match = similarity > threshold
 
-    print(f"Similarity: {similarity:.4f}")
-    print(f"Result: {'Same person' if is_match else 'Different person'} (threshold: {threshold})")
+    print(f'Similarity: {similarity:.4f}')
+    print(f'Result: {"Same person" if is_match else "Different person"} (threshold: {threshold})')
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Face recognition and comparison")
-    parser.add_argument("--image", type=str, help="Single image for embedding extraction")
-    parser.add_argument("--image1", type=str, help="First image for comparison")
-    parser.add_argument("--image2", type=str, help="Second image for comparison")
-    parser.add_argument("--threshold", type=float, default=0.35, help="Similarity threshold")
-    parser.add_argument("--detector", type=str, default="retinaface", choices=["retinaface", "scrfd"])
+    parser = argparse.ArgumentParser(description='Face recognition and comparison')
+    parser.add_argument('--image', type=str, help='Single image for embedding extraction')
+    parser.add_argument('--image1', type=str, help='First image for comparison')
+    parser.add_argument('--image2', type=str, help='Second image for comparison')
+    parser.add_argument('--threshold', type=float, default=0.35, help='Similarity threshold')
+    parser.add_argument('--detector', type=str, default='retinaface', choices=['retinaface', 'scrfd'])
     parser.add_argument(
-        "--recognizer",
+        '--recognizer',
         type=str,
-        default="arcface",
-        choices=["arcface", "mobileface", "sphereface"],
+        default='arcface',
+        choices=['arcface', 'mobileface', 'sphereface'],
     )
     args = parser.parse_args()
 
-    detector = RetinaFace() if args.detector == "retinaface" else SCRFD()
+    detector = RetinaFace() if args.detector == 'retinaface' else SCRFD()
     recognizer = get_recognizer(args.recognizer)
 
     if args.image1 and args.image2:
@@ -95,9 +95,9 @@ def main():
     elif args.image:
         run_inference(detector, recognizer, args.image)
     else:
-        print("Error: Provide --image or both --image1 and --image2")
+        print('Error: Provide --image or both --image1 and --image2')
         parser.print_help()
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/scripts/run_video_detection.py b/scripts/run_video_detection.py
index a9988f4..18fe8a9 100644
--- a/scripts/run_video_detection.py
+++ b/scripts/run_video_detection.py
@@ -29,10 +29,10 @@ def process_video(
     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
-    print(f"Input: {input_path} ({width}x{height}, {fps:.1f} fps, {total_frames} frames)")
-    print(f"Output: {output_path}")
+    print(f'Input: {input_path} ({width}x{height}, {fps:.1f} fps, {total_frames} frames)')
+    print(f'Output: {output_path}')
 
-    fourcc = cv2.VideoWriter_fourcc(*"mp4v")  # codec for .mp4
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # codec for .mp4
     out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
 
     if not out.isOpened():
@@ -43,7 +43,7 @@ def process_video(
     frame_count = 0
     total_faces = 0
 
-    for _ in tqdm(range(total_frames), desc="Processing", unit="frames"):
+    for _ in tqdm(range(total_frames), desc='Processing', unit='frames'):
         ret, frame = cap.read()
         if not ret:
             break
@@ -52,14 +52,14 @@ def process_video(
         faces = detector.detect(frame)
         total_faces += len(faces)
 
-        bboxes = [f["bbox"] for f in faces]
-        scores = [f["confidence"] for f in faces]
-        landmarks = [f["landmarks"] for f in faces]
+        bboxes = [f['bbox'] for f in faces]
+        scores = [f['confidence'] for f in faces]
+        landmarks = [f['landmarks'] for f in faces]
         draw_detections(frame, bboxes, scores, landmarks, vis_threshold=threshold)
 
         cv2.putText(
             frame,
-            f"Faces: {len(faces)}",
+            f'Faces: {len(faces)}',
             (10, 30),
             cv2.FONT_HERSHEY_SIMPLEX,
             1,
@@ -70,8 +70,8 @@ def process_video(
 
         if show_preview:
             cv2.imshow("Processing - Press 'q' to cancel", frame)
-            if cv2.waitKey(1) & 0xFF == ord("q"):
-                print("\nCancelled by user")
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                print('\nCancelled by user')
                 break
 
     cap.release()
@@ -80,17 +80,17 @@ def process_video(
         cv2.destroyAllWindows()
 
     avg_faces = total_faces / frame_count if frame_count > 0 else 0
-    print(f"\nDone! {frame_count} frames, {total_faces} faces ({avg_faces:.1f} avg/frame)")
-    print(f"Saved: {output_path}")
+    print(f'\nDone! {frame_count} frames, {total_faces} faces ({avg_faces:.1f} avg/frame)')
+    print(f'Saved: {output_path}')
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Process video with face detection")
-    parser.add_argument("--input", type=str, required=True, help="Input video path")
-    parser.add_argument("--output", type=str, required=True, help="Output video path")
-    parser.add_argument("--detector", type=str, default="retinaface", choices=["retinaface", "scrfd"])
-    parser.add_argument("--threshold", type=float, default=0.6, help="Visualization threshold")
-    parser.add_argument("--preview", action="store_true", help="Show live preview")
+    parser = argparse.ArgumentParser(description='Process video with face detection')
+    parser.add_argument('--input', type=str, required=True, help='Input video path')
+    parser.add_argument('--output', type=str, required=True, help='Output video path')
+    parser.add_argument('--detector', type=str, default='retinaface', choices=['retinaface', 'scrfd'])
+    parser.add_argument('--threshold', type=float, default=0.6, help='Visualization threshold')
+    parser.add_argument('--preview', action='store_true', help='Show live preview')
     args = parser.parse_args()
 
     if not Path(args.input).exists():
@@ -99,9 +99,9 @@ def main():
 
     Path(args.output).parent.mkdir(parents=True, exist_ok=True)
 
-    detector = RetinaFace() if args.detector == "retinaface" else SCRFD()
+    detector = RetinaFace() if args.detector == 'retinaface' else SCRFD()
     process_video(detector, args.input, args.output, args.threshold, args.preview)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/scripts/sha256_generate.py b/scripts/sha256_generate.py
index 9377c1e..60dbc49 100644
--- a/scripts/sha256_generate.py
+++ b/scripts/sha256_generate.py
@@ -5,24 +5,24 @@ from pathlib import Path
 
 def compute_sha256(file_path: Path, chunk_size: int = 8192) -> str:
     sha256_hash = hashlib.sha256()
-    with file_path.open("rb") as f:
-        for chunk in iter(lambda: f.read(chunk_size), b""):
+    with file_path.open('rb') as f:
+        for chunk in iter(lambda: f.read(chunk_size), b''):
             sha256_hash.update(chunk)
     return sha256_hash.hexdigest()
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Compute SHA256 hash of a file")
-    parser.add_argument("file", type=Path, help="Path to file")
+    parser = argparse.ArgumentParser(description='Compute SHA256 hash of a file')
+    parser.add_argument('file', type=Path, help='Path to file')
     args = parser.parse_args()
 
     if not args.file.exists() or not args.file.is_file():
-        print(f"File does not exist: {args.file}")
+        print(f'File does not exist: {args.file}')
         return
 
     sha256 = compute_sha256(args.file)
     print(f"SHA256 hash for '{args.file.name}':\n{sha256}")
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
diff --git a/tests/test_age_gender.py b/tests/test_age_gender.py
index 34c0092..e899331 100644
--- a/tests/test_age_gender.py
+++ b/tests/test_age_gender.py
@@ -20,23 +20,23 @@ def mock_bbox():
 
 
 def test_model_initialization(age_gender_model):
-    assert age_gender_model is not None, "AgeGender model initialization failed."
+    assert age_gender_model is not None, 'AgeGender model initialization failed.'
 
 
 def test_prediction_output_format(age_gender_model, mock_image, mock_bbox):
-    gender, age = age_gender_model.predict(mock_image, mock_bbox)
-    assert isinstance(gender, str), f"Gender should be string, got {type(gender)}"
-    assert isinstance(age, int), f"Age should be int, got {type(age)}"
+    gender_id, age = age_gender_model.predict(mock_image, mock_bbox)
+    assert isinstance(gender_id, int), f'Gender ID should be int, got {type(gender_id)}'
+    assert isinstance(age, int), f'Age should be int, got {type(age)}'
 
 
 def test_gender_values(age_gender_model, mock_image, mock_bbox):
-    gender, age = age_gender_model.predict(mock_image, mock_bbox)
-    assert gender in ["Male", "Female"], f"Gender should be 'Male' or 'Female', got '{gender}'"
+    gender_id, age = age_gender_model.predict(mock_image, mock_bbox)
+    assert gender_id in [0, 1], f'Gender ID should be 0 (Female) or 1 (Male), got {gender_id}'
 
 
 def test_age_range(age_gender_model, mock_image, mock_bbox):
-    gender, age = age_gender_model.predict(mock_image, mock_bbox)
-    assert 0 <= age <= 120, f"Age should be between 0 and 120, got {age}"
+    gender_id, age = age_gender_model.predict(mock_image, mock_bbox)
+    assert 0 <= age <= 120, f'Age should be between 0 and 120, got {age}'
 
 
 def test_different_bbox_sizes(age_gender_model, mock_image):
@@ -47,9 +47,9 @@ def test_different_bbox_sizes(age_gender_model, mock_image):
     ]
 
     for bbox in test_bboxes:
-        gender, age = age_gender_model.predict(mock_image, bbox)
-        assert gender in ["Male", "Female"], f"Failed for bbox {bbox}"
-        assert 0 <= age <= 120, f"Age out of range for bbox {bbox}"
+        gender_id, age = age_gender_model.predict(mock_image, bbox)
+        assert gender_id in [0, 1], f'Failed for bbox {bbox}'
+        assert 0 <= age <= 120, f'Age out of range for bbox {bbox}'
 
 
 def test_different_image_sizes(age_gender_model, mock_bbox):
@@ -57,31 +57,31 @@ def test_different_image_sizes(age_gender_model, mock_bbox):
 
     for size in test_sizes:
         mock_image = np.random.randint(0, 255, size, dtype=np.uint8)
-        gender, age = age_gender_model.predict(mock_image, mock_bbox)
-        assert gender in ["Male", "Female"], f"Failed for image size {size}"
-        assert 0 <= age <= 120, f"Age out of range for image size {size}"
+        gender_id, age = age_gender_model.predict(mock_image, mock_bbox)
+        assert gender_id in [0, 1], f'Failed for image size {size}'
+        assert 0 <= age <= 120, f'Age out of range for image size {size}'
 
 
 def test_consistency(age_gender_model, mock_image, mock_bbox):
-    gender1, age1 = age_gender_model.predict(mock_image, mock_bbox)
-    gender2, age2 = age_gender_model.predict(mock_image, mock_bbox)
+    gender_id1, age1 = age_gender_model.predict(mock_image, mock_bbox)
+    gender_id2, age2 = age_gender_model.predict(mock_image, mock_bbox)
 
-    assert gender1 == gender2, "Same input should produce same gender prediction"
-    assert age1 == age2, "Same input should produce same age prediction"
+    assert gender_id1 == gender_id2, 'Same input should produce same gender prediction'
+    assert age1 == age2, 'Same input should produce same age prediction'
 
 
 def test_bbox_list_format(age_gender_model, mock_image):
     bbox_list = [100, 100, 300, 300]
-    gender, age = age_gender_model.predict(mock_image, bbox_list)
-    assert gender in ["Male", "Female"], "Should work with bbox as list"
-    assert 0 <= age <= 120, "Age should be in valid range"
+    gender_id, age = age_gender_model.predict(mock_image, bbox_list)
+    assert gender_id in [0, 1], 'Should work with bbox as list'
+    assert 0 <= age <= 120, 'Age should be in valid range'
 
 
 def test_bbox_array_format(age_gender_model, mock_image):
     bbox_array = np.array([100, 100, 300, 300])
-    gender, age = age_gender_model.predict(mock_image, bbox_array)
-    assert gender in ["Male", "Female"], "Should work with bbox as numpy array"
-    assert 0 <= age <= 120, "Age should be in valid range"
+    gender_id, age = age_gender_model.predict(mock_image, bbox_array)
+    assert gender_id in [0, 1], 'Should work with bbox as numpy array'
+    assert 0 <= age <= 120, 'Age should be in valid range'
 
 
 def test_multiple_predictions(age_gender_model, mock_image):
@@ -93,24 +93,25 @@ def test_multiple_predictions(age_gender_model, mock_image):
 
     results = []
     for bbox in bboxes:
-        gender, age = age_gender_model.predict(mock_image, bbox)
-        results.append((gender, age))
+        gender_id, age = age_gender_model.predict(mock_image, bbox)
+        results.append((gender_id, age))
 
-    assert len(results) == 3, "Should have 3 predictions"
-    for gender, age in results:
-        assert gender in ["Male", "Female"]
+    assert len(results) == 3, 'Should have 3 predictions'
+    for gender_id, age in results:
+        assert gender_id in [0, 1]
         assert 0 <= age <= 120
 
 
 def test_age_is_positive(age_gender_model, mock_image, mock_bbox):
     for _ in range(5):
-        gender, age = age_gender_model.predict(mock_image, mock_bbox)
-        assert age >= 0, f"Age should be non-negative, got {age}"
+        gender_id, age = age_gender_model.predict(mock_image, mock_bbox)
+        assert age >= 0, f'Age should be non-negative, got {age}'
 
 
 def test_output_format_for_visualization(age_gender_model, mock_image, mock_bbox):
-    gender, age = age_gender_model.predict(mock_image, mock_bbox)
-    text = f"{gender}, {age}y"
-    assert isinstance(text, str), "Should be able to format as string"
-    assert "Male" in text or "Female" in text, "Text should contain gender"
-    assert "y" in text, "Text should contain 'y' for years"
+    gender_id, age = age_gender_model.predict(mock_image, mock_bbox)
+    gender_str = 'Female' if gender_id == 0 else 'Male'
+    text = f'{gender_str}, {age}y'
+    assert isinstance(text, str), 'Should be able to format as string'
+    assert 'Male' in text or 'Female' in text, 'Text should contain gender'
+    assert 'y' in text, "Text should contain 'y' for years"
diff --git a/tests/test_factory.py b/tests/test_factory.py
index 9f30ba2..0f134bd 100644
--- a/tests/test_factory.py
+++ b/tests/test_factory.py
@@ -16,16 +16,16 @@ def test_create_detector_retinaface():
     """
     Test creating a RetinaFace detector using factory function.
     """
-    detector = create_detector("retinaface")
-    assert detector is not None, "Failed to create RetinaFace detector"
+    detector = create_detector('retinaface')
+    assert detector is not None, 'Failed to create RetinaFace detector'
 
 
 def test_create_detector_scrfd():
     """
     Test creating a SCRFD detector using factory function.
     """
-    detector = create_detector("scrfd")
-    assert detector is not None, "Failed to create SCRFD detector"
+    detector = create_detector('scrfd')
+    assert detector is not None, 'Failed to create SCRFD detector'
 
 
 def test_create_detector_with_config():
@@ -33,12 +33,12 @@ def test_create_detector_with_config():
     Test creating detector with custom configuration.
     """
     detector = create_detector(
-        "retinaface",
+        'retinaface',
         model_name=RetinaFaceWeights.MNET_V2,
         conf_thresh=0.8,
         nms_thresh=0.3,
     )
-    assert detector is not None, "Failed to create detector with custom config"
+    assert detector is not None, 'Failed to create detector with custom config'
 
 
 def test_create_detector_invalid_method():
@@ -46,15 +46,15 @@ def test_create_detector_invalid_method():
     Test that invalid detector method raises an error.
     """
     with pytest.raises((ValueError, KeyError)):
-        create_detector("invalid_method")
+        create_detector('invalid_method')
 
 
 def test_create_detector_scrfd_with_model():
     """
     Test creating SCRFD detector with specific model.
     """
-    detector = create_detector("scrfd", model_name=SCRFDWeights.SCRFD_10G_KPS, conf_thresh=0.5)
-    assert detector is not None, "Failed to create SCRFD with specific model"
+    detector = create_detector('scrfd', model_name=SCRFDWeights.SCRFD_10G_KPS, conf_thresh=0.5)
+    assert detector is not None, 'Failed to create SCRFD with specific model'
 
 
 # create_recognizer tests
@@ -62,24 +62,24 @@ def test_create_recognizer_arcface():
     """
     Test creating an ArcFace recognizer using factory function.
     """
-    recognizer = create_recognizer("arcface")
-    assert recognizer is not None, "Failed to create ArcFace recognizer"
+    recognizer = create_recognizer('arcface')
+    assert recognizer is not None, 'Failed to create ArcFace recognizer'
 
 
 def test_create_recognizer_mobileface():
     """
     Test creating a MobileFace recognizer using factory function.
     """
-    recognizer = create_recognizer("mobileface")
-    assert recognizer is not None, "Failed to create MobileFace recognizer"
+    recognizer = create_recognizer('mobileface')
+    assert recognizer is not None, 'Failed to create MobileFace recognizer'
 
 
 def test_create_recognizer_sphereface():
     """
     Test creating a SphereFace recognizer using factory function.
     """
-    recognizer = create_recognizer("sphereface")
-    assert recognizer is not None, "Failed to create SphereFace recognizer"
+    recognizer = create_recognizer('sphereface')
+    assert recognizer is not None, 'Failed to create SphereFace recognizer'
 
 
 def test_create_recognizer_invalid_method():
@@ -87,7 +87,7 @@ def test_create_recognizer_invalid_method():
     Test that invalid recognizer method raises an error.
     """
     with pytest.raises((ValueError, KeyError)):
-        create_recognizer("invalid_method")
+        create_recognizer('invalid_method')
 
 
 # create_landmarker tests
@@ -95,8 +95,8 @@ def test_create_landmarker():
     """
     Test creating a Landmark106 detector using factory function.
     """
-    landmarker = create_landmarker("2d106det")
-    assert landmarker is not None, "Failed to create Landmark106 detector"
+    landmarker = create_landmarker('2d106det')
+    assert landmarker is not None, 'Failed to create Landmark106 detector'
 
 
 def test_create_landmarker_default():
@@ -104,7 +104,7 @@ def test_create_landmarker_default():
     Test creating landmarker with default parameters.
     """
     landmarker = create_landmarker()
-    assert landmarker is not None, "Failed to create default landmarker"
+    assert landmarker is not None, 'Failed to create default landmarker'
 
 
 def test_create_landmarker_invalid_method():
@@ -112,7 +112,7 @@ def test_create_landmarker_invalid_method():
     Test that invalid landmarker method raises an error.
     """
     with pytest.raises((ValueError, KeyError)):
-        create_landmarker("invalid_method")
+        create_landmarker('invalid_method')
 
 
 # detect_faces tests
@@ -121,9 +121,9 @@ def test_detect_faces_retinaface():
     Test high-level detect_faces function with RetinaFace.
     """
     mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
-    faces = detect_faces(mock_image, method="retinaface")
+    faces = detect_faces(mock_image, method='retinaface')
 
-    assert isinstance(faces, list), "detect_faces should return a list"
+    assert isinstance(faces, list), 'detect_faces should return a list'
 
 
 def test_detect_faces_scrfd():
@@ -131,9 +131,9 @@ def test_detect_faces_scrfd():
     Test high-level detect_faces function with SCRFD.
     """
     mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
-    faces = detect_faces(mock_image, method="scrfd")
+    faces = detect_faces(mock_image, method='scrfd')
 
-    assert isinstance(faces, list), "detect_faces should return a list"
+    assert isinstance(faces, list), 'detect_faces should return a list'
 
 
 def test_detect_faces_with_threshold():
@@ -141,13 +141,13 @@ def test_detect_faces_with_threshold():
     Test detect_faces with custom confidence threshold.
     """
     mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
-    faces = detect_faces(mock_image, method="retinaface", conf_thresh=0.8)
+    faces = detect_faces(mock_image, method='retinaface', conf_thresh=0.8)
 
-    assert isinstance(faces, list), "detect_faces should return a list"
+    assert isinstance(faces, list), 'detect_faces should return a list'
 
     # All detections should respect threshold
     for face in faces:
-        assert face["confidence"] >= 0.8, "All detections should meet confidence threshold"
+        assert face['confidence'] >= 0.8, 'All detections should meet confidence threshold'
 
 
 def test_detect_faces_default_method():
@@ -157,7 +157,7 @@ def test_detect_faces_default_method():
     mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
     faces = detect_faces(mock_image)  # No method specified
 
-    assert isinstance(faces, list), "detect_faces should return a list with default method"
+    assert isinstance(faces, list), 'detect_faces should return a list with default method'
 
 
 def test_detect_faces_empty_image():
@@ -165,10 +165,10 @@ def test_detect_faces_empty_image():
     Test detect_faces on a blank image.
     """
     empty_image = np.zeros((640, 640, 3), dtype=np.uint8)
-    faces = detect_faces(empty_image, method="retinaface")
+    faces = detect_faces(empty_image, method='retinaface')
 
-    assert isinstance(faces, list), "Should return a list even for empty image"
-    assert len(faces) == 0, "Should detect no faces in blank image"
+    assert isinstance(faces, list), 'Should return a list even for empty image'
+    assert len(faces) == 0, 'Should detect no faces in blank image'
 
 
 # list_available_detectors tests
@@ -178,8 +178,8 @@ def test_list_available_detectors():
     """
     detectors = list_available_detectors()
 
-    assert isinstance(detectors, dict), "Should return a dictionary of detectors"
-    assert len(detectors) > 0, "Should have at least one detector available"
+    assert isinstance(detectors, dict), 'Should return a dictionary of detectors'
+    assert len(detectors) > 0, 'Should have at least one detector available'
 
 
 def test_list_available_detectors_contents():
@@ -189,8 +189,8 @@ def test_list_available_detectors_contents():
     detectors = list_available_detectors()
 
     # Should include at least these detectors
-    assert "retinaface" in detectors, "Should include 'retinaface'"
-    assert "scrfd" in detectors, "Should include 'scrfd'"
+    assert 'retinaface' in detectors, "Should include 'retinaface'"
+    assert 'scrfd' in detectors, "Should include 'scrfd'"
 
 
 # Integration tests
@@ -198,56 +198,56 @@ def test_detector_inference_from_factory():
     """
     Test that detector created from factory can perform inference.
     """
-    detector = create_detector("retinaface")
+    detector = create_detector('retinaface')
     mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
 
     faces = detector.detect(mock_image)
-    assert isinstance(faces, list), "Detector should return list of faces"
+    assert isinstance(faces, list), 'Detector should return list of faces'
 
 
 def test_recognizer_inference_from_factory():
     """
     Test that recognizer created from factory can perform inference.
     """
-    recognizer = create_recognizer("arcface")
+    recognizer = create_recognizer('arcface')
     mock_image = np.random.randint(0, 255, (112, 112, 3), dtype=np.uint8)
 
     embedding = recognizer.get_embedding(mock_image)
-    assert embedding is not None, "Recognizer should return embedding"
-    assert embedding.shape[1] == 512, "Should return 512-dimensional embedding"
+    assert embedding is not None, 'Recognizer should return embedding'
+    assert embedding.shape[1] == 512, 'Should return 512-dimensional embedding'
 
 
 def test_landmarker_inference_from_factory():
     """
     Test that landmarker created from factory can perform inference.
     """
-    landmarker = create_landmarker("2d106det")
+    landmarker = create_landmarker('2d106det')
     mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
     mock_bbox = [100, 100, 300, 300]
 
     landmarks = landmarker.get_landmarks(mock_image, mock_bbox)
-    assert landmarks is not None, "Landmarker should return landmarks"
-    assert landmarks.shape == (106, 2), "Should return 106 landmarks"
+    assert landmarks is not None, 'Landmarker should return landmarks'
+    assert landmarks.shape == (106, 2), 'Should return 106 landmarks'
 
 
 def test_multiple_detector_creation():
     """
     Test that multiple detectors can be created independently.
     """
-    detector1 = create_detector("retinaface")
-    detector2 = create_detector("scrfd")
+    detector1 = create_detector('retinaface')
+    detector2 = create_detector('scrfd')
 
     assert detector1 is not None
     assert detector2 is not None
-    assert detector1 is not detector2, "Should create separate instances"
+    assert detector1 is not detector2, 'Should create separate instances'
 
 
 def test_detector_with_different_configs():
     """
     Test creating multiple detectors with different configurations.
     """
-    detector_high_thresh = create_detector("retinaface", conf_thresh=0.9)
-    detector_low_thresh = create_detector("retinaface", conf_thresh=0.3)
+    detector_high_thresh = create_detector('retinaface', conf_thresh=0.9)
+    detector_low_thresh = create_detector('retinaface', conf_thresh=0.3)
 
     mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
 
@@ -265,10 +265,10 @@ def test_factory_returns_correct_types():
     """
     from uniface import RetinaFace, ArcFace, Landmark106
 
-    detector = create_detector("retinaface")
-    recognizer = create_recognizer("arcface")
-    landmarker = create_landmarker("2d106det")
+    detector = create_detector('retinaface')
+    recognizer = create_recognizer('arcface')
+    landmarker = create_landmarker('2d106det')
 
-    assert isinstance(detector, RetinaFace), "Should return RetinaFace instance"
-    assert isinstance(recognizer, ArcFace), "Should return ArcFace instance"
-    assert isinstance(landmarker, Landmark106), "Should return Landmark106 instance"
+    assert isinstance(detector, RetinaFace), 'Should return RetinaFace instance'
+    assert isinstance(recognizer, ArcFace), 'Should return ArcFace instance'
+    assert isinstance(landmarker, Landmark106), 'Should return Landmark106 instance'
diff --git a/tests/test_landmark.py b/tests/test_landmark.py
index fa1a26b..d636457 100644
--- a/tests/test_landmark.py
+++ b/tests/test_landmark.py
@@ -20,17 +20,17 @@ def mock_bbox():
 
 
 def test_model_initialization(landmark_model):
-    assert landmark_model is not None, "Landmark106 model initialization failed."
+    assert landmark_model is not None, 'Landmark106 model initialization failed.'
 
 
 def test_landmark_detection(landmark_model, mock_image, mock_bbox):
     landmarks = landmark_model.get_landmarks(mock_image, mock_bbox)
-    assert landmarks.shape == (106, 2), f"Expected shape (106, 2), got {landmarks.shape}"
+    assert landmarks.shape == (106, 2), f'Expected shape (106, 2), got {landmarks.shape}'
 
 
 def test_landmark_dtype(landmark_model, mock_image, mock_bbox):
     landmarks = landmark_model.get_landmarks(mock_image, mock_bbox)
-    assert landmarks.dtype == np.float32, f"Expected float32, got {landmarks.dtype}"
+    assert landmarks.dtype == np.float32, f'Expected float32, got {landmarks.dtype}'
 
 
 def test_landmark_coordinates_within_image(landmark_model, mock_image, mock_bbox):
@@ -45,8 +45,8 @@ def test_landmark_coordinates_within_image(landmark_model, mock_image, mock_bbox
     x_in_bounds = np.sum((x_coords >= x1 - margin) & (x_coords <= x2 + margin))
     y_in_bounds = np.sum((y_coords >= y1 - margin) & (y_coords <= y2 + margin))
 
-    assert x_in_bounds >= 95, f"Only {x_in_bounds}/106 x-coordinates within bounds"
-    assert y_in_bounds >= 95, f"Only {y_in_bounds}/106 y-coordinates within bounds"
+    assert x_in_bounds >= 95, f'Only {x_in_bounds}/106 x-coordinates within bounds'
+    assert y_in_bounds >= 95, f'Only {y_in_bounds}/106 y-coordinates within bounds'
 
 
 def test_different_bbox_sizes(landmark_model, mock_image):
@@ -58,22 +58,22 @@ def test_different_bbox_sizes(landmark_model, mock_image):
 
     for bbox in test_bboxes:
         landmarks = landmark_model.get_landmarks(mock_image, bbox)
-        assert landmarks.shape == (106, 2), f"Failed for bbox {bbox}"
+        assert landmarks.shape == (106, 2), f'Failed for bbox {bbox}'
 
 
 def test_landmark_array_format(landmark_model, mock_image, mock_bbox):
     landmarks = landmark_model.get_landmarks(mock_image, mock_bbox)
     landmarks_int = landmarks.astype(int)
 
-    assert landmarks_int.shape == (106, 2), "Integer conversion should preserve shape"
-    assert landmarks_int.dtype in [np.int32, np.int64], "Should convert to integer type"
+    assert landmarks_int.shape == (106, 2), 'Integer conversion should preserve shape'
+    assert landmarks_int.dtype in [np.int32, np.int64], 'Should convert to integer type'
 
 
 def test_consistency(landmark_model, mock_image, mock_bbox):
     landmarks1 = landmark_model.get_landmarks(mock_image, mock_bbox)
     landmarks2 = landmark_model.get_landmarks(mock_image, mock_bbox)
 
-    assert np.allclose(landmarks1, landmarks2), "Same input should produce same landmarks"
+    assert np.allclose(landmarks1, landmarks2), 'Same input should produce same landmarks'
 
 
 def test_different_image_sizes(landmark_model, mock_bbox):
@@ -82,19 +82,19 @@ def test_different_image_sizes(landmark_model, mock_bbox):
     for size in test_sizes:
         mock_image = np.random.randint(0, 255, size, dtype=np.uint8)
         landmarks = landmark_model.get_landmarks(mock_image, mock_bbox)
-        assert landmarks.shape == (106, 2), f"Failed for image size {size}"
+        assert landmarks.shape == (106, 2), f'Failed for image size {size}'
 
 
 def test_bbox_list_format(landmark_model, mock_image):
     bbox_list = [100, 100, 300, 300]
     landmarks = landmark_model.get_landmarks(mock_image, bbox_list)
-    assert landmarks.shape == (106, 2), "Should work with bbox as list"
+    assert landmarks.shape == (106, 2), 'Should work with bbox as list'
 
 
 def test_bbox_array_format(landmark_model, mock_image):
     bbox_array = np.array([100, 100, 300, 300])
     landmarks = landmark_model.get_landmarks(mock_image, bbox_array)
-    assert landmarks.shape == (106, 2), "Should work with bbox as numpy array"
+    assert landmarks.shape == (106, 2), 'Should work with bbox as numpy array'
 
 
 def test_landmark_distribution(landmark_model, mock_image, mock_bbox):
@@ -103,5 +103,5 @@ def test_landmark_distribution(landmark_model, mock_image, mock_bbox):
     x_variance = np.var(landmarks[:, 0])
     y_variance = np.var(landmarks[:, 1])
 
-    assert x_variance > 0, "Landmarks should have variation in x-coordinates"
-    assert y_variance > 0, "Landmarks should have variation in y-coordinates"
+    assert x_variance > 0, 'Landmarks should have variation in x-coordinates'
+    assert y_variance > 0, 'Landmarks should have variation in y-coordinates'
diff --git a/tests/test_recognition.py b/tests/test_recognition.py
index 769b55c..c8c761f 100644
--- a/tests/test_recognition.py
+++ b/tests/test_recognition.py
@@ -58,7 +58,7 @@ def test_arcface_initialization(arcface_model):
     """
     Test that the ArcFace model initializes correctly.
     """
-    assert arcface_model is not None, "ArcFace model initialization failed."
+    assert arcface_model is not None, 'ArcFace model initialization failed.'
 
 
 def test_arcface_embedding_shape(arcface_model, mock_aligned_face):
@@ -68,8 +68,8 @@ def test_arcface_embedding_shape(arcface_model, mock_aligned_face):
     embedding = arcface_model.get_embedding(mock_aligned_face)
 
     # ArcFace typically produces 512-dimensional embeddings
-    assert embedding.shape[1] == 512, f"Expected 512-dim embedding, got {embedding.shape[1]}"
-    assert embedding.shape[0] == 1, "Embedding should have batch dimension of 1"
+    assert embedding.shape[1] == 512, f'Expected 512-dim embedding, got {embedding.shape[1]}'
+    assert embedding.shape[0] == 1, 'Embedding should have batch dimension of 1'
 
 
 def test_arcface_normalized_embedding(arcface_model, mock_landmarks):
@@ -83,7 +83,7 @@ def test_arcface_normalized_embedding(arcface_model, mock_landmarks):
 
     # Check that embedding is normalized (L2 norm ≈ 1.0)
     norm = np.linalg.norm(embedding)
-    assert np.isclose(norm, 1.0, atol=1e-5), f"Normalized embedding should have norm 1.0, got {norm}"
+    assert np.isclose(norm, 1.0, atol=1e-5), f'Normalized embedding should have norm 1.0, got {norm}'
 
 
 def test_arcface_embedding_dtype(arcface_model, mock_aligned_face):
@@ -91,7 +91,7 @@ def test_arcface_embedding_dtype(arcface_model, mock_aligned_face):
     Test that embeddings have the correct data type.
     """
     embedding = arcface_model.get_embedding(mock_aligned_face)
-    assert embedding.dtype == np.float32, f"Expected float32, got {embedding.dtype}"
+    assert embedding.dtype == np.float32, f'Expected float32, got {embedding.dtype}'
 
 
 def test_arcface_consistency(arcface_model, mock_aligned_face):
@@ -101,7 +101,7 @@ def test_arcface_consistency(arcface_model, mock_aligned_face):
     embedding1 = arcface_model.get_embedding(mock_aligned_face)
     embedding2 = arcface_model.get_embedding(mock_aligned_face)
 
-    assert np.allclose(embedding1, embedding2), "Same input should produce same embedding"
+    assert np.allclose(embedding1, embedding2), 'Same input should produce same embedding'
 
 
 # MobileFace Tests
@@ -109,7 +109,7 @@ def test_mobileface_initialization(mobileface_model):
     """
     Test that the MobileFace model initializes correctly.
     """
-    assert mobileface_model is not None, "MobileFace model initialization failed."
+    assert mobileface_model is not None, 'MobileFace model initialization failed.'
 
 
 def test_mobileface_embedding_shape(mobileface_model, mock_aligned_face):
@@ -119,8 +119,8 @@ def test_mobileface_embedding_shape(mobileface_model, mock_aligned_face):
     embedding = mobileface_model.get_embedding(mock_aligned_face)
 
     # MobileFace typically produces 512-dimensional embeddings
-    assert embedding.shape[1] == 512, f"Expected 512-dim embedding, got {embedding.shape[1]}"
-    assert embedding.shape[0] == 1, "Embedding should have batch dimension of 1"
+    assert embedding.shape[1] == 512, f'Expected 512-dim embedding, got {embedding.shape[1]}'
+    assert embedding.shape[0] == 1, 'Embedding should have batch dimension of 1'
 
 
 def test_mobileface_normalized_embedding(mobileface_model, mock_landmarks):
@@ -132,7 +132,7 @@ def test_mobileface_normalized_embedding(mobileface_model, mock_landmarks):
     embedding = mobileface_model.get_normalized_embedding(mock_image, mock_landmarks)
 
     norm = np.linalg.norm(embedding)
-    assert np.isclose(norm, 1.0, atol=1e-5), f"Normalized embedding should have norm 1.0, got {norm}"
+    assert np.isclose(norm, 1.0, atol=1e-5), f'Normalized embedding should have norm 1.0, got {norm}'
 
 
 # SphereFace Tests
@@ -140,7 +140,7 @@ def test_sphereface_initialization(sphereface_model):
     """
     Test that the SphereFace model initializes correctly.
     """
-    assert sphereface_model is not None, "SphereFace model initialization failed."
+    assert sphereface_model is not None, 'SphereFace model initialization failed.'
 
 
 def test_sphereface_embedding_shape(sphereface_model, mock_aligned_face):
@@ -150,8 +150,8 @@ def test_sphereface_embedding_shape(sphereface_model, mock_aligned_face):
     embedding = sphereface_model.get_embedding(mock_aligned_face)
 
     # SphereFace typically produces 512-dimensional embeddings
-    assert embedding.shape[1] == 512, f"Expected 512-dim embedding, got {embedding.shape[1]}"
-    assert embedding.shape[0] == 1, "Embedding should have batch dimension of 1"
+    assert embedding.shape[1] == 512, f'Expected 512-dim embedding, got {embedding.shape[1]}'
+    assert embedding.shape[0] == 1, 'Embedding should have batch dimension of 1'
 
 
 def test_sphereface_normalized_embedding(sphereface_model, mock_landmarks):
@@ -163,7 +163,7 @@ def test_sphereface_normalized_embedding(sphereface_model, mock_landmarks):
     embedding = sphereface_model.get_normalized_embedding(mock_image, mock_landmarks)
 
     norm = np.linalg.norm(embedding)
-    assert np.isclose(norm, 1.0, atol=1e-5), f"Normalized embedding should have norm 1.0, got {norm}"
+    assert np.isclose(norm, 1.0, atol=1e-5), f'Normalized embedding should have norm 1.0, got {norm}'
 
 
 # Cross-model comparison tests
@@ -176,7 +176,7 @@ def test_different_models_different_embeddings(arcface_model, mobileface_model,
 
     # Embeddings should be different (with high probability for random input)
     # We check that they're not identical
-    assert not np.allclose(arcface_emb, mobileface_emb), "Different models should produce different embeddings"
+    assert not np.allclose(arcface_emb, mobileface_emb), 'Different models should produce different embeddings'
 
 
 def test_embedding_similarity_computation(arcface_model, mock_aligned_face):
@@ -197,7 +197,7 @@ def test_embedding_similarity_computation(arcface_model, mock_aligned_face):
     similarity = compute_similarity(emb1, emb2)
 
     # Similarity should be between -1 and 1
-    assert -1.0 <= similarity <= 1.0, f"Similarity should be in [-1, 1], got {similarity}"
+    assert -1.0 <= similarity <= 1.0, f'Similarity should be in [-1, 1], got {similarity}'
 
 
 def test_same_face_high_similarity(arcface_model, mock_aligned_face):
@@ -212,4 +212,4 @@ def test_same_face_high_similarity(arcface_model, mock_aligned_face):
     similarity = compute_similarity(emb1, emb2)
 
     # Same image should have similarity close to 1.0
-    assert similarity > 0.99, f"Same face should have similarity > 0.99, got {similarity}"
+    assert similarity > 0.99, f'Same face should have similarity > 0.99, got {similarity}'
diff --git a/tests/test_retinaface.py b/tests/test_retinaface.py
index 6ed1d28..502ac5e 100644
--- a/tests/test_retinaface.py
+++ b/tests/test_retinaface.py
@@ -17,27 +17,27 @@ def retinaface_model():
 
 
 def test_model_initialization(retinaface_model):
-    assert retinaface_model is not None, "Model initialization failed."
+    assert retinaface_model is not None, 'Model initialization failed.'
 
 
 def test_inference_on_640x640_image(retinaface_model):
     mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
     faces = retinaface_model.detect(mock_image)
 
-    assert isinstance(faces, list), "Detections should be a list."
+    assert isinstance(faces, list), 'Detections should be a list.'
 
     for face in faces:
-        assert isinstance(face, dict), "Each detection should be a dictionary."
-        assert "bbox" in face, "Each detection should have a 'bbox' key."
-        assert "confidence" in face, "Each detection should have a 'confidence' key."
-        assert "landmarks" in face, "Each detection should have a 'landmarks' key."
+        assert isinstance(face, dict), 'Each detection should be a dictionary.'
+        assert 'bbox' in face, "Each detection should have a 'bbox' key."
+        assert 'confidence' in face, "Each detection should have a 'confidence' key."
+        assert 'landmarks' in face, "Each detection should have a 'landmarks' key."
 
-        bbox = face["bbox"]
-        assert len(bbox) == 4, "BBox should have 4 values (x1, y1, x2, y2)."
+        bbox = face['bbox']
+        assert len(bbox) == 4, 'BBox should have 4 values (x1, y1, x2, y2).'
 
-        landmarks = face["landmarks"]
-        assert len(landmarks) == 5, "Should have 5 landmark points."
-        assert all(len(pt) == 2 for pt in landmarks), "Each landmark should be (x, y)."
+        landmarks = face['landmarks']
+        assert len(landmarks) == 5, 'Should have 5 landmark points.'
+        assert all(len(pt) == 2 for pt in landmarks), 'Each landmark should be (x, y).'
 
 
 def test_confidence_threshold(retinaface_model):
@@ -45,11 +45,11 @@ def test_confidence_threshold(retinaface_model):
     faces = retinaface_model.detect(mock_image)
 
     for face in faces:
-        confidence = face["confidence"]
-        assert confidence >= 0.5, f"Detection has confidence {confidence} below threshold 0.5"
+        confidence = face['confidence']
+        assert confidence >= 0.5, f'Detection has confidence {confidence} below threshold 0.5'
 
 
 def test_no_faces_detected(retinaface_model):
     empty_image = np.zeros((640, 640, 3), dtype=np.uint8)
     faces = retinaface_model.detect(empty_image)
-    assert len(faces) == 0, "Should detect no faces in a blank image."
+    assert len(faces) == 0, 'Should detect no faces in a blank image.'
diff --git a/tests/test_scrfd.py b/tests/test_scrfd.py
index c25101d..f304609 100644
--- a/tests/test_scrfd.py
+++ b/tests/test_scrfd.py
@@ -15,27 +15,27 @@ def scrfd_model():
 
 
 def test_model_initialization(scrfd_model):
-    assert scrfd_model is not None, "Model initialization failed."
+    assert scrfd_model is not None, 'Model initialization failed.'
 
 
 def test_inference_on_640x640_image(scrfd_model):
     mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
     faces = scrfd_model.detect(mock_image)
 
-    assert isinstance(faces, list), "Detections should be a list."
+    assert isinstance(faces, list), 'Detections should be a list.'
 
     for face in faces:
-        assert isinstance(face, dict), "Each detection should be a dictionary."
-        assert "bbox" in face, "Each detection should have a 'bbox' key."
-        assert "confidence" in face, "Each detection should have a 'confidence' key."
-        assert "landmarks" in face, "Each detection should have a 'landmarks' key."
+        assert isinstance(face, dict), 'Each detection should be a dictionary.'
+        assert 'bbox' in face, "Each detection should have a 'bbox' key."
+        assert 'confidence' in face, "Each detection should have a 'confidence' key."
+        assert 'landmarks' in face, "Each detection should have a 'landmarks' key."
 
-        bbox = face["bbox"]
-        assert len(bbox) == 4, "BBox should have 4 values (x1, y1, x2, y2)."
+        bbox = face['bbox']
+        assert len(bbox) == 4, 'BBox should have 4 values (x1, y1, x2, y2).'
 
-        landmarks = face["landmarks"]
-        assert len(landmarks) == 5, "Should have 5 landmark points."
-        assert all(len(pt) == 2 for pt in landmarks), "Each landmark should be (x, y)."
+        landmarks = face['landmarks']
+        assert len(landmarks) == 5, 'Should have 5 landmark points.'
+        assert all(len(pt) == 2 for pt in landmarks), 'Each landmark should be (x, y).'
 
 
 def test_confidence_threshold(scrfd_model):
@@ -43,14 +43,14 @@ def test_confidence_threshold(scrfd_model):
     faces = scrfd_model.detect(mock_image)
 
     for face in faces:
-        confidence = face["confidence"]
-        assert confidence >= 0.5, f"Detection has confidence {confidence} below threshold 0.5"
+        confidence = face['confidence']
+        assert confidence >= 0.5, f'Detection has confidence {confidence} below threshold 0.5'
 
 
 def test_no_faces_detected(scrfd_model):
     empty_image = np.zeros((640, 640, 3), dtype=np.uint8)
     faces = scrfd_model.detect(empty_image)
-    assert len(faces) == 0, "Should detect no faces in a blank image."
+    assert len(faces) == 0, 'Should detect no faces in a blank image.'
 
 
 def test_different_input_sizes(scrfd_model):
@@ -59,13 +59,13 @@ def test_different_input_sizes(scrfd_model):
     for size in test_sizes:
         mock_image = np.random.randint(0, 255, size, dtype=np.uint8)
         faces = scrfd_model.detect(mock_image)
-        assert isinstance(faces, list), f"Should return list for size {size}"
+        assert isinstance(faces, list), f'Should return list for size {size}'
 
 
 def test_scrfd_10g_model():
     model = SCRFD(model_name=SCRFDWeights.SCRFD_10G_KPS, conf_thresh=0.5)
-    assert model is not None, "SCRFD 10G model initialization failed."
+    assert model is not None, 'SCRFD 10G model initialization failed.'
 
     mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
     faces = model.detect(mock_image)
-    assert isinstance(faces, list), "SCRFD 10G should return list of detections."
+    assert isinstance(faces, list), 'SCRFD 10G should return list of detections.'
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 15aa745..ac2eba8 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -39,7 +39,7 @@ def test_compute_similarity_same_embedding():
     embedding = embedding / np.linalg.norm(embedding)  # Normalize
 
     similarity = compute_similarity(embedding, embedding)
-    assert np.isclose(similarity, 1.0, atol=1e-5), f"Self-similarity should be 1.0, got {similarity}"
+    assert np.isclose(similarity, 1.0, atol=1e-5), f'Self-similarity should be 1.0, got {similarity}'
 
 
 def test_compute_similarity_range():
@@ -56,7 +56,7 @@ def test_compute_similarity_range():
         emb2 = emb2 / np.linalg.norm(emb2)
 
         similarity = compute_similarity(emb1, emb2)
-        assert -1.0 <= similarity <= 1.0, f"Similarity should be in [-1, 1], got {similarity}"
+        assert -1.0 <= similarity <= 1.0, f'Similarity should be in [-1, 1], got {similarity}'
 
 
 def test_compute_similarity_orthogonal():
@@ -71,7 +71,7 @@ def test_compute_similarity_orthogonal():
     emb2[0, 1] = 1.0  # [0, 1, 0, ..., 0]
 
     similarity = compute_similarity(emb1, emb2)
-    assert np.isclose(similarity, 0.0, atol=1e-5), f"Orthogonal embeddings should have similarity 0.0, got {similarity}"
+    assert np.isclose(similarity, 0.0, atol=1e-5), f'Orthogonal embeddings should have similarity 0.0, got {similarity}'
 
 
 def test_compute_similarity_opposite():
@@ -84,7 +84,7 @@ def test_compute_similarity_opposite():
     emb2 = -emb1  # Opposite direction
 
     similarity = compute_similarity(emb1, emb2)
-    assert np.isclose(similarity, -1.0, atol=1e-5), f"Opposite embeddings should have similarity -1.0, got {similarity}"
+    assert np.isclose(similarity, -1.0, atol=1e-5), f'Opposite embeddings should have similarity -1.0, got {similarity}'
 
 
 def test_compute_similarity_symmetry():
@@ -101,7 +101,7 @@ def test_compute_similarity_symmetry():
     sim_12 = compute_similarity(emb1, emb2)
     sim_21 = compute_similarity(emb2, emb1)
 
-    assert np.isclose(sim_12, sim_21), "Similarity should be symmetric"
+    assert np.isclose(sim_12, sim_21), 'Similarity should be symmetric'
 
 
 def test_compute_similarity_dtype():
@@ -116,7 +116,7 @@ def test_compute_similarity_dtype():
     emb2 = emb2 / np.linalg.norm(emb2)
 
     similarity = compute_similarity(emb1, emb2)
-    assert isinstance(similarity, (float, np.floating)), f"Similarity should be float, got {type(similarity)}"
+    assert isinstance(similarity, (float, np.floating)), f'Similarity should be float, got {type(similarity)}'
 
 
 # face_alignment tests
@@ -126,7 +126,7 @@ def test_face_alignment_output_shape(mock_image, mock_landmarks):
     """
     aligned, _ = face_alignment(mock_image, mock_landmarks, image_size=(112, 112))
 
-    assert aligned.shape == (112, 112, 3), f"Expected shape (112, 112, 3), got {aligned.shape}"
+    assert aligned.shape == (112, 112, 3), f'Expected shape (112, 112, 3), got {aligned.shape}'
 
 
 def test_face_alignment_dtype(mock_image, mock_landmarks):
@@ -135,7 +135,7 @@ def test_face_alignment_dtype(mock_image, mock_landmarks):
     """
     aligned, _ = face_alignment(mock_image, mock_landmarks, image_size=(112, 112))
 
-    assert aligned.dtype == np.uint8, f"Expected uint8, got {aligned.dtype}"
+    assert aligned.dtype == np.uint8, f'Expected uint8, got {aligned.dtype}'
 
 
 def test_face_alignment_different_sizes(mock_image, mock_landmarks):
@@ -147,7 +147,7 @@ def test_face_alignment_different_sizes(mock_image, mock_landmarks):
 
     for size in test_sizes:
         aligned, _ = face_alignment(mock_image, mock_landmarks, image_size=size)
-        assert aligned.shape == (*size, 3), f"Failed for size {size}"
+        assert aligned.shape == (*size, 3), f'Failed for size {size}'
 
 
 def test_face_alignment_consistency(mock_image, mock_landmarks):
@@ -157,7 +157,7 @@ def test_face_alignment_consistency(mock_image, mock_landmarks):
     aligned1, _ = face_alignment(mock_image, mock_landmarks, image_size=(112, 112))
     aligned2, _ = face_alignment(mock_image, mock_landmarks, image_size=(112, 112))
 
-    assert np.allclose(aligned1, aligned2), "Same input should produce same aligned face"
+    assert np.allclose(aligned1, aligned2), 'Same input should produce same aligned face'
 
 
 def test_face_alignment_landmarks_as_list(mock_image):
@@ -175,7 +175,7 @@ def test_face_alignment_landmarks_as_list(mock_image):
     # Convert list to numpy array before passing to face_alignment
     landmarks_array = np.array(landmarks_list, dtype=np.float32)
     aligned, _ = face_alignment(mock_image, landmarks_array, image_size=(112, 112))
-    assert aligned.shape == (112, 112, 3), "Should work with landmarks as array"
+    assert aligned.shape == (112, 112, 3), 'Should work with landmarks as array'
 
 
 def test_face_alignment_value_range(mock_image, mock_landmarks):
@@ -184,8 +184,8 @@ def test_face_alignment_value_range(mock_image, mock_landmarks):
     """
     aligned, _ = face_alignment(mock_image, mock_landmarks, image_size=(112, 112))
 
-    assert np.all(aligned >= 0), "Pixel values should be >= 0"
-    assert np.all(aligned <= 255), "Pixel values should be <= 255"
+    assert np.all(aligned >= 0), 'Pixel values should be >= 0'
+    assert np.all(aligned <= 255), 'Pixel values should be <= 255'
 
 
 def test_face_alignment_not_all_zeros(mock_image, mock_landmarks):
@@ -195,7 +195,7 @@ def test_face_alignment_not_all_zeros(mock_image, mock_landmarks):
     aligned, _ = face_alignment(mock_image, mock_landmarks, image_size=(112, 112))
 
     # At least some pixels should be non-zero
-    assert np.any(aligned > 0), "Aligned face should have some non-zero pixels"
+    assert np.any(aligned > 0), 'Aligned face should have some non-zero pixels'
 
 
 def test_face_alignment_from_different_positions(mock_image):
@@ -220,7 +220,7 @@ def test_face_alignment_from_different_positions(mock_image):
 
     for landmarks in positions:
         aligned, _ = face_alignment(mock_image, landmarks, image_size=(112, 112))
-        assert aligned.shape == (112, 112, 3), f"Failed for landmarks at {landmarks[0]}"
+        assert aligned.shape == (112, 112, 3), f'Failed for landmarks at {landmarks[0]}'
 
 
 def test_face_alignment_landmark_count(mock_image):
@@ -240,7 +240,7 @@ def test_face_alignment_landmark_count(mock_image):
     )
 
     aligned, _ = face_alignment(mock_image, landmarks_5pt, image_size=(112, 112))
-    assert aligned.shape == (112, 112, 3), "Should work with 5-point landmarks"
+    assert aligned.shape == (112, 112, 3), 'Should work with 5-point landmarks'
 
 
 def test_compute_similarity_with_recognition_embeddings():
diff --git a/uniface/__init__.py b/uniface/__init__.py
index ad23895..fed089b 100644
--- a/uniface/__init__.py
+++ b/uniface/__init__.py
@@ -11,9 +11,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__license__ = "MIT"
-__author__ = "Yakhyokhuja Valikhujaev"
-__version__ = "1.1.1"
+__license__ = 'MIT'
+__author__ = 'Yakhyokhuja Valikhujaev'
+__version__ = '1.1.2'
 
 
 from uniface.face_utils import compute_similarity, face_alignment
@@ -21,7 +21,9 @@ from uniface.log import Logger, enable_logging
 from uniface.model_store import verify_model_weights
 from uniface.visualization import draw_detections
 
+from .analyzer import FaceAnalyzer
 from .attribute import AgeGender
+from .face import Face
 
 try:
     from .attribute import Emotion
@@ -38,32 +40,35 @@ from .landmark import Landmark106, create_landmarker
 from .recognition import ArcFace, MobileFace, SphereFace, create_recognizer
 
 __all__ = [
-    "__author__",
-    "__license__",
-    "__version__",
+    '__author__',
+    '__license__',
+    '__version__',
+    # Core classes
+    'Face',
+    'FaceAnalyzer',
     # Factory functions
-    "create_detector",
-    "create_landmarker",
-    "create_recognizer",
-    "detect_faces",
-    "list_available_detectors",
+    'create_detector',
+    'create_landmarker',
+    'create_recognizer',
+    'detect_faces',
+    'list_available_detectors',
     # Detection models
-    "RetinaFace",
-    "SCRFD",
+    'RetinaFace',
+    'SCRFD',
     # Recognition models
-    "ArcFace",
-    "MobileFace",
-    "SphereFace",
+    'ArcFace',
+    'MobileFace',
+    'SphereFace',
     # Landmark models
-    "Landmark106",
+    'Landmark106',
     # Attribute models
-    "AgeGender",
-    "Emotion",
+    'AgeGender',
+    'Emotion',
     # Utilities
-    "compute_similarity",
-    "draw_detections",
-    "face_alignment",
-    "verify_model_weights",
-    "Logger",
-    "enable_logging",
+    'compute_similarity',
+    'draw_detections',
+    'face_alignment',
+    'verify_model_weights',
+    'Logger',
+    'enable_logging',
 ]
diff --git a/uniface/analyzer.py b/uniface/analyzer.py
new file mode 100644
index 0000000..156979a
--- /dev/null
+++ b/uniface/analyzer.py
@@ -0,0 +1,84 @@
+# Copyright 2025 Yakhyokhuja Valikhujaev
+# Author: Yakhyokhuja Valikhujaev
+# GitHub: https://github.com/yakhyo
+
+from typing import List, Optional
+
+import numpy as np
+
+from uniface.attribute.age_gender import AgeGender
+from uniface.detection.base import BaseDetector
+from uniface.face import Face
+from uniface.log import Logger
+from uniface.recognition.base import BaseRecognizer
+
+__all__ = ['FaceAnalyzer']
+
+
+class FaceAnalyzer:
+    """Unified face analyzer combining detection, recognition, and attributes."""
+
+    def __init__(
+        self,
+        detector: BaseDetector,
+        recognizer: Optional[BaseRecognizer] = None,
+        age_gender: Optional[AgeGender] = None,
+    ) -> None:
+        self.detector = detector
+        self.recognizer = recognizer
+        self.age_gender = age_gender
+
+        Logger.info(f'Initialized FaceAnalyzer with detector={detector.__class__.__name__}')
+        if recognizer:
+            Logger.info(f'  - Recognition enabled: {recognizer.__class__.__name__}')
+        if age_gender:
+            Logger.info(f'  - Age/Gender enabled: {age_gender.__class__.__name__}')
+
+    def analyze(self, image: np.ndarray) -> List[Face]:
+        """Analyze faces in an image."""
+        detections = self.detector.detect(image)
+        Logger.debug(f'Detected {len(detections)} face(s)')
+
+        faces = []
+        for idx, detection in enumerate(detections):
+            bbox = detection['bbox']
+            confidence = detection['confidence']
+            landmarks = detection['landmarks']
+
+            embedding = None
+            if self.recognizer is not None:
+                try:
+                    embedding = self.recognizer.get_normalized_embedding(image, landmarks)
+                    Logger.debug(f'  Face {idx + 1}: Extracted embedding with shape {embedding.shape}')
+                except Exception as e:
+                    Logger.warning(f'  Face {idx + 1}: Failed to extract embedding: {e}')
+
+            age, gender_id = None, None
+            if self.age_gender is not None:
+                try:
+                    gender_id, age = self.age_gender.predict(image, bbox)
+                    gender_str = 'Female' if gender_id == 0 else 'Male'
+                    Logger.debug(f'  Face {idx + 1}: Age={age}, Gender={gender_str}')
+                except Exception as e:
+                    Logger.warning(f'  Face {idx + 1}: Failed to predict age/gender: {e}')
+
+            face = Face(
+                bbox=bbox,
+                confidence=confidence,
+                landmarks=landmarks,
+                embedding=embedding,
+                age=age,
+                gender_id=gender_id,
+            )
+            faces.append(face)
+
+        Logger.info(f'Analysis complete: {len(faces)} face(s) processed')
+        return faces
+
+    def __repr__(self) -> str:
+        parts = [f'FaceAnalyzer(detector={self.detector.__class__.__name__}']
+        if self.recognizer:
+            parts.append(f'recognizer={self.recognizer.__class__.__name__}')
+        if self.age_gender:
+            parts.append(f'age_gender={self.age_gender.__class__.__name__}')
+        return ', '.join(parts) + ')'
diff --git a/uniface/attribute/__init__.py b/uniface/attribute/__init__.py
index 3f6dc28..7111ff2 100644
--- a/uniface/attribute/__init__.py
+++ b/uniface/attribute/__init__.py
@@ -20,7 +20,7 @@ except ImportError:
     _EMOTION_AVAILABLE = False
 
 # Public API for the attribute module
-__all__ = ["AgeGender", "Emotion", "create_attribute_predictor", "predict_attributes"]
+__all__ = ['AgeGender', 'Emotion', 'create_attribute_predictor', 'predict_attributes']
 
 # A mapping from model enums to their corresponding attribute classes
 _ATTRIBUTE_MODELS = {
@@ -54,7 +54,7 @@ def create_attribute_predictor(model_name: Union[AgeGenderWeights, DDAMFNWeights
 
     if model_class is None:
         raise ValueError(
-            f"Unsupported attribute model: {model_name}. Please choose from AgeGenderWeights or DDAMFNWeights."
+            f'Unsupported attribute model: {model_name}. Please choose from AgeGenderWeights or DDAMFNWeights.'
         )
 
     # Pass model_name to the constructor, as some classes might need it
@@ -84,16 +84,16 @@ def predict_attributes(
     """
     for face in detections:
         # Initialize attributes dict if it doesn't exist
-        if "attributes" not in face:
-            face["attributes"] = {}
+        if 'attributes' not in face:
+            face['attributes'] = {}
 
         if isinstance(predictor, AgeGender):
-            gender, age = predictor(image, face["bbox"])
-            face["attributes"]["gender"] = gender
-            face["attributes"]["age"] = age
+            gender_id, age = predictor(image, face['bbox'])
+            face['attributes']['gender_id'] = gender_id
+            face['attributes']['age'] = age
         elif isinstance(predictor, Emotion):
-            emotion, confidence = predictor(image, face["landmark"])
-            face["attributes"]["emotion"] = emotion
-            face["attributes"]["confidence"] = confidence
+            emotion, confidence = predictor(image, face['landmark'])
+            face['attributes']['emotion'] = emotion
+            face['attributes']['confidence'] = confidence
 
     return detections
diff --git a/uniface/attribute/age_gender.py b/uniface/attribute/age_gender.py
index d738ad3..f1ee837 100644
--- a/uniface/attribute/age_gender.py
+++ b/uniface/attribute/age_gender.py
@@ -14,7 +14,7 @@ from uniface.log import Logger
 from uniface.model_store import verify_model_weights
 from uniface.onnx_utils import create_onnx_session
 
-__all__ = ["AgeGender"]
+__all__ = ['AgeGender']
 
 
 class AgeGender(Attribute):
@@ -22,8 +22,8 @@ class AgeGender(Attribute):
     Age and gender prediction model using ONNX Runtime.
 
     This class inherits from the base `Attribute` class and implements the
-    functionality for predicting age (in years) and gender (0 for female,
-    1 for male) from a face image. It requires a bounding box to locate the face.
+    functionality for predicting age (in years) and gender ID (0 for Female,
+    1 for Male) from a face image. It requires a bounding box to locate the face.
     """
 
     def __init__(self, model_name: AgeGenderWeights = AgeGenderWeights.DEFAULT) -> None:
@@ -34,7 +34,7 @@ class AgeGender(Attribute):
             model_name (AgeGenderWeights): The enum specifying the model weights
                                            to load.
         """
-        Logger.info(f"Initializing AgeGender with model={model_name.name}")
+        Logger.info(f'Initializing AgeGender with model={model_name.name}')
         self.model_path = verify_model_weights(model_name)
         self._initialize_model()
 
@@ -49,13 +49,13 @@ class AgeGender(Attribute):
             self.input_name = input_meta.name
             self.input_size = tuple(input_meta.shape[2:4])  # (height, width)
             self.output_names = [output.name for output in self.session.get_outputs()]
-            Logger.info(f"Successfully initialized AgeGender model with input size {self.input_size}")
+            Logger.info(f'Successfully initialized AgeGender model with input size {self.input_size}')
         except Exception as e:
             Logger.error(
                 f"Failed to load AgeGender model from '{self.model_path}'",
                 exc_info=True,
             )
-            raise RuntimeError(f"Failed to initialize AgeGender model: {e}") from e
+            raise RuntimeError(f'Failed to initialize AgeGender model: {e}') from e
 
     def preprocess(self, image: np.ndarray, bbox: Union[List, np.ndarray]) -> np.ndarray:
         """
@@ -87,7 +87,7 @@ class AgeGender(Attribute):
         )
         return blob
 
-    def postprocess(self, prediction: np.ndarray) -> Tuple[str, int]:
+    def postprocess(self, prediction: np.ndarray) -> Tuple[int, int]:
         """
         Processes the raw model output to extract gender and age.
 
@@ -95,17 +95,16 @@ class AgeGender(Attribute):
             prediction (np.ndarray): The raw output from the model inference.
 
         Returns:
-            Tuple[str, int]: A tuple containing the predicted gender label ("Female" or "Male")
+            Tuple[int, int]: A tuple containing the predicted gender ID (0 for Female, 1 for Male)
                              and age (in years).
         """
         # First two values are gender logits
         gender_id = int(np.argmax(prediction[:2]))
-        gender = "Female" if gender_id == 0 else "Male"
         # Third value is normalized age, scaled by 100
         age = int(np.round(prediction[2] * 100))
-        return gender, age
+        return gender_id, age
 
-    def predict(self, image: np.ndarray, bbox: Union[List, np.ndarray]) -> Tuple[str, int]:
+    def predict(self, image: np.ndarray, bbox: Union[List, np.ndarray]) -> Tuple[int, int]:
         """
         Predicts age and gender for a single face specified by a bounding box.
 
@@ -114,22 +113,22 @@ class AgeGender(Attribute):
             bbox (Union[List, np.ndarray]): The face bounding box coordinates [x1, y1, x2, y2].
 
         Returns:
-            Tuple[str, int]: A tuple containing the predicted gender label and age.
+            Tuple[int, int]: A tuple containing the predicted gender ID (0 for Female, 1 for Male) and age.
         """
         face_blob = self.preprocess(image, bbox)
         prediction = self.session.run(self.output_names, {self.input_name: face_blob})[0][0]
-        gender, age = self.postprocess(prediction)
-        return gender, age
+        gender_id, age = self.postprocess(prediction)
+        return gender_id, age
 
 
 # TODO: below is only for testing, remove it later
-if __name__ == "__main__":
+if __name__ == '__main__':
     # To run this script, you need to have uniface.detection installed
     # or available in your path.
     from uniface.constants import RetinaFaceWeights
     from uniface.detection import create_detector
 
-    print("Initializing models for live inference...")
+    print('Initializing models for live inference...')
     # 1. Initialize the face detector
     # Using a smaller model for faster real-time performance
     detector = create_detector(model_name=RetinaFaceWeights.MNET_V2)
@@ -140,14 +139,14 @@ if __name__ == "__main__":
     # 3. Start webcam capture
     cap = cv2.VideoCapture(0)
     if not cap.isOpened():
-        print("Error: Could not open webcam.")
+        print('Error: Could not open webcam.')
         exit()
 
     print("Starting webcam feed. Press 'q' to quit.")
     while True:
         ret, frame = cap.read()
         if not ret:
-            print("Error: Failed to capture frame.")
+            print('Error: Failed to capture frame.')
             break
 
         # Detect faces in the current frame
@@ -155,14 +154,15 @@ if __name__ == "__main__":
 
         # For each detected face, predict age and gender
         for detection in detections:
-            box = detection["bbox"]
+            box = detection['bbox']
             x1, y1, x2, y2 = map(int, box)
 
             # Predict attributes
-            gender, age = age_gender_predictor.predict(frame, box)
+            gender_id, age = age_gender_predictor.predict(frame, box)
+            gender_str = 'Female' if gender_id == 0 else 'Male'
 
             # Prepare text and draw on the frame
-            label = f"{gender}, {age}"
+            label = f'{gender_str}, {age}'
             cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
             cv2.putText(
                 frame,
@@ -178,10 +178,10 @@ if __name__ == "__main__":
         cv2.imshow("Age and Gender Inference (Press 'q' to quit)", frame)
 
         # Break the loop if 'q' is pressed
-        if cv2.waitKey(1) & 0xFF == ord("q"):
+        if cv2.waitKey(1) & 0xFF == ord('q'):
             break
 
     # Release resources
     cap.release()
     cv2.destroyAllWindows()
-    print("Inference stopped.")
+    print('Inference stopped.')
diff --git a/uniface/attribute/base.py b/uniface/attribute/base.py
index 33b548a..b9ba73f 100644
--- a/uniface/attribute/base.py
+++ b/uniface/attribute/base.py
@@ -27,7 +27,7 @@ class Attribute(ABC):
         inference session (e.g., ONNX Runtime, PyTorch), and any necessary
         warm-up procedures to prepare the model for prediction.
         """
-        raise NotImplementedError("Subclasses must implement the _initialize_model method.")
+        raise NotImplementedError('Subclasses must implement the _initialize_model method.')
 
     @abstractmethod
     def preprocess(self, image: np.ndarray, *args: Any) -> Any:
@@ -47,7 +47,7 @@ class Attribute(ABC):
         Returns:
             The preprocessed data ready for model inference.
         """
-        raise NotImplementedError("Subclasses must implement the preprocess method.")
+        raise NotImplementedError('Subclasses must implement the preprocess method.')
 
     @abstractmethod
     def postprocess(self, prediction: Any) -> Any:
@@ -64,7 +64,7 @@ class Attribute(ABC):
         Returns:
             The final, processed attributes.
         """
-        raise NotImplementedError("Subclasses must implement the postprocess method.")
+        raise NotImplementedError('Subclasses must implement the postprocess method.')
 
     @abstractmethod
     def predict(self, image: np.ndarray, *args: Any) -> Any:
@@ -83,7 +83,7 @@ class Attribute(ABC):
         Returns:
             The final predicted attributes.
         """
-        raise NotImplementedError("Subclasses must implement the predict method.")
+        raise NotImplementedError('Subclasses must implement the predict method.')
 
     def __call__(self, *args, **kwargs) -> Any:
         """
diff --git a/uniface/attribute/emotion.py b/uniface/attribute/emotion.py
index 8aa38b3..9daeace 100644
--- a/uniface/attribute/emotion.py
+++ b/uniface/attribute/emotion.py
@@ -14,7 +14,7 @@ from uniface.face_utils import face_alignment
 from uniface.log import Logger
 from uniface.model_store import verify_model_weights
 
-__all__ = ["Emotion"]
+__all__ = ['Emotion']
 
 
 class Emotion(Attribute):
@@ -38,23 +38,30 @@ class Emotion(Attribute):
             model_weights (DDAMFNWeights): The enum for the model weights to load.
             input_size (Tuple[int, int]): The expected input size for the model.
         """
-        Logger.info(f"Initializing Emotion with model={model_weights.name}")
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        Logger.info(f'Initializing Emotion with model={model_weights.name}')
+
+        if torch.backends.mps.is_available():
+            self.device = torch.device('mps')
+        elif torch.cuda.is_available():
+            self.device = torch.device('cuda')
+        else:
+            self.device = torch.device('cpu')
+
         self.input_size = input_size
         self.model_path = verify_model_weights(model_weights)
 
         # Define emotion labels based on the selected model
         self.emotion_labels = [
-            "Neutral",
-            "Happy",
-            "Sad",
-            "Surprise",
-            "Fear",
-            "Disgust",
-            "Angry",
+            'Neutral',
+            'Happy',
+            'Sad',
+            'Surprise',
+            'Fear',
+            'Disgust',
+            'Angry',
         ]
         if model_weights == DDAMFNWeights.AFFECNET8:
-            self.emotion_labels.append("Contempt")
+            self.emotion_labels.append('Contempt')
 
         self._initialize_model()
 
@@ -69,10 +76,10 @@ class Emotion(Attribute):
             dummy_input = torch.randn(1, 3, *self.input_size).to(self.device)
             with torch.no_grad():
                 self.model(dummy_input)
-            Logger.info(f"Successfully initialized Emotion model on {self.device}")
+            Logger.info(f'Successfully initialized Emotion model on {self.device}')
         except Exception as e:
             Logger.error(f"Failed to load Emotion model from '{self.model_path}'", exc_info=True)
-            raise RuntimeError(f"Failed to initialize Emotion model: {e}") from e
+            raise RuntimeError(f'Failed to initialize Emotion model: {e}') from e
 
     def preprocess(self, image: np.ndarray, landmark: Union[List, np.ndarray]) -> torch.Tensor:
         """
@@ -123,11 +130,11 @@ class Emotion(Attribute):
 
 
 # TODO: below is only for testing, remove it later
-if __name__ == "__main__":
+if __name__ == '__main__':
     from uniface.constants import RetinaFaceWeights
     from uniface.detection import create_detector
 
-    print("Initializing models for live inference...")
+    print('Initializing models for live inference...')
     # 1. Initialize the face detector
     # Using a smaller model for faster real-time performance
     detector = create_detector(model_name=RetinaFaceWeights.MNET_V2)
@@ -138,14 +145,14 @@ if __name__ == "__main__":
     # 3. Start webcam capture
     cap = cv2.VideoCapture(0)
     if not cap.isOpened():
-        print("Error: Could not open webcam.")
+        print('Error: Could not open webcam.')
         exit()
 
     print("Starting webcam feed. Press 'q' to quit.")
     while True:
         ret, frame = cap.read()
         if not ret:
-            print("Error: Failed to capture frame.")
+            print('Error: Failed to capture frame.')
             break
 
         # Detect faces in the current frame.
@@ -154,15 +161,15 @@ if __name__ == "__main__":
 
         # For each detected face, predict the emotion
         for detection in detections:
-            box = detection["bbox"]
-            landmark = detection["landmarks"]
+            box = detection['bbox']
+            landmark = detection['landmarks']
             x1, y1, x2, y2 = map(int, box)
 
             # Predict attributes using the landmark
             emotion, confidence = emotion_predictor.predict(frame, landmark)
 
             # Prepare text and draw on the frame
-            label = f"{emotion} ({confidence:.2f})"
+            label = f'{emotion} ({confidence:.2f})'
             cv2.rectangle(frame, (x1, y1), (x2, y2), (255, 0, 0), 2)
             cv2.putText(
                 frame,
@@ -178,10 +185,10 @@ if __name__ == "__main__":
         cv2.imshow("Emotion Inference (Press 'q' to quit)", frame)
 
         # Break the loop if 'q' is pressed
-        if cv2.waitKey(1) & 0xFF == ord("q"):
+        if cv2.waitKey(1) & 0xFF == ord('q'):
             break
 
     # Release resources
     cap.release()
     cv2.destroyAllWindows()
-    print("Inference stopped.")
+    print('Inference stopped.')
diff --git a/uniface/common.py b/uniface/common.py
index 028a1b3..1098552 100644
--- a/uniface/common.py
+++ b/uniface/common.py
@@ -4,11 +4,21 @@
 
 import itertools
 import math
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 import cv2
 import numpy as np
 
+__all__ = [
+    'resize_image',
+    'generate_anchors',
+    'non_max_suppression',
+    'decode_boxes',
+    'decode_landmarks',
+    'distance2bbox',
+    'distance2kps',
+]
+
 
 def resize_image(frame, target_shape: Tuple[int, int] = (640, 640)) -> Tuple[np.ndarray, float]:
     """
@@ -45,16 +55,14 @@ def resize_image(frame, target_shape: Tuple[int, int] = (640, 640)) -> Tuple[np.
 
 def generate_anchors(image_size: Tuple[int, int] = (640, 640)) -> np.ndarray:
     """
-    Generate anchor boxes for a given image size.
+    Generate anchor boxes for a given image size (RetinaFace specific).
 
     Args:
         image_size (Tuple[int, int]): Input image size (width, height). Defaults to (640, 640).
 
     Returns:
-        np.ndarray: Anchor box coordinates as a NumPy array.
+        np.ndarray: Anchor box coordinates as a NumPy array with shape (num_anchors, 4).
     """
-    image_size = image_size
-
     steps = [8, 16, 32]
     min_sizes = [[16, 32], [64, 128], [256, 512]]
 
@@ -77,16 +85,16 @@ def generate_anchors(image_size: Tuple[int, int] = (640, 640)) -> np.ndarray:
     return output
 
 
-def non_max_supression(dets: List[np.ndarray], threshold: float):
+def non_max_suppression(dets: np.ndarray, threshold: float) -> List[int]:
     """
     Apply Non-Maximum Suppression (NMS) to reduce overlapping bounding boxes based on a threshold.
 
     Args:
-        dets (numpy.ndarray): Array of detections with each row as [x1, y1, x2, y2, score].
+        dets (np.ndarray): Array of detections with each row as [x1, y1, x2, y2, score].
         threshold (float): IoU threshold for suppression.
 
     Returns:
-        list: Indices of bounding boxes retained after suppression.
+        List[int]: Indices of bounding boxes retained after suppression.
     """
     x1 = dets[:, 0]
     y1 = dets[:, 1]
@@ -117,19 +125,21 @@ def non_max_supression(dets: List[np.ndarray], threshold: float):
     return keep
 
 
-def decode_boxes(loc, priors, variances=[0.1, 0.2]) -> np.ndarray:
+def decode_boxes(loc: np.ndarray, priors: np.ndarray, variances: Optional[List[float]] = None) -> np.ndarray:
     """
     Decode locations from predictions using priors to undo
-    the encoding done for offset regression at train time.
+    the encoding done for offset regression at train time (RetinaFace specific).
 
     Args:
         loc (np.ndarray): Location predictions for loc layers, shape: [num_priors, 4]
         priors (np.ndarray): Prior boxes in center-offset form, shape: [num_priors, 4]
-        variances (list[float]): Variances of prior boxes
+        variances (Optional[List[float]]): Variances of prior boxes. Defaults to [0.1, 0.2].
 
     Returns:
-        np.ndarray: Decoded bounding box predictions
+        np.ndarray: Decoded bounding box predictions with shape [num_priors, 4]
     """
+    if variances is None:
+        variances = [0.1, 0.2]
     # Compute centers of predicted boxes
     cxcy = priors[:, :2] + loc[:, :2] * variances[0] * priors[:, 2:]
 
@@ -144,18 +154,22 @@ def decode_boxes(loc, priors, variances=[0.1, 0.2]) -> np.ndarray:
     return boxes
 
 
-def decode_landmarks(predictions, priors, variances=[0.1, 0.2]) -> np.ndarray:
+def decode_landmarks(
+    predictions: np.ndarray, priors: np.ndarray, variances: Optional[List[float]] = None
+) -> np.ndarray:
     """
-    Decode landmark predictions using prior boxes.
+    Decode landmark predictions using prior boxes (RetinaFace specific).
 
     Args:
         predictions (np.ndarray): Landmark predictions, shape: [num_priors, 10]
         priors (np.ndarray): Prior boxes, shape: [num_priors, 4]
-        variances (list): Scaling factors for landmark offsets.
+        variances (Optional[List[float]]): Scaling factors for landmark offsets. Defaults to [0.1, 0.2].
 
     Returns:
         np.ndarray: Decoded landmarks, shape: [num_priors, 10]
     """
+    if variances is None:
+        variances = [0.1, 0.2]
 
     # Reshape predictions to [num_priors, 5, 2] to process landmark points
     predictions = predictions.reshape(predictions.shape[0], 5, 2)
@@ -171,3 +185,59 @@ def decode_landmarks(predictions, priors, variances=[0.1, 0.2]) -> np.ndarray:
     landmarks = landmarks.reshape(landmarks.shape[0], -1)
 
     return landmarks
+
+
+def distance2bbox(points: np.ndarray, distance: np.ndarray, max_shape: Optional[Tuple[int, int]] = None) -> np.ndarray:
+    """
+    Decode distance prediction to bounding box (SCRFD specific).
+
+    Args:
+        points (np.ndarray): Anchor points with shape (n, 2), [x, y].
+        distance (np.ndarray): Distance from the given point to 4
+            boundaries (left, top, right, bottom) with shape (n, 4).
+        max_shape (Optional[Tuple[int, int]]): Shape of the image (height, width) for clipping.
+
+    Returns:
+        np.ndarray: Decoded bounding boxes with shape (n, 4) as [x1, y1, x2, y2].
+    """
+    x1 = points[:, 0] - distance[:, 0]
+    y1 = points[:, 1] - distance[:, 1]
+    x2 = points[:, 0] + distance[:, 2]
+    y2 = points[:, 1] + distance[:, 3]
+
+    if max_shape is not None:
+        x1 = np.clip(x1, 0, max_shape[1])
+        y1 = np.clip(y1, 0, max_shape[0])
+        x2 = np.clip(x2, 0, max_shape[1])
+        y2 = np.clip(y2, 0, max_shape[0])
+    else:
+        x1 = np.maximum(x1, 0)
+        y1 = np.maximum(y1, 0)
+        x2 = np.maximum(x2, 0)
+        y2 = np.maximum(y2, 0)
+
+    return np.stack([x1, y1, x2, y2], axis=-1)
+
+
+def distance2kps(points: np.ndarray, distance: np.ndarray, max_shape: Optional[Tuple[int, int]] = None) -> np.ndarray:
+    """
+    Decode distance prediction to keypoints (SCRFD specific).
+
+    Args:
+        points (np.ndarray): Anchor points with shape (n, 2), [x, y].
+        distance (np.ndarray): Distance from the given point to keypoints with shape (n, 2k).
+        max_shape (Optional[Tuple[int, int]]): Shape of the image (height, width) for clipping.
+
+    Returns:
+        np.ndarray: Decoded keypoints with shape (n, 2k).
+    """
+    preds = []
+    for i in range(0, distance.shape[1], 2):
+        px = points[:, i % 2] + distance[:, i]
+        py = points[:, i % 2 + 1] + distance[:, i + 1]
+        if max_shape is not None:
+            px = np.clip(px, 0, max_shape[1])
+            py = np.clip(py, 0, max_shape[0])
+        preds.append(px)
+        preds.append(py)
+    return np.stack(preds, axis=-1)
diff --git a/uniface/constants.py b/uniface/constants.py
index 7c5701a..f2178a3 100644
--- a/uniface/constants.py
+++ b/uniface/constants.py
@@ -79,69 +79,67 @@ class LandmarkWeights(str, Enum):
     """
     DEFAULT = "2d_106"
 
-# fmt: on
-
 
 MODEL_URLS: Dict[Enum, str] = {
     # RetinaFace
-    RetinaFaceWeights.MNET_025: "https://github.com/yakhyo/uniface/releases/download/weights/retinaface_mv1_0.25.onnx",
-    RetinaFaceWeights.MNET_050: "https://github.com/yakhyo/uniface/releases/download/weights/retinaface_mv1_0.50.onnx",
-    RetinaFaceWeights.MNET_V1: "https://github.com/yakhyo/uniface/releases/download/weights/retinaface_mv1.onnx",
-    RetinaFaceWeights.MNET_V2: "https://github.com/yakhyo/uniface/releases/download/weights/retinaface_mv2.onnx",
-    RetinaFaceWeights.RESNET18: "https://github.com/yakhyo/uniface/releases/download/weights/retinaface_r18.onnx",
-    RetinaFaceWeights.RESNET34: "https://github.com/yakhyo/uniface/releases/download/weights/retinaface_r34.onnx",
+    RetinaFaceWeights.MNET_025:      'https://github.com/yakhyo/uniface/releases/download/weights/retinaface_mv1_0.25.onnx',
+    RetinaFaceWeights.MNET_050:      'https://github.com/yakhyo/uniface/releases/download/weights/retinaface_mv1_0.50.onnx',
+    RetinaFaceWeights.MNET_V1:       'https://github.com/yakhyo/uniface/releases/download/weights/retinaface_mv1.onnx',
+    RetinaFaceWeights.MNET_V2:       'https://github.com/yakhyo/uniface/releases/download/weights/retinaface_mv2.onnx',
+    RetinaFaceWeights.RESNET18:      'https://github.com/yakhyo/uniface/releases/download/weights/retinaface_r18.onnx',
+    RetinaFaceWeights.RESNET34:      'https://github.com/yakhyo/uniface/releases/download/weights/retinaface_r34.onnx',
     # MobileFace
-    MobileFaceWeights.MNET_025: "https://github.com/yakhyo/uniface/releases/download/weights/mobilenetv1_0.25.onnx",
-    MobileFaceWeights.MNET_V2: "https://github.com/yakhyo/uniface/releases/download/weights/mobilenetv2.onnx",
-    MobileFaceWeights.MNET_V3_SMALL: "https://github.com/yakhyo/uniface/releases/download/weights/mobilenetv3_small.onnx",
-    MobileFaceWeights.MNET_V3_LARGE: "https://github.com/yakhyo/uniface/releases/download/weights/mobilenetv3_large.onnx",
+    MobileFaceWeights.MNET_025:      'https://github.com/yakhyo/uniface/releases/download/weights/mobilenetv1_0.25.onnx',
+    MobileFaceWeights.MNET_V2:       'https://github.com/yakhyo/uniface/releases/download/weights/mobilenetv2.onnx',
+    MobileFaceWeights.MNET_V3_SMALL: 'https://github.com/yakhyo/uniface/releases/download/weights/mobilenetv3_small.onnx',
+    MobileFaceWeights.MNET_V3_LARGE: 'https://github.com/yakhyo/uniface/releases/download/weights/mobilenetv3_large.onnx',
     # SphereFace
-    SphereFaceWeights.SPHERE20: "https://github.com/yakhyo/uniface/releases/download/weights/sphere20.onnx",
-    SphereFaceWeights.SPHERE36: "https://github.com/yakhyo/uniface/releases/download/weights/sphere36.onnx",
+    SphereFaceWeights.SPHERE20:      'https://github.com/yakhyo/uniface/releases/download/weights/sphere20.onnx',
+    SphereFaceWeights.SPHERE36:      'https://github.com/yakhyo/uniface/releases/download/weights/sphere36.onnx',
     # ArcFace
-    ArcFaceWeights.MNET: "https://github.com/yakhyo/uniface/releases/download/weights/w600k_mbf.onnx",
-    ArcFaceWeights.RESNET: "https://github.com/yakhyo/uniface/releases/download/weights/w600k_r50.onnx",
+    ArcFaceWeights.MNET:             'https://github.com/yakhyo/uniface/releases/download/weights/w600k_mbf.onnx',
+    ArcFaceWeights.RESNET:           'https://github.com/yakhyo/uniface/releases/download/weights/w600k_r50.onnx',
     # SCRFD
-    SCRFDWeights.SCRFD_10G_KPS: "https://github.com/yakhyo/uniface/releases/download/weights/scrfd_10g_kps.onnx",
-    SCRFDWeights.SCRFD_500M_KPS: "https://github.com/yakhyo/uniface/releases/download/weights/scrfd_500m_kps.onnx",
+    SCRFDWeights.SCRFD_10G_KPS:      'https://github.com/yakhyo/uniface/releases/download/weights/scrfd_10g_kps.onnx',
+    SCRFDWeights.SCRFD_500M_KPS:     'https://github.com/yakhyo/uniface/releases/download/weights/scrfd_500m_kps.onnx',
     # DDAFM
-    DDAMFNWeights.AFFECNET7: "https://github.com/yakhyo/uniface/releases/download/weights/affecnet7.script",
-    DDAMFNWeights.AFFECNET8: "https://github.com/yakhyo/uniface/releases/download/weights/affecnet8.script",
+    DDAMFNWeights.AFFECNET7:         'https://github.com/yakhyo/uniface/releases/download/weights/affecnet7.script',
+    DDAMFNWeights.AFFECNET8:         'https://github.com/yakhyo/uniface/releases/download/weights/affecnet8.script',
     # AgeGender
-    AgeGenderWeights.DEFAULT: "https://github.com/yakhyo/uniface/releases/download/weights/genderage.onnx",
+    AgeGenderWeights.DEFAULT:        'https://github.com/yakhyo/uniface/releases/download/weights/genderage.onnx',
     # Landmarks
-    LandmarkWeights.DEFAULT: "https://github.com/yakhyo/uniface/releases/download/weights/2d106det.onnx",
+    LandmarkWeights.DEFAULT:         'https://github.com/yakhyo/uniface/releases/download/weights/2d106det.onnx',
 }
 
 MODEL_SHA256: Dict[Enum, str] = {
     # RetinaFace
-    RetinaFaceWeights.MNET_025: "b7a7acab55e104dce6f32cdfff929bd83946da5cd869b9e2e9bdffafd1b7e4a5",
-    RetinaFaceWeights.MNET_050: "d8977186f6037999af5b4113d42ba77a84a6ab0c996b17c713cc3d53b88bfc37",
-    RetinaFaceWeights.MNET_V1: "75c961aaf0aff03d13c074e9ec656e5510e174454dd4964a161aab4fe5f04153",
-    RetinaFaceWeights.MNET_V2: "3ca44c045651cabeed1193a1fae8946ad1f3a55da8fa74b341feab5a8319f757",
-    RetinaFaceWeights.RESNET18: "e8b5ddd7d2c3c8f7c942f9f10cec09d8e319f78f09725d3f709631de34fb649d",
-    RetinaFaceWeights.RESNET34: "bd0263dc2a465d32859555cb1741f2d98991eb0053696e8ee33fec583d30e630",
+    RetinaFaceWeights.MNET_025:      'b7a7acab55e104dce6f32cdfff929bd83946da5cd869b9e2e9bdffafd1b7e4a5',
+    RetinaFaceWeights.MNET_050:      'd8977186f6037999af5b4113d42ba77a84a6ab0c996b17c713cc3d53b88bfc37',
+    RetinaFaceWeights.MNET_V1:       '75c961aaf0aff03d13c074e9ec656e5510e174454dd4964a161aab4fe5f04153',
+    RetinaFaceWeights.MNET_V2:       '3ca44c045651cabeed1193a1fae8946ad1f3a55da8fa74b341feab5a8319f757',
+    RetinaFaceWeights.RESNET18:      'e8b5ddd7d2c3c8f7c942f9f10cec09d8e319f78f09725d3f709631de34fb649d',
+    RetinaFaceWeights.RESNET34:      'bd0263dc2a465d32859555cb1741f2d98991eb0053696e8ee33fec583d30e630',
     # MobileFace
-    MobileFaceWeights.MNET_025: "eeda7d23d9c2b40cf77fa8da8e895b5697465192648852216074679657f8ee8b",
-    MobileFaceWeights.MNET_V2: "38b148284dd48cc898d5d4453104252fbdcbacc105fe3f0b80e78954d9d20d89",
-    MobileFaceWeights.MNET_V3_SMALL: "d4acafa1039a82957aa8a9a1dac278a401c353a749c39df43de0e29cc1c127c3",
-    MobileFaceWeights.MNET_V3_LARGE: "0e48f8e11f070211716d03e5c65a3db35a5e917cfb5bc30552358629775a142a",
+    MobileFaceWeights.MNET_025:      'eeda7d23d9c2b40cf77fa8da8e895b5697465192648852216074679657f8ee8b',
+    MobileFaceWeights.MNET_V2:       '38b148284dd48cc898d5d4453104252fbdcbacc105fe3f0b80e78954d9d20d89',
+    MobileFaceWeights.MNET_V3_SMALL: 'd4acafa1039a82957aa8a9a1dac278a401c353a749c39df43de0e29cc1c127c3',
+    MobileFaceWeights.MNET_V3_LARGE: '0e48f8e11f070211716d03e5c65a3db35a5e917cfb5bc30552358629775a142a',
     # SphereFace
-    SphereFaceWeights.SPHERE20: "c02878cf658eb1861f580b7e7144b0d27cc29c440bcaa6a99d466d2854f14c9d",
-    SphereFaceWeights.SPHERE36: "13b3890cd5d7dec2b63f7c36fd7ce07403e5a0bbb701d9647c0289e6cbe7bb20",
+    SphereFaceWeights.SPHERE20:      'c02878cf658eb1861f580b7e7144b0d27cc29c440bcaa6a99d466d2854f14c9d',
+    SphereFaceWeights.SPHERE36:      '13b3890cd5d7dec2b63f7c36fd7ce07403e5a0bbb701d9647c0289e6cbe7bb20',
     # ArcFace
-    ArcFaceWeights.MNET: "9cc6e4a75f0e2bf0b1aed94578f144d15175f357bdc05e815e5c4a02b319eb4f",
-    ArcFaceWeights.RESNET: "4c06341c33c2ca1f86781dab0e829f88ad5b64be9fba56e56bc9ebdefc619e43",
+    ArcFaceWeights.MNET:             '9cc6e4a75f0e2bf0b1aed94578f144d15175f357bdc05e815e5c4a02b319eb4f',
+    ArcFaceWeights.RESNET:           '4c06341c33c2ca1f86781dab0e829f88ad5b64be9fba56e56bc9ebdefc619e43',
     # SCRFD
-    SCRFDWeights.SCRFD_10G_KPS: "5838f7fe053675b1c7a08b633df49e7af5495cee0493c7dcf6697200b85b5b91",
-    SCRFDWeights.SCRFD_500M_KPS: "5e4447f50245bbd7966bd6c0fa52938c61474a04ec7def48753668a9d8b4ea3a",
+    SCRFDWeights.SCRFD_10G_KPS:      '5838f7fe053675b1c7a08b633df49e7af5495cee0493c7dcf6697200b85b5b91',
+    SCRFDWeights.SCRFD_500M_KPS:     '5e4447f50245bbd7966bd6c0fa52938c61474a04ec7def48753668a9d8b4ea3a',
     # DDAFM
-    DDAMFNWeights.AFFECNET7: "10535bf8b6afe8e9d6ae26cea6c3add9a93036e9addb6adebfd4a972171d015d",
-    DDAMFNWeights.AFFECNET8: "8c66963bc71db42796a14dfcbfcd181b268b65a3fc16e87147d6a3a3d7e0f487",
+    DDAMFNWeights.AFFECNET7:         '10535bf8b6afe8e9d6ae26cea6c3add9a93036e9addb6adebfd4a972171d015d',
+    DDAMFNWeights.AFFECNET8:         '8c66963bc71db42796a14dfcbfcd181b268b65a3fc16e87147d6a3a3d7e0f487',
     # AgeGender
-    AgeGenderWeights.DEFAULT: "4fde69b1c810857b88c64a335084f1c3fe8f01246c9a191b48c7bb756d6652fb",
+    AgeGenderWeights.DEFAULT:        '4fde69b1c810857b88c64a335084f1c3fe8f01246c9a191b48c7bb756d6652fb',
     # Landmark
-    LandmarkWeights.DEFAULT: "f001b856447c413801ef5c42091ed0cd516fcd21f2d6b79635b1e733a7109dbf",
+    LandmarkWeights.DEFAULT:         'f001b856447c413801ef5c42091ed0cd516fcd21f2d6b79635b1e733a7109dbf',
 }
 
 CHUNK_SIZE = 8192
diff --git a/uniface/detection/__init__.py b/uniface/detection/__init__.py
index 6f80891..87538f6 100644
--- a/uniface/detection/__init__.py
+++ b/uniface/detection/__init__.py
@@ -15,7 +15,7 @@ from .scrfd import SCRFD
 _detector_cache: Dict[str, BaseDetector] = {}
 
 
-def detect_faces(image: np.ndarray, method: str = "retinaface", **kwargs) -> List[Dict[str, Any]]:
+def detect_faces(image: np.ndarray, method: str = 'retinaface', **kwargs) -> List[Dict[str, Any]]:
     """
     High-level face detection function.
 
@@ -41,7 +41,7 @@ def detect_faces(image: np.ndarray, method: str = "retinaface", **kwargs) -> Lis
     method_name = method.lower()
 
     sorted_kwargs = sorted(kwargs.items())
-    cache_key = f"{method_name}_{str(sorted_kwargs)}"
+    cache_key = f'{method_name}_{str(sorted_kwargs)}'
 
     if cache_key not in _detector_cache:
         # Pass kwargs to create the correctly configured detector
@@ -51,7 +51,7 @@ def detect_faces(image: np.ndarray, method: str = "retinaface", **kwargs) -> Lis
     return detector.detect(image)
 
 
-def create_detector(method: str = "retinaface", **kwargs) -> BaseDetector:
+def create_detector(method: str = 'retinaface', **kwargs) -> BaseDetector:
     """
     Factory function to create face detectors.
 
@@ -89,14 +89,14 @@ def create_detector(method: str = "retinaface", **kwargs) -> BaseDetector:
     """
     method = method.lower()
 
-    if method == "retinaface":
+    if method == 'retinaface':
         return RetinaFace(**kwargs)
 
-    elif method == "scrfd":
+    elif method == 'scrfd':
         return SCRFD(**kwargs)
 
     else:
-        available_methods = ["retinaface", "scrfd"]
+        available_methods = ['retinaface', 'scrfd']
         raise ValueError(f"Unsupported detection method: '{method}'. Available methods: {available_methods}")
 
 
@@ -108,36 +108,36 @@ def list_available_detectors() -> Dict[str, Dict[str, Any]]:
         Dict[str, Dict[str, Any]]: Dictionary of detector information
     """
     return {
-        "retinaface": {
-            "description": "RetinaFace detector with high accuracy",
-            "supports_landmarks": True,
-            "paper": "https://arxiv.org/abs/1905.00641",
-            "default_params": {
-                "model_name": "mnet_v2",
-                "conf_thresh": 0.5,
-                "nms_thresh": 0.4,
-                "input_size": (640, 640),
+        'retinaface': {
+            'description': 'RetinaFace detector with high accuracy',
+            'supports_landmarks': True,
+            'paper': 'https://arxiv.org/abs/1905.00641',
+            'default_params': {
+                'model_name': 'mnet_v2',
+                'conf_thresh': 0.5,
+                'nms_thresh': 0.4,
+                'input_size': (640, 640),
             },
         },
-        "scrfd": {
-            "description": "SCRFD detector - fast and accurate with efficient architecture",
-            "supports_landmarks": True,
-            "paper": "https://arxiv.org/abs/2105.04714",
-            "default_params": {
-                "model_name": "scrfd_10g_kps",
-                "conf_thresh": 0.5,
-                "nms_thresh": 0.4,
-                "input_size": (640, 640),
+        'scrfd': {
+            'description': 'SCRFD detector - fast and accurate with efficient architecture',
+            'supports_landmarks': True,
+            'paper': 'https://arxiv.org/abs/2105.04714',
+            'default_params': {
+                'model_name': 'scrfd_10g_kps',
+                'conf_thresh': 0.5,
+                'nms_thresh': 0.4,
+                'input_size': (640, 640),
             },
         },
     }
 
 
 __all__ = [
-    "detect_faces",
-    "create_detector",
-    "list_available_detectors",
-    "SCRFD",
-    "RetinaFace",
-    "BaseDetector",
+    'detect_faces',
+    'create_detector',
+    'list_available_detectors',
+    'SCRFD',
+    'RetinaFace',
+    'BaseDetector',
 ]
diff --git a/uniface/detection/base.py b/uniface/detection/base.py
index 945884a..4b0c985 100644
--- a/uniface/detection/base.py
+++ b/uniface/detection/base.py
@@ -2,12 +2,8 @@
 # Author: Yakhyokhuja Valikhujaev
 # GitHub: https://github.com/yakhyo
 
-"""
-Base classes for face detection.
-"""
-
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, List
 
 import numpy as np
 
@@ -25,7 +21,7 @@ class BaseDetector(ABC):
         self.config = kwargs
 
     @abstractmethod
-    def detect(self, image: np.ndarray, **kwargs) -> Tuple[np.ndarray, np.ndarray]:
+    def detect(self, image: np.ndarray, **kwargs) -> List[Dict[str, Any]]:
         """
         Detect faces in an image.
 
@@ -34,11 +30,18 @@ class BaseDetector(ABC):
             **kwargs: Additional detection parameters
 
         Returns:
-            Tuple[np.ndarray, np.ndarray]: (detections, landmarks)
-                - detections: Bounding boxes with confidence scores, shape (N, 5)
-                  Format: [x_min, y_min, x_max, y_max, confidence]
-                - landmarks: Facial landmark points, shape (N, 5, 2) for 5-point landmarks
-                  or (N, 68, 2) for 68-point landmarks. Empty array if not supported.
+            List[Dict[str, Any]]: List of detected faces, where each dictionary contains:
+                - 'bbox' (np.ndarray): Bounding box coordinates with shape (4,) as [x1, y1, x2, y2]
+                - 'confidence' (float): Detection confidence score (0.0 to 1.0)
+                - 'landmarks' (np.ndarray): Facial landmarks with shape (5, 2) for 5-point landmarks
+                  or (68, 2) for 68-point landmarks. Empty array if not supported.
+
+        Example:
+            >>> faces = detector.detect(image)
+            >>> for face in faces:
+            ...     bbox = face['bbox']  # np.ndarray with shape (4,)
+            ...     confidence = face['confidence']  # float
+            ...     landmarks = face['landmarks']  # np.ndarray with shape (5, 2)
         """
         pass
 
@@ -56,7 +59,7 @@ class BaseDetector(ABC):
         pass
 
     @abstractmethod
-    def postprocess(self, outputs, **kwargs) -> Tuple[np.ndarray, np.ndarray]:
+    def postprocess(self, outputs, **kwargs) -> Any:
         """
         Postprocess model outputs to get final detections.
 
@@ -65,13 +68,13 @@ class BaseDetector(ABC):
             **kwargs: Additional postprocessing parameters
 
         Returns:
-            Tuple[np.ndarray, np.ndarray]: (detections, landmarks)
+            Any: Processed outputs (implementation-specific format, typically tuple of arrays)
         """
         pass
 
     def __str__(self) -> str:
         """String representation of the detector."""
-        return f"{self.__class__.__name__}({self.config})"
+        return f'{self.__class__.__name__}({self.config})'
 
     def __repr__(self) -> str:
         """Detailed string representation."""
@@ -85,7 +88,7 @@ class BaseDetector(ABC):
         Returns:
             bool: True if landmarks are supported, False otherwise
         """
-        return hasattr(self, "_supports_landmarks") and self._supports_landmarks
+        return hasattr(self, '_supports_landmarks') and self._supports_landmarks
 
     def get_info(self) -> Dict[str, Any]:
         """
@@ -95,7 +98,7 @@ class BaseDetector(ABC):
             Dict[str, Any]: Detector information
         """
         return {
-            "name": self.__class__.__name__,
-            "supports_landmarks": self._supports_landmarks,
-            "config": self.config,
+            'name': self.__class__.__name__,
+            'supports_landmarks': self._supports_landmarks,
+            'config': self.config,
         }
diff --git a/uniface/detection/retinaface.py b/uniface/detection/retinaface.py
index 04638cb..fe06541 100644
--- a/uniface/detection/retinaface.py
+++ b/uniface/detection/retinaface.py
@@ -6,19 +6,19 @@ from typing import Any, Dict, List, Literal, Tuple
 
 import numpy as np
 
+from uniface.common import (
+    decode_boxes,
+    decode_landmarks,
+    generate_anchors,
+    non_max_suppression,
+    resize_image,
+)
 from uniface.constants import RetinaFaceWeights
 from uniface.log import Logger
 from uniface.model_store import verify_model_weights
 from uniface.onnx_utils import create_onnx_session
 
 from .base import BaseDetector
-from .utils import (
-    decode_boxes,
-    decode_landmarks,
-    generate_anchors,
-    non_max_supression,
-    resize_image,
-)
 
 
 class RetinaFace(BaseDetector):
@@ -36,7 +36,8 @@ class RetinaFace(BaseDetector):
             pre_nms_topk (int, optional): Number of top-scoring boxes considered before NMS. Defaults to 5000.
             post_nms_topk (int, optional): Max number of detections kept after NMS. Defaults to 750.
             dynamic_size (bool, optional): If True, generate anchors dynamically per input image. Defaults to False.
-            input_size (Tuple[int, int], optional): Fixed input size (width, height) if `dynamic_size=False`. Defaults to (640, 640).
+            input_size (Tuple[int, int], optional): Fixed input size (width, height) if `dynamic_size=False`.
+                Defaults to (640, 640).
 
     Attributes:
         model_name (RetinaFaceWeights): Selected model variant.
@@ -59,27 +60,27 @@ class RetinaFace(BaseDetector):
         super().__init__(**kwargs)
         self._supports_landmarks = True  # RetinaFace supports landmarks
 
-        self.model_name = kwargs.get("model_name", RetinaFaceWeights.MNET_V2)
-        self.conf_thresh = kwargs.get("conf_thresh", 0.5)
-        self.nms_thresh = kwargs.get("nms_thresh", 0.4)
-        self.pre_nms_topk = kwargs.get("pre_nms_topk", 5000)
-        self.post_nms_topk = kwargs.get("post_nms_topk", 750)
-        self.dynamic_size = kwargs.get("dynamic_size", False)
-        self.input_size = kwargs.get("input_size", (640, 640))
+        self.model_name = kwargs.get('model_name', RetinaFaceWeights.MNET_V2)
+        self.conf_thresh = kwargs.get('conf_thresh', 0.5)
+        self.nms_thresh = kwargs.get('nms_thresh', 0.4)
+        self.pre_nms_topk = kwargs.get('pre_nms_topk', 5000)
+        self.post_nms_topk = kwargs.get('post_nms_topk', 750)
+        self.dynamic_size = kwargs.get('dynamic_size', False)
+        self.input_size = kwargs.get('input_size', (640, 640))
 
         Logger.info(
-            f"Initializing RetinaFace with model={self.model_name}, conf_thresh={self.conf_thresh}, nms_thresh={self.nms_thresh}, "
-            f"input_size={self.input_size}"
+            f'Initializing RetinaFace with model={self.model_name}, conf_thresh={self.conf_thresh}, '
+            f'nms_thresh={self.nms_thresh}, input_size={self.input_size}'
         )
 
         # Get path to model weights
         self._model_path = verify_model_weights(self.model_name)
-        Logger.info(f"Verified model weights located at: {self._model_path}")
+        Logger.info(f'Verified model weights located at: {self._model_path}')
 
         # Precompute anchors if using static size
         if not self.dynamic_size and self.input_size is not None:
             self._priors = generate_anchors(image_size=self.input_size)
-            Logger.debug("Generated anchors for static input size.")
+            Logger.debug('Generated anchors for static input size.')
 
         # Initialize model
         self._initialize_model(self._model_path)
@@ -98,7 +99,7 @@ class RetinaFace(BaseDetector):
             self.session = create_onnx_session(model_path)
             self.input_names = self.session.get_inputs()[0].name
             self.output_names = [x.name for x in self.session.get_outputs()]
-            Logger.info(f"Successfully initialized the model from {model_path}")
+            Logger.info(f'Successfully initialized the model from {model_path}')
         except Exception as e:
             Logger.error(f"Failed to load model from '{model_path}': {e}", exc_info=True)
             raise RuntimeError(f"Failed to initialize model session for '{model_path}'") from e
@@ -132,7 +133,7 @@ class RetinaFace(BaseDetector):
         self,
         image: np.ndarray,
         max_num: int = 0,
-        metric: Literal["default", "max"] = "max",
+        metric: Literal['default', 'max'] = 'max',
         center_weight: float = 2.0,
     ) -> List[Dict[str, Any]]:
         """
@@ -149,9 +150,18 @@ class RetinaFace(BaseDetector):
 
         Returns:
             List[Dict[str, Any]]: List of face detection dictionaries, each containing:
-                - 'bbox': [x1, y1, x2, y2] - Bounding box coordinates
-                - 'confidence': float - Detection confidence score
-                - 'landmarks': [[x1, y1], [x2, y2], [x3, y3], [x4, y4], [x5, y5]] - 5-point facial landmarks
+                - 'bbox' (np.ndarray): Bounding box coordinates with shape (4,) as [x1, y1, x2, y2]
+                - 'confidence' (float): Detection confidence score (0.0 to 1.0)
+                - 'landmarks' (np.ndarray): 5-point facial landmarks with shape (5, 2)
+
+        Example:
+            >>> faces = detector.detect(image)
+            >>> for face in faces:
+            ...     bbox = face['bbox']  # np.ndarray with shape (4,)
+            ...     confidence = face['confidence']  # float
+            ...     landmarks = face['landmarks']  # np.ndarray with shape (5, 2)
+            ...     # Can pass landmarks directly to recognition
+            ...     embedding = recognizer.get_normalized_embedding(image, landmarks)
         """
 
         original_height, original_width = image.shape[:2]
@@ -187,7 +197,7 @@ class RetinaFace(BaseDetector):
             offset_dist_squared = np.sum(np.power(offsets, 2.0), axis=0)
 
             # Calculate scores based on the chosen metric
-            if metric == "max":
+            if metric == 'max':
                 scores = areas
             else:
                 scores = areas - offset_dist_squared * center_weight
@@ -201,9 +211,9 @@ class RetinaFace(BaseDetector):
         faces = []
         for i in range(detections.shape[0]):
             face_dict = {
-                "bbox": detections[i, :4].astype(float).tolist(),
-                "confidence": detections[i, 4].item(),
-                "landmarks": landmarks[i].astype(float).tolist(),
+                'bbox': detections[i, :4].astype(np.float32),
+                'confidence': float(detections[i, 4]),
+                'landmarks': landmarks[i].astype(np.float32),
             }
             faces.append(face_dict)
 
@@ -255,7 +265,7 @@ class RetinaFace(BaseDetector):
 
         # Apply NMS
         detections = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32, copy=False)
-        keep = non_max_supression(detections, self.nms_thresh)
+        keep = non_max_suppression(detections, self.nms_thresh)
         detections, landmarks = detections[keep], landmarks[keep]
 
         # Keep top-k detections
@@ -289,7 +299,7 @@ class RetinaFace(BaseDetector):
 def draw_bbox(frame, bbox, score, color=(0, 255, 0), thickness=2):
     x1, y1, x2, y2 = map(int, bbox)  # Unpack 4 bbox values
     cv2.rectangle(frame, (x1, y1), (x2, y2), color, thickness)
-    cv2.putText(frame, f"{score:.2f}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
+    cv2.putText(frame, f'{score:.2f}', (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
 
 
 def draw_keypoints(frame, points, color=(0, 0, 255), radius=2):
@@ -297,7 +307,7 @@ def draw_keypoints(frame, points, color=(0, 0, 255), radius=2):
         cv2.circle(frame, (int(x), int(y)), radius, color, -1)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     import cv2
 
     detector = RetinaFace(model_name=RetinaFaceWeights.MNET_050)
@@ -305,7 +315,7 @@ if __name__ == "__main__":
     cap = cv2.VideoCapture(0)
 
     if not cap.isOpened():
-        print("Failed to open webcam.")
+        print('Failed to open webcam.')
         exit()
 
     print("Webcam started. Press 'q' to exit.")
@@ -313,7 +323,7 @@ if __name__ == "__main__":
     while True:
         ret, frame = cap.read()
         if not ret:
-            print("Failed to read frame.")
+            print('Failed to read frame.')
             break
 
         # Get face detections as list of dictionaries
@@ -322,9 +332,9 @@ if __name__ == "__main__":
         # Process each detected face
         for face in faces:
             # Extract bbox and landmarks from dictionary
-            bbox = face["bbox"]  # [x1, y1, x2, y2]
-            landmarks = face["landmarks"]  # [[x1, y1], [x2, y2], ...]
-            confidence = face["confidence"]
+            bbox = face['bbox']  # [x1, y1, x2, y2]
+            landmarks = face['landmarks']  # [[x1, y1], [x2, y2], ...]
+            confidence = face['confidence']
 
             # Pass bbox and confidence separately
             draw_bbox(frame, bbox, confidence)
@@ -338,7 +348,7 @@ if __name__ == "__main__":
         # Display face count
         cv2.putText(
             frame,
-            f"Faces: {len(faces)}",
+            f'Faces: {len(faces)}',
             (10, 30),
             cv2.FONT_HERSHEY_SIMPLEX,
             0.7,
@@ -346,8 +356,8 @@ if __name__ == "__main__":
             2,
         )
 
-        cv2.imshow("FaceDetection", frame)
-        if cv2.waitKey(1) & 0xFF == ord("q"):
+        cv2.imshow('FaceDetection', frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
             break
 
     cap.release()
diff --git a/uniface/detection/scrfd.py b/uniface/detection/scrfd.py
index e9a1a29..e62b83e 100644
--- a/uniface/detection/scrfd.py
+++ b/uniface/detection/scrfd.py
@@ -7,15 +7,15 @@ from typing import Any, Dict, List, Literal, Tuple
 import cv2
 import numpy as np
 
+from uniface.common import distance2bbox, distance2kps, non_max_suppression, resize_image
 from uniface.constants import SCRFDWeights
 from uniface.log import Logger
 from uniface.model_store import verify_model_weights
 from uniface.onnx_utils import create_onnx_session
 
 from .base import BaseDetector
-from .utils import distance2bbox, distance2kps, non_max_supression, resize_image
 
-__all__ = ["SCRFD"]
+__all__ = ['SCRFD']
 
 
 class SCRFD(BaseDetector):
@@ -52,10 +52,10 @@ class SCRFD(BaseDetector):
         super().__init__(**kwargs)
         self._supports_landmarks = True  # SCRFD supports landmarks
 
-        model_name = kwargs.get("model_name", SCRFDWeights.SCRFD_10G_KPS)
-        conf_thresh = kwargs.get("conf_thresh", 0.5)
-        nms_thresh = kwargs.get("nms_thresh", 0.4)
-        input_size = kwargs.get("input_size", (640, 640))
+        model_name = kwargs.get('model_name', SCRFDWeights.SCRFD_10G_KPS)
+        conf_thresh = kwargs.get('conf_thresh', 0.5)
+        nms_thresh = kwargs.get('nms_thresh', 0.4)
+        input_size = kwargs.get('input_size', (640, 640))
 
         self.conf_thresh = conf_thresh
         self.nms_thresh = nms_thresh
@@ -69,13 +69,13 @@ class SCRFD(BaseDetector):
         # ---------------------------------
 
         Logger.info(
-            f"Initializing SCRFD with model={model_name}, conf_thresh={conf_thresh}, nms_thresh={nms_thresh}, "
-            f"input_size={input_size}"
+            f'Initializing SCRFD with model={model_name}, conf_thresh={conf_thresh}, nms_thresh={nms_thresh}, '
+            f'input_size={input_size}'
         )
 
         # Get path to model weights
         self._model_path = verify_model_weights(model_name)
-        Logger.info(f"Verified model weights located at: {self._model_path}")
+        Logger.info(f'Verified model weights located at: {self._model_path}')
 
         # Initialize model
         self._initialize_model(self._model_path)
@@ -94,7 +94,7 @@ class SCRFD(BaseDetector):
             self.session = create_onnx_session(model_path)
             self.input_names = self.session.get_inputs()[0].name
             self.output_names = [x.name for x in self.session.get_outputs()]
-            Logger.info(f"Successfully initialized the model from {model_path}")
+            Logger.info(f'Successfully initialized the model from {model_path}')
         except Exception as e:
             Logger.error(f"Failed to load model from '{model_path}': {e}", exc_info=True)
             raise RuntimeError(f"Failed to initialize model session for '{model_path}'") from e
@@ -176,7 +176,7 @@ class SCRFD(BaseDetector):
         self,
         image: np.ndarray,
         max_num: int = 0,
-        metric: Literal["default", "max"] = "max",
+        metric: Literal['default', 'max'] = 'max',
         center_weight: float = 2,
     ) -> List[Dict[str, Any]]:
         """
@@ -193,9 +193,18 @@ class SCRFD(BaseDetector):
 
         Returns:
             List[Dict[str, Any]]: List of face detection dictionaries, each containing:
-                - 'bbox': [x1, y1, x2, y2] - Bounding box coordinates
-                - 'confidence': float - Detection confidence score
-                - 'landmarks': [[x1, y1], [x2, y2], [x3, y3], [x4, y4], [x5, y5]] - 5-point facial landmarks
+                - 'bbox' (np.ndarray): Bounding box coordinates with shape (4,) as [x1, y1, x2, y2]
+                - 'confidence' (float): Detection confidence score (0.0 to 1.0)
+                - 'landmarks' (np.ndarray): 5-point facial landmarks with shape (5, 2)
+
+        Example:
+            >>> faces = detector.detect(image)
+            >>> for face in faces:
+            ...     bbox = face['bbox']  # np.ndarray with shape (4,)
+            ...     confidence = face['confidence']  # float
+            ...     landmarks = face['landmarks']  # np.ndarray with shape (5, 2)
+            ...     # Can pass landmarks directly to recognition
+            ...     embedding = recognizer.get_normalized_embedding(image, landmarks)
         """
 
         original_height, original_width = image.shape[:2]
@@ -223,7 +232,7 @@ class SCRFD(BaseDetector):
         pre_det = np.hstack((bboxes, scores)).astype(np.float32, copy=False)
         pre_det = pre_det[order, :]
 
-        keep = non_max_supression(pre_det, threshold=self.nms_thresh)
+        keep = non_max_suppression(pre_det, threshold=self.nms_thresh)
 
         detections = pre_det[keep, :]
         landmarks = landmarks[order, :, :]
@@ -244,7 +253,7 @@ class SCRFD(BaseDetector):
 
             # Calculate scores based on the chosen metric
             offset_dist_squared = np.sum(np.power(offsets, 2.0), axis=0)
-            if metric == "max":
+            if metric == 'max':
                 values = area
             else:
                 values = area - offset_dist_squared * center_weight
@@ -257,9 +266,9 @@ class SCRFD(BaseDetector):
         faces = []
         for i in range(detections.shape[0]):
             face_dict = {
-                "bbox": detections[i, :4].astype(float).tolist(),
-                "confidence": detections[i, 4].item(),
-                "landmarks": landmarks[i].astype(float).tolist(),
+                'bbox': detections[i, :4].astype(np.float32),
+                'confidence': float(detections[i, 4]),
+                'landmarks': landmarks[i].astype(np.float32),
             }
             faces.append(face_dict)
 
@@ -270,7 +279,7 @@ class SCRFD(BaseDetector):
 def draw_bbox(frame, bbox, score, color=(0, 255, 0), thickness=2):
     x1, y1, x2, y2 = map(int, bbox)  # Unpack 4 bbox values
     cv2.rectangle(frame, (x1, y1), (x2, y2), color, thickness)
-    cv2.putText(frame, f"{score:.2f}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
+    cv2.putText(frame, f'{score:.2f}', (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
 
 
 def draw_keypoints(frame, points, color=(0, 0, 255), radius=2):
@@ -278,13 +287,13 @@ def draw_keypoints(frame, points, color=(0, 0, 255), radius=2):
         cv2.circle(frame, (int(x), int(y)), radius, color, -1)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     detector = SCRFD(model_name=SCRFDWeights.SCRFD_500M_KPS)
     print(detector.get_info())
     cap = cv2.VideoCapture(0)
 
     if not cap.isOpened():
-        print("Failed to open webcam.")
+        print('Failed to open webcam.')
         exit()
 
     print("Webcam started. Press 'q' to exit.")
@@ -292,7 +301,7 @@ if __name__ == "__main__":
     while True:
         ret, frame = cap.read()
         if not ret:
-            print("Failed to read frame.")
+            print('Failed to read frame.')
             break
 
         # Get face detections as list of dictionaries
@@ -301,9 +310,9 @@ if __name__ == "__main__":
         # Process each detected face
         for face in faces:
             # Extract bbox and landmarks from dictionary
-            bbox = face["bbox"]  # [x1, y1, x2, y2]
-            landmarks = face["landmarks"]  # [[x1, y1], [x2, y2], ...]
-            confidence = face["confidence"]
+            bbox = face['bbox']  # [x1, y1, x2, y2]
+            landmarks = face['landmarks']  # [[x1, y1], [x2, y2], ...]
+            confidence = face['confidence']
 
             # Pass bbox and confidence separately
             draw_bbox(frame, bbox, confidence)
@@ -317,7 +326,7 @@ if __name__ == "__main__":
         # Display face count
         cv2.putText(
             frame,
-            f"Faces: {len(faces)}",
+            f'Faces: {len(faces)}',
             (10, 30),
             cv2.FONT_HERSHEY_SIMPLEX,
             0.7,
@@ -325,8 +334,8 @@ if __name__ == "__main__":
             2,
         )
 
-        cv2.imshow("FaceDetection", frame)
-        if cv2.waitKey(1) & 0xFF == ord("q"):
+        cv2.imshow('FaceDetection', frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
             break
 
     cap.release()
diff --git a/uniface/detection/utils.py b/uniface/detection/utils.py
deleted file mode 100644
index 3101b68..0000000
--- a/uniface/detection/utils.py
+++ /dev/null
@@ -1,227 +0,0 @@
-# Copyright 2025 Yakhyokhuja Valikhujaev
-# Author: Yakhyokhuja Valikhujaev
-# GitHub: https://github.com/yakhyo
-
-import itertools
-import math
-from typing import List, Tuple
-
-import cv2
-import numpy as np
-
-
-def resize_image(frame, target_shape: Tuple[int, int] = (640, 640)) -> Tuple[np.ndarray, float]:
-    """
-    Resize an image to fit within a target shape while keeping its aspect ratio.
-
-    Args:
-        frame (np.ndarray): Input image.
-        target_shape (Tuple[int, int]): Target size (width, height). Defaults to (640, 640).
-
-    Returns:
-        Tuple[np.ndarray, float]: Resized image on a blank canvas and the resize factor.
-    """
-    width, height = target_shape
-
-    # Aspect-ratio preserving resize
-    im_ratio = float(frame.shape[0]) / frame.shape[1]
-    model_ratio = height / width
-    if im_ratio > model_ratio:
-        new_height = height
-        new_width = int(new_height / im_ratio)
-    else:
-        new_width = width
-        new_height = int(new_width * im_ratio)
-
-    resize_factor = float(new_height) / frame.shape[0]
-    resized_frame = cv2.resize(frame, (new_width, new_height))
-
-    # Create blank image and place resized image on it
-    image = np.zeros((height, width, 3), dtype=np.uint8)
-    image[:new_height, :new_width, :] = resized_frame
-
-    return image, resize_factor
-
-
-def generate_anchors(image_size: Tuple[int, int] = (640, 640)) -> np.ndarray:
-    """
-    Generate anchor boxes for a given image size.
-
-    Args:
-        image_size (Tuple[int, int]): Input image size (width, height). Defaults to (640, 640).
-
-    Returns:
-        np.ndarray: Anchor box coordinates as a NumPy array.
-    """
-    image_size = image_size
-
-    steps = [8, 16, 32]
-    min_sizes = [[16, 32], [64, 128], [256, 512]]
-
-    anchors = []
-    feature_maps = [[math.ceil(image_size[0] / step), math.ceil(image_size[1] / step)] for step in steps]
-
-    for k, (map_height, map_width) in enumerate(feature_maps):
-        step = steps[k]
-        for i, j in itertools.product(range(map_height), range(map_width)):
-            for min_size in min_sizes[k]:
-                s_kx = min_size / image_size[1]
-                s_ky = min_size / image_size[0]
-
-                dense_cx = [x * step / image_size[1] for x in [j + 0.5]]
-                dense_cy = [y * step / image_size[0] for y in [i + 0.5]]
-                for cy, cx in itertools.product(dense_cy, dense_cx):
-                    anchors += [cx, cy, s_kx, s_ky]
-
-    output = np.array(anchors, dtype=np.float32).reshape(-1, 4)
-    return output
-
-
-def non_max_supression(dets: List[np.ndarray], threshold: float):
-    """
-    Apply Non-Maximum Suppression (NMS) to reduce overlapping bounding boxes based on a threshold.
-
-    Args:
-        dets (numpy.ndarray): Array of detections with each row as [x1, y1, x2, y2, score].
-        threshold (float): IoU threshold for suppression.
-
-    Returns:
-        list: Indices of bounding boxes retained after suppression.
-    """
-    x1 = dets[:, 0]
-    y1 = dets[:, 1]
-    x2 = dets[:, 2]
-    y2 = dets[:, 3]
-    scores = dets[:, 4]
-
-    areas = (x2 - x1 + 1) * (y2 - y1 + 1)
-    order = scores.argsort()[::-1]
-
-    keep = []
-    while order.size > 0:
-        i = order[0]
-        keep.append(i)
-        xx1 = np.maximum(x1[i], x1[order[1:]])
-        yy1 = np.maximum(y1[i], y1[order[1:]])
-        xx2 = np.minimum(x2[i], x2[order[1:]])
-        yy2 = np.minimum(y2[i], y2[order[1:]])
-
-        w = np.maximum(0.0, xx2 - xx1 + 1)
-        h = np.maximum(0.0, yy2 - yy1 + 1)
-        inter = w * h
-        ovr = inter / (areas[i] + areas[order[1:]] - inter)
-
-        inds = np.where(ovr <= threshold)[0]
-        order = order[inds + 1]
-
-    return keep
-
-
-def decode_boxes(loc, priors, variances=[0.1, 0.2]) -> np.ndarray:
-    """
-    Decode locations from predictions using priors to undo
-    the encoding done for offset regression at train time.
-
-    Args:
-        loc (np.ndarray): Location predictions for loc layers, shape: [num_priors, 4]
-        priors (np.ndarray): Prior boxes in center-offset form, shape: [num_priors, 4]
-        variances (list[float]): Variances of prior boxes
-
-    Returns:
-        np.ndarray: Decoded bounding box predictions
-    """
-    # Compute centers of predicted boxes
-    cxcy = priors[:, :2] + loc[:, :2] * variances[0] * priors[:, 2:]
-
-    # Compute widths and heights of predicted boxes
-    wh = priors[:, 2:] * np.exp(loc[:, 2:] * variances[1])
-
-    # Convert center, size to corner coordinates
-    boxes = np.zeros_like(loc)
-    boxes[:, :2] = cxcy - wh / 2  # xmin, ymin
-    boxes[:, 2:] = cxcy + wh / 2  # xmax, ymax
-
-    return boxes
-
-
-def decode_landmarks(predictions, priors, variances=[0.1, 0.2]) -> np.ndarray:
-    """
-    Decode landmark predictions using prior boxes.
-
-    Args:
-        predictions (np.ndarray): Landmark predictions, shape: [num_priors, 10]
-        priors (np.ndarray): Prior boxes, shape: [num_priors, 4]
-        variances (list): Scaling factors for landmark offsets.
-
-    Returns:
-        np.ndarray: Decoded landmarks, shape: [num_priors, 10]
-    """
-
-    # Reshape predictions to [num_priors, 5, 2] to process landmark points
-    predictions = predictions.reshape(predictions.shape[0], 5, 2)
-
-    # Expand priors to match (num_priors, 5, 2)
-    priors_xy = np.repeat(priors[:, :2][:, np.newaxis, :], 5, axis=1)  # (num_priors, 5, 2)
-    priors_wh = np.repeat(priors[:, 2:][:, np.newaxis, :], 5, axis=1)  # (num_priors, 5, 2)
-
-    # Compute absolute landmark positions
-    landmarks = priors_xy + predictions * variances[0] * priors_wh
-
-    # Flatten back to [num_priors, 10]
-    landmarks = landmarks.reshape(landmarks.shape[0], -1)
-
-    return landmarks
-
-
-def distance2bbox(points, distance, max_shape=None):
-    """Decode distance prediction to bounding box.
-
-    Args:
-        points (Tensor): Shape (n, 2), [x, y].
-        distance (Tensor): Distance from the given point to 4
-            boundaries (left, top, right, bottom).
-        max_shape (tuple): Shape of the image.
-
-    Returns:
-        Tensor: Decoded bounding boxes with shape (n, 4).
-    """
-    x1 = points[:, 0] - distance[:, 0]
-    y1 = points[:, 1] - distance[:, 1]
-    x2 = points[:, 0] + distance[:, 2]
-    y2 = points[:, 1] + distance[:, 3]
-    if max_shape is not None:
-        x1 = x1.clamp(min=0, max=max_shape[1])
-        y1 = y1.clamp(min=0, max=max_shape[0])
-        x2 = x2.clamp(min=0, max=max_shape[1])
-        y2 = y2.clamp(min=0, max=max_shape[0])
-    else:
-        x1 = np.maximum(x1, 0)
-        y1 = np.maximum(y1, 0)
-        x2 = np.maximum(x2, 0)
-        y2 = np.maximum(y2, 0)
-
-    return np.stack([x1, y1, x2, y2], axis=-1)
-
-
-def distance2kps(points, distance, max_shape=None):
-    """Decode distance prediction to keypoints.
-
-    Args:
-        points (Tensor): Shape (n, 2), [x, y].
-        distance (Tensor): Distance from the given point to 4
-            boundaries (left, top, right, bottom).
-        max_shape (tuple): Shape of the image.
-
-    Returns:
-        Tensor: Decoded keypoints with shape (n, 2k).
-    """
-    preds = []
-    for i in range(0, distance.shape[1], 2):
-        px = points[:, i % 2] + distance[:, i]
-        py = points[:, i % 2 + 1] + distance[:, i + 1]
-        if max_shape is not None:
-            px = px.clamp(min=0, max=max_shape[1])
-            py = py.clamp(min=0, max=max_shape[0])
-        preds.append(px)
-        preds.append(py)
-    return np.stack(preds, axis=-1)
diff --git a/uniface/face.py b/uniface/face.py
new file mode 100644
index 0000000..14a2854
--- /dev/null
+++ b/uniface/face.py
@@ -0,0 +1,51 @@
+# Copyright 2025 Yakhyokhuja Valikhujaev
+# Author: Yakhyokhuja Valikhujaev
+# GitHub: https://github.com/yakhyo
+
+from dataclasses import asdict, dataclass
+from typing import Optional
+
+import numpy as np
+
+from uniface.face_utils import compute_similarity
+
+__all__ = ['Face']
+
+
+@dataclass
+class Face:
+    """Detected face with analysis results."""
+
+    bbox: np.ndarray
+    confidence: float
+    landmarks: np.ndarray
+    embedding: Optional[np.ndarray] = None
+    age: Optional[int] = None
+    gender_id: Optional[int] = None  # 0: Female, 1: Male
+
+    def compute_similarity(self, other: 'Face') -> float:
+        """Compute cosine similarity with another face."""
+        if self.embedding is None or other.embedding is None:
+            raise ValueError('Both faces must have embeddings for similarity computation')
+        return float(compute_similarity(self.embedding, other.embedding))
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return asdict(self)
+
+    @property
+    def gender(self) -> str:
+        """Get gender as a string label (Female or Male)."""
+        if self.gender_id is None:
+            return None
+        return 'Female' if self.gender_id == 0 else 'Male'
+
+    def __repr__(self) -> str:
+        parts = [f'Face(confidence={self.confidence:.3f}']
+        if self.age is not None:
+            parts.append(f'age={self.age}')
+        if self.gender_id is not None:
+            parts.append(f'gender={self.gender}')
+        if self.embedding is not None:
+            parts.append(f'embedding_dim={self.embedding.shape[0]}')
+        return ', '.join(parts) + ')'
diff --git a/uniface/face_utils.py b/uniface/face_utils.py
index 4a3b431..98bed7d 100644
--- a/uniface/face_utils.py
+++ b/uniface/face_utils.py
@@ -9,10 +9,10 @@ import numpy as np
 from skimage.transform import SimilarityTransform
 
 __all__ = [
-    "face_alignment",
-    "compute_similarity",
-    "bbox_center_alignment",
-    "transform_points_2d",
+    'face_alignment',
+    'compute_similarity',
+    'bbox_center_alignment',
+    'transform_points_2d',
 ]
 
 
@@ -46,7 +46,7 @@ def estimate_norm(landmark: np.ndarray, image_size: Union[int, Tuple[int, int]]
         AssertionError: If the input landmark array does not have the shape (5, 2)
                         or if image_size is not a multiple of 112 or 128.
     """
-    assert landmark.shape == (5, 2), "Landmark array must have shape (5, 2)."
+    assert landmark.shape == (5, 2), 'Landmark array must have shape (5, 2).'
 
     # Handle both int and tuple inputs
     if isinstance(image_size, tuple):
@@ -54,7 +54,7 @@ def estimate_norm(landmark: np.ndarray, image_size: Union[int, Tuple[int, int]]
     else:
         size = image_size
 
-    assert size % 112 == 0 or size % 128 == 0, "Image size must be a multiple of 112 or 128."
+    assert size % 112 == 0 or size % 128 == 0, 'Image size must be a multiple of 112 or 128.'
 
     if size % 112 == 0:
         ratio = float(size) / 112.0
diff --git a/uniface/landmark/__init__.py b/uniface/landmark/__init__.py
index ec80b50..d241853 100644
--- a/uniface/landmark/__init__.py
+++ b/uniface/landmark/__init__.py
@@ -6,7 +6,7 @@ from .base import BaseLandmarker
 from .models import Landmark106
 
 
-def create_landmarker(method: str = "2d106det", **kwargs) -> BaseLandmarker:
+def create_landmarker(method: str = '2d106det', **kwargs) -> BaseLandmarker:
     """
     Factory function to create facial landmark predictors.
 
@@ -18,11 +18,11 @@ def create_landmarker(method: str = "2d106det", **kwargs) -> BaseLandmarker:
         Initialized landmarker instance.
     """
     method = method.lower()
-    if method == "2d106det":
+    if method == '2d106det':
         return Landmark106(**kwargs)
     else:
-        available = ["2d106det"]
+        available = ['2d106det']
         raise ValueError(f"Unsupported method: '{method}'. Available: {available}")
 
 
-__all__ = ["create_landmarker", "Landmark106", "BaseLandmarker"]
+__all__ = ['create_landmarker', 'Landmark106', 'BaseLandmarker']
diff --git a/uniface/landmark/models.py b/uniface/landmark/models.py
index c1c9801..381144a 100644
--- a/uniface/landmark/models.py
+++ b/uniface/landmark/models.py
@@ -15,7 +15,7 @@ from uniface.onnx_utils import create_onnx_session
 
 from .base import BaseLandmarker
 
-__all__ = ["Landmark"]
+__all__ = ['Landmark106']
 
 
 class Landmark106(BaseLandmarker):
@@ -48,7 +48,7 @@ class Landmark106(BaseLandmarker):
         model_name: LandmarkWeights = LandmarkWeights.DEFAULT,
         input_size: Tuple[int, int] = (192, 192),
     ) -> None:
-        Logger.info(f"Initializing Facial Landmark with model={model_name}, input_size={input_size}")
+        Logger.info(f'Initializing Facial Landmark with model={model_name}, input_size={input_size}')
         self.input_size = input_size
         self.input_std = 1.0
         self.input_mean = 0.0
@@ -79,11 +79,11 @@ class Landmark106(BaseLandmarker):
             self.lmk_dim = 2  # x,y coordinates
             self.lmk_num = output_shape[1] // self.lmk_dim  # Number of landmarks
 
-            Logger.info(f"Model initialized with {self.lmk_num} landmarks")
+            Logger.info(f'Model initialized with {self.lmk_num} landmarks')
 
         except Exception as e:
             Logger.error(f"Failed to load landmark model from '{self.model_path}'", exc_info=True)
-            raise RuntimeError(f"Failed to initialize landmark model: {e}") from e
+            raise RuntimeError(f'Failed to initialize landmark model: {e}') from e
 
     def preprocess(self, image: np.ndarray, bbox: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
         """Prepares a face crop for inference.
@@ -158,7 +158,7 @@ class Landmark106(BaseLandmarker):
 
 
 # Testing code
-if __name__ == "__main__":
+if __name__ == '__main__':
     from uniface.detection import RetinaFace
     from uniface.landmark import Landmark106
 
@@ -167,7 +167,7 @@ if __name__ == "__main__":
 
     cap = cv2.VideoCapture(0)
     if not cap.isOpened():
-        print("Webcam not available.")
+        print('Webcam not available.')
         exit()
 
     print("Press 'q' to quit.")
@@ -175,22 +175,22 @@ if __name__ == "__main__":
     while True:
         ret, frame = cap.read()
         if not ret:
-            print("Frame capture failed.")
+            print('Frame capture failed.')
             break
 
         # 2. The detect method returns a list of dictionaries
         faces = face_detector.detect(frame)
 
         if not faces:
-            cv2.imshow("Facial Landmark Detection", frame)
-            if cv2.waitKey(1) & 0xFF == ord("q"):
+            cv2.imshow('Facial Landmark Detection', frame)
+            if cv2.waitKey(1) & 0xFF == ord('q'):
                 break
             continue
 
         # 3. Loop through the list of face dictionaries
         for face in faces:
             # Extract the bounding box
-            bbox = face["bbox"]
+            bbox = face['bbox']
 
             # 4. Get landmarks for the current face using its bounding box
             landmarks = landmarker.get_landmarks(frame, bbox)
@@ -204,8 +204,8 @@ if __name__ == "__main__":
             x1, y1, x2, y2 = map(int, bbox)
             cv2.rectangle(frame, (x1, y1), (x2, y2), (255, 0, 0), 2)
 
-        cv2.imshow("Facial Landmark Detection", frame)
-        if cv2.waitKey(1) & 0xFF == ord("q"):
+        cv2.imshow('Facial Landmark Detection', frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
             break
 
     cap.release()
diff --git a/uniface/log.py b/uniface/log.py
index 5605e9d..0477c5c 100644
--- a/uniface/log.py
+++ b/uniface/log.py
@@ -1,7 +1,7 @@
 import logging
 
 # Create logger for uniface
-Logger = logging.getLogger("uniface")
+Logger = logging.getLogger('uniface')
 Logger.setLevel(logging.WARNING)  # Only show warnings/errors by default
 Logger.addHandler(logging.NullHandler())
 
@@ -19,7 +19,7 @@ def enable_logging(level=logging.INFO):
     """
     Logger.handlers.clear()
     handler = logging.StreamHandler()
-    handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"))
+    handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S'))
     Logger.addHandler(handler)
     Logger.setLevel(level)
     Logger.propagate = False
diff --git a/uniface/model_store.py b/uniface/model_store.py
index 4015302..b721e39 100644
--- a/uniface/model_store.py
+++ b/uniface/model_store.py
@@ -11,10 +11,10 @@ from tqdm import tqdm
 import uniface.constants as const
 from uniface.log import Logger
 
-__all__ = ["verify_model_weights"]
+__all__ = ['verify_model_weights']
 
 
-def verify_model_weights(model_name: str, root: str = "~/.uniface/models") -> str:
+def verify_model_weights(model_name: str, root: str = '~/.uniface/models') -> str:
     """
     Ensure model weights are present, downloading and verifying them using SHA-256 if necessary.
 
@@ -53,7 +53,7 @@ def verify_model_weights(model_name: str, root: str = "~/.uniface/models") -> st
         raise ValueError(f"No URL found for model '{model_name}'")
 
     file_ext = os.path.splitext(url)[1]
-    model_path = os.path.normpath(os.path.join(root, f"{model_name.value}{file_ext}"))
+    model_path = os.path.normpath(os.path.join(root, f'{model_name.value}{file_ext}'))
 
     if not os.path.exists(model_path):
         Logger.info(f"Downloading model '{model_name}' from {url}")
@@ -67,7 +67,7 @@ def verify_model_weights(model_name: str, root: str = "~/.uniface/models") -> st
     expected_hash = const.MODEL_SHA256.get(model_name)
     if expected_hash and not verify_file_hash(model_path, expected_hash):
         os.remove(model_path)  # Remove corrupted file
-        Logger.warning("Corrupted weight detected. Removing...")
+        Logger.warning('Corrupted weight detected. Removing...')
         raise ValueError(f"Hash mismatch for '{model_name}'. The file may be corrupted; please try downloading again.")
 
     return model_path
@@ -79,10 +79,10 @@ def download_file(url: str, dest_path: str) -> None:
         response = requests.get(url, stream=True)
         response.raise_for_status()
         with (
-            open(dest_path, "wb") as file,
+            open(dest_path, 'wb') as file,
             tqdm(
-                desc=f"Downloading {dest_path}",
-                unit="B",
+                desc=f'Downloading {dest_path}',
+                unit='B',
                 unit_scale=True,
                 unit_divisor=1024,
             ) as progress,
@@ -92,22 +92,22 @@ def download_file(url: str, dest_path: str) -> None:
                     file.write(chunk)
                     progress.update(len(chunk))
     except requests.RequestException as e:
-        raise ConnectionError(f"Failed to download file from {url}. Error: {e}") from e
+        raise ConnectionError(f'Failed to download file from {url}. Error: {e}') from e
 
 
 def verify_file_hash(file_path: str, expected_hash: str) -> bool:
     """Compute the SHA-256 hash of the file and compare it with the expected hash."""
     file_hash = hashlib.sha256()
-    with open(file_path, "rb") as f:
-        for chunk in iter(lambda: f.read(const.CHUNK_SIZE), b""):
+    with open(file_path, 'rb') as f:
+        for chunk in iter(lambda: f.read(const.CHUNK_SIZE), b''):
             file_hash.update(chunk)
     actual_hash = file_hash.hexdigest()
     if actual_hash != expected_hash:
-        Logger.warning(f"Expected hash: {expected_hash}, but got: {actual_hash}")
+        Logger.warning(f'Expected hash: {expected_hash}, but got: {actual_hash}')
     return actual_hash == expected_hash
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     model_names = [model.value for model in const.RetinaFaceWeights]
 
     # Download each model in the list
diff --git a/uniface/onnx_utils.py b/uniface/onnx_utils.py
index 557491f..a06f96c 100644
--- a/uniface/onnx_utils.py
+++ b/uniface/onnx_utils.py
@@ -2,10 +2,6 @@
 # Author: Yakhyokhuja Valikhujaev
 # GitHub: https://github.com/yakhyo
 
-"""
-Utilities for ONNX Runtime configuration and provider selection.
-"""
-
 from typing import List
 
 import onnxruntime as ort
@@ -35,19 +31,19 @@ def get_available_providers() -> List[str]:
     providers = []
 
     # Priority order: CoreML > CUDA > CPU
-    if "CoreMLExecutionProvider" in available:
-        providers.append("CoreMLExecutionProvider")
-        Logger.info("CoreML acceleration enabled (Apple Silicon)")
+    if 'CoreMLExecutionProvider' in available:
+        providers.append('CoreMLExecutionProvider')
+        Logger.info('CoreML acceleration enabled (Apple Silicon)')
 
-    if "CUDAExecutionProvider" in available:
-        providers.append("CUDAExecutionProvider")
-        Logger.info("CUDA acceleration enabled (NVIDIA GPU)")
+    if 'CUDAExecutionProvider' in available:
+        providers.append('CUDAExecutionProvider')
+        Logger.info('CUDA acceleration enabled (NVIDIA GPU)')
 
     # CPU is always available as fallback
-    providers.append("CPUExecutionProvider")
+    providers.append('CPUExecutionProvider')
 
     if len(providers) == 1:
-        Logger.info("Using CPU execution (no hardware acceleration detected)")
+        Logger.info('Using CPU execution (no hardware acceleration detected)')
 
     return providers
 
@@ -85,18 +81,19 @@ def create_onnx_session(model_path: str, providers: List[str] = None) -> ort.Inf
     try:
         session = ort.InferenceSession(model_path, sess_options=sess_options, providers=providers)
         active_provider = session.get_providers()[0]
-        Logger.debug(f"Session created with provider: {active_provider}")
+        Logger.debug(f'Session created with provider: {active_provider}')
 
         # Show user-friendly message about which provider is being used
         provider_names = {
-            "CoreMLExecutionProvider": "CoreML (Apple Silicon)",
-            "CUDAExecutionProvider": "CUDA (NVIDIA GPU)",
-            "CPUExecutionProvider": "CPU",
+            'CoreMLExecutionProvider': 'CoreML (Apple Silicon)',
+            'CUDAExecutionProvider': 'CUDA (NVIDIA GPU)',
+            'CPUExecutionProvider': 'CPU',
         }
         provider_display = provider_names.get(active_provider, active_provider)
-        print(f"Model loaded ({provider_display})")
+        Logger.debug(f'Model loaded with provider: {active_provider}')
+        print(f'✓ Model loaded ({provider_display})')
 
         return session
     except Exception as e:
-        Logger.error(f"Failed to create ONNX session: {e}", exc_info=True)
-        raise RuntimeError(f"Failed to initialize ONNX Runtime session: {e}") from e
+        Logger.error(f'Failed to create ONNX session: {e}', exc_info=True)
+        raise RuntimeError(f'Failed to initialize ONNX Runtime session: {e}') from e
diff --git a/uniface/py.typed b/uniface/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/uniface/recognition/__init__.py b/uniface/recognition/__init__.py
index 6de7fcd..ec8cb27 100644
--- a/uniface/recognition/__init__.py
+++ b/uniface/recognition/__init__.py
@@ -7,7 +7,7 @@ from .base import BaseRecognizer
 from .models import ArcFace, MobileFace, SphereFace
 
 
-def create_recognizer(method: str = "arcface", **kwargs) -> BaseRecognizer:
+def create_recognizer(method: str = 'arcface', **kwargs) -> BaseRecognizer:
     """
     Factory function to create face recognizers.
 
@@ -44,21 +44,21 @@ def create_recognizer(method: str = "arcface", **kwargs) -> BaseRecognizer:
     """
     method = method.lower()
 
-    if method == "arcface":
+    if method == 'arcface':
         return ArcFace(**kwargs)
-    elif method == "mobileface":
+    elif method == 'mobileface':
         return MobileFace(**kwargs)
-    elif method == "sphereface":
+    elif method == 'sphereface':
         return SphereFace(**kwargs)
     else:
-        available = ["arcface", "mobileface", "sphereface"]
+        available = ['arcface', 'mobileface', 'sphereface']
         raise ValueError(f"Unsupported method: '{method}'. Available: {available}")
 
 
 __all__ = [
-    "create_recognizer",
-    "ArcFace",
-    "MobileFace",
-    "SphereFace",
-    "BaseRecognizer",
+    'create_recognizer',
+    'ArcFace',
+    'MobileFace',
+    'SphereFace',
+    'BaseRecognizer',
 ]
diff --git a/uniface/recognition/base.py b/uniface/recognition/base.py
index 7190d52..12e81bd 100644
--- a/uniface/recognition/base.py
+++ b/uniface/recognition/base.py
@@ -66,14 +66,14 @@ class BaseRecognizer(ABC):
             input_shape = input_cfg.shape
             model_input_size = tuple(input_shape[2:4][::-1])  # (width, height)
             if model_input_size != self.input_size:
-                Logger.warning(f"Model input size {model_input_size} differs from configured size {self.input_size}")
+                Logger.warning(f'Model input size {model_input_size} differs from configured size {self.input_size}')
 
             # Extract output configuration
             self.output_names = [output.name for output in self.session.get_outputs()]
             self.output_shape = self.session.get_outputs()[0].shape
 
-            assert len(self.output_names) == 1, "Expected only one output node."
-            Logger.info(f"Successfully initialized face encoder from {self.model_path}")
+            assert len(self.output_names) == 1, 'Expected only one output node.'
+            Logger.info(f'Successfully initialized face encoder from {self.model_path}')
 
         except Exception as e:
             Logger.error(
diff --git a/uniface/recognition/models.py b/uniface/recognition/models.py
index 661e35b..3046e18 100644
--- a/uniface/recognition/models.py
+++ b/uniface/recognition/models.py
@@ -9,7 +9,7 @@ from uniface.model_store import verify_model_weights
 
 from .base import BaseRecognizer, PreprocessConfig
 
-__all__ = ["ArcFace", "MobileFace", "SphereFace"]
+__all__ = ['ArcFace', 'MobileFace', 'SphereFace']
 
 
 class ArcFace(BaseRecognizer):
diff --git a/uniface/visualization.py b/uniface/visualization.py
index d48c213..cb8e2e1 100644
--- a/uniface/visualization.py
+++ b/uniface/visualization.py
@@ -10,9 +10,9 @@ import numpy as np
 
 def draw_detections(
     image: np.ndarray,
-    bboxes: Union[np.ndarray, List[List[float]]],
+    bboxes: Union[List[np.ndarray], List[List[float]]],
     scores: Union[np.ndarray, List[float]],
-    landmarks: Union[np.ndarray, List[List[List[float]]]],
+    landmarks: Union[List[np.ndarray], List[List[List[float]]]],
     vis_threshold: float = 0.6,
 ):
     """
@@ -20,9 +20,11 @@ def draw_detections(
 
     Args:
         image (np.ndarray): The image to draw on.
-        bboxes (list or np.ndarray): A list of bounding boxes, e.g., [[x1,y1,x2,y2], ...].
-        scores (list or np.ndarray): A list of confidence scores.
-        landmarks (list or np.ndarray): A list of landmark sets, e.g., [[[x,y],...],...].
+        bboxes (List[np.ndarray] or List[List[float]]): List of bounding boxes. Each bbox can be
+            np.ndarray with shape (4,) or list [x1, y1, x2, y2].
+        scores (List[float] or np.ndarray): List or array of confidence scores.
+        landmarks (List[np.ndarray] or List[List[List[float]]]): List of landmark sets. Each landmark
+            set can be np.ndarray with shape (5, 2) or nested list [[[x,y],...],...].
         vis_threshold (float): Confidence threshold for filtering which detections to draw.
     """
     _colors = [(0, 0, 255), (0, 255, 255), (255, 0, 255), (0, 255, 0), (255, 0, 0)]
@@ -45,7 +47,7 @@ def draw_detections(
         # Draw score
         cv2.putText(
             image,
-            f"{score:.2f}",
+            f'{score:.2f}',
             (bbox[0], bbox[1] - 10),
             cv2.FONT_HERSHEY_SIMPLEX,
             0.5,