16 | {% for category, message in messages %}
17 |
30 | {% endfor %}
31 |
32 |
42 | {% endif %}
43 | {% endwith %}
44 |
45 |
46 |
74 |
75 |
76 |
--------------------------------------------------------------------------------
/utils/import os.py:
--------------------------------------------------------------------------------
1 | import os
2 | import shutil
3 | from pathlib import Path
4 | from smbclient import register_session, listdir, open_file, remove_session, path as smb_path
5 | from smbprotocol.exceptions import SMBException
6 |
7 | # Destination folder for photos before preparation
8 | PHOTOS_DIR = Path("static/photos")
9 | # Supported image extensions
10 | SUPPORTED_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.gif', '.heic', '.heif']
11 |
12 | def import_samba_photos(config):
13 | """
14 | Connects to an SMB share, lists, and copies image files to a local directory.
15 | This is a generator function that yields progress updates.
16 | """
17 | host = config.get("smb_host")
18 | share = config.get("smb_share")
19 | user = config.get("smb_user")
20 | password = config.get("smb_password")
21 | remote_path_str = config.get("smb_path", "/").strip("/")
22 |
23 | if not all([host, share]):
24 | yield {"type": "error", "message": "Configuration SMB incomplète : Hôte ou Partage manquant."}
25 | return
26 |
27 | # Construct the full UNC path
28 | full_remote_path_unc = f"\\\\{host}\\{share}"
29 | if remote_path_str:
30 | full_remote_path_unc += f"\\{remote_path_str.replace('/', '\\')}"
31 |
32 | yield {"type": "progress", "stage": "CONNECTING", "percent": 5, "message": f"Connexion à {full_remote_path_unc}"}
33 |
34 | session_registered = False
35 | try:
36 | # Register session if credentials are provided
37 | if user and password:
38 | register_session(host, username=user, password=password)
39 | session_registered = True
40 |
41 | if not smb_path.exists(full_remote_path_unc):
42 | yield {"type": "error", "message": f"Le chemin distant est introuvable : {full_remote_path_unc}"}
43 | return
44 |
45 | yield {"type": "progress", "stage": "LISTING", "percent": 10, "message": "Liste des fichiers distants..."}
46 |
47 | remote_files = listdir(full_remote_path_unc)
48 | image_files = [f for f in remote_files if Path(f).suffix.lower() in SUPPORTED_EXTENSIONS and not smb_path.isdir(os.path.join(full_remote_path_unc, f))]
49 |
50 | if not image_files:
51 | yield {"type": "warning", "message": f"Aucune photo trouvée dans le dossier : {full_remote_path_unc}"}
52 | yield {"type": "done", "percent": 100, "message": "Aucune nouvelle photo à importer."}
53 | return
54 |
55 | total_files = len(image_files)
56 | yield {"type": "progress", "stage": "PREPARING_IMPORT", "percent": 20, "message": f"{total_files} photos trouvées. Nettoyage du dossier local..."}
57 |
58 | PHOTOS_DIR.mkdir(exist_ok=True)
59 | for f in PHOTOS_DIR.iterdir():
60 | if f.is_file():
61 | f.unlink()
62 |
63 | yield {"type": "progress", "stage": "COPYING", "percent": 20, "message": f"Début de la copie de {total_files} photos..."}
64 | for i, filename in enumerate(image_files, start=1):
65 | remote_file_path = os.path.join(full_remote_path_unc, filename)
66 | local_file_path = PHOTOS_DIR / filename
67 | percent = 20 + int((i / total_files) * 60)
68 |
69 | with open_file(remote_file_path, mode='rb') as remote_f, open(local_file_path, 'wb') as local_f:
70 | shutil.copyfileobj(remote_f, local_f)
71 | yield {"type": "progress", "stage": "COPYING", "percent": percent, "message": f"Copie de {filename} ({i}/{total_files})"}
72 |
73 | yield {"type": "done", "percent": 80, "message": f"Copie terminée. {total_files} photos importées."}
74 |
75 | except SMBException as e:
76 | yield {"type": "error", "message": f"Erreur SMB : {e}"}
77 | except Exception as e:
78 | yield {"type": "error", "message": f"Erreur inattendue : {e}"}
79 | finally:
80 | if session_registered:
81 | try:
82 | remove_session(host)
83 | except Exception:
84 | pass
--------------------------------------------------------------------------------
/utils/config_manager.py:
--------------------------------------------------------------------------------
1 | import json
2 | import os
3 |
4 | CONFIG_PATH = os.path.join(os.path.dirname(__file__), '..', 'config', 'config.json')
5 |
6 | def create_default_config():
7 | """Crée et retourne un dictionnaire de configuration par défaut. Source unique de vérité."""
8 | return {
9 | "display_duration": 10,
10 | "active_start": "07:00",
11 | "active_end": "22:00",
12 | "immich_url": "",
13 | "immich_token": "",
14 | "album_name": "",
15 | "display_width": 1920,
16 | "display_height": 1080,
17 | "pan_zoom_factor": 1.15,
18 | "immich_auto_update": False,
19 | "immich_update_interval_hours": 24,
20 | "pan_zoom_enabled": False,
21 | "transition_enabled": True,
22 | "transition_type": "fade",
23 | "transition_duration": 1.0,
24 | "video_audio_enabled": False,
25 | "video_audio_output": "auto",
26 | "video_audio_volume": 100,
27 | "smb_host": "",
28 | "smb_share": "",
29 | "smb_user": "",
30 | "smb_password": "",
31 | "smb_path": "/",
32 | "smb_auto_update": False,
33 | "smb_update_interval_hours": 24,
34 | "display_sources": ["immich"],
35 | "show_clock": True,
36 | "clock_format": "%H:%M",
37 | "clock_color": "#FFFFFF",
38 | "clock_outline_color": "#000000",
39 | "clock_font_size": 72,
40 | "clock_font_path": "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
41 | "clock_offset_x": 0,
42 | "clock_offset_y": 0,
43 | "clock_position": "center",
44 | "clock_background_enabled": False,
45 | "clock_background_color": "#00000080",
46 | "show_date": True,
47 | "date_format": "%A %d %B %Y",
48 | "show_weather": True,
49 | "weather_api_key": "",
50 | "weather_city": "Paris",
51 | "weather_units": "metric",
52 | "weather_update_interval_minutes": 60,
53 | "show_tides": False,
54 | "tide_latitude": "",
55 | "tide_longitude": "",
56 | "stormglass_api_key": "",
57 | "tide_offset_x": 0,
58 | "tide_offset_y": 0,
59 | "wifi_ssid": "",
60 | "wifi_country": "FR",
61 | "wifi_password": "",
62 | "skip_initial_auto_import": False,
63 | "info_display_duration": 5,
64 | "screen_height_percent": 100,
65 | "favorite_boost_factor": 2,
66 | "video_hwdec_enabled": False,
67 | "telegram_bot_enabled": False,
68 | "telegram_bot_token": "",
69 | "telegram_authorized_users": "",
70 | "voice_control_enabled": False,
71 | "voice_control_language": "fr",
72 | "porcupine_access_key": "",
73 | "voice_control_device_index": "",
74 | "notification_sound_volume": 80, # NOUVEAU: Volume pour les sons de notification
75 | }
76 |
77 | def load_config():
78 | """Charge la configuration depuis le fichier et la fusionne avec les valeurs par défaut."""
79 | default_config = create_default_config()
80 |
81 | if not os.path.exists(CONFIG_PATH):
82 | # Si le fichier de config n'existe pas, on le crée avec les valeurs par défaut.
83 | save_config(default_config)
84 | return default_config
85 |
86 | try:
87 | with open(CONFIG_PATH, 'r', encoding='utf-8') as f:
88 | user_config = json.load(f)
89 |
90 | # Fusionne la configuration utilisateur avec la configuration par défaut.
91 | # Cela garantit que les nouvelles clés de configuration sont ajoutées
92 | # sans écraser les réglages existants de l'utilisateur.
93 | merged_config = default_config.copy()
94 | merged_config.update(user_config)
95 | return merged_config
96 | except (json.JSONDecodeError, IOError) as e:
97 | # En cas de fichier corrompu ou illisible, on retourne la config par défaut
98 | # pour éviter un crash de l'application.
99 | print(f"Avertissement: Impossible de charger {CONFIG_PATH} ({e}). Utilisation de la configuration par défaut.")
100 | return default_config
101 |
102 | def save_config(config):
103 | """Sauvegarde la configuration dans un fichier JSON."""
104 | os.makedirs(os.path.dirname(CONFIG_PATH), exist_ok=True)
105 | with open(CONFIG_PATH, 'w', encoding='utf-8') as f:
106 | json.dump(config, f, indent=4, ensure_ascii=False)
--------------------------------------------------------------------------------
/import time.py:
--------------------------------------------------------------------------------
1 | import time
2 | from datetime import datetime, timedelta
3 | import threading
4 | import os
5 | import json
6 | from utils.config import load_config
7 | from utils.download_album import download_and_extract_album
8 | from utils.prepare_all_photos import prepare_all_photos_with_progress
9 |
10 | # Chemin vers un fichier pour stocker les horodatages des dernières mises à jour
11 | LAST_UPDATE_FILE = os.path.join("config", "last_updates.json")
12 |
13 | def read_last_updates():
14 | """Lit les horodatages des dernières mises à jour depuis un fichier JSON."""
15 | if not os.path.exists(LAST_UPDATE_FILE):
16 | return {}
17 | try:
18 | with open(LAST_UPDATE_FILE, "r") as f:
19 | return json.load(f)
20 | except (json.JSONDecodeError, IOError):
21 | return {}
22 |
23 | def write_last_update(source_name):
24 | """Écrit l'horodatage actuel pour une source donnée."""
25 | updates = read_last_updates()
26 | updates[source_name] = datetime.now().isoformat()
27 | try:
28 | with open(LAST_UPDATE_FILE, "w") as f:
29 | json.dump(updates, f, indent=2)
30 | except IOError as e:
31 | print(f"[Updater] Erreur lors de l'écriture de l'heure de mise à jour : {e}")
32 |
33 | def immich_update_task():
34 | """Vérifie si une mise à jour Immich est nécessaire et la lance."""
35 | print("[Updater] Vérification des mises à jour Immich...")
36 | config = load_config()
37 |
38 | if not config.get("immich_auto_update", False):
39 | return
40 |
41 | interval_hours = int(config.get("immich_update_interval_hours", 24))
42 | last_updates = read_last_updates()
43 | last_update_str = last_updates.get("immich")
44 |
45 | if last_update_str:
46 | last_update_time = datetime.fromisoformat(last_update_str)
47 | if datetime.now() < last_update_time + timedelta(hours=interval_hours):
48 | return
49 |
50 | print("[Updater] Mise à jour pour Immich nécessaire. Lancement...")
51 | try:
52 | download_generator = download_and_extract_album(config)
53 | download_complete = False
54 | for update in download_generator:
55 | print(f"[Updater] Immich Download: {update.get('message')}")
56 | if update.get('type') == 'error':
57 | print(f"[Updater] Erreur pendant le téléchargement Immich : {update.get('message')}")
58 | return
59 | if update.get('stage') == 'DOWNLOAD_COMPLETE':
60 | download_complete = True
61 |
62 | if not download_complete:
63 | return
64 |
65 | print("[Updater] Lancement de la préparation des photos pour Immich...")
66 | prepare_generator = prepare_all_photos_with_progress(source_type="immich")
67 | for update in prepare_generator:
68 | print(f"[Updater] Préparation Photo: {update.get('message')}")
69 | if update.get('type') == 'error':
70 | print(f"[Updater] Erreur pendant la préparation des photos : {update.get('message')}")
71 | return
72 |
73 | print("[Updater] Mise à jour et préparation Immich terminées.")
74 | write_last_update("immich")
75 |
76 | except Exception as e:
77 | print(f"[Updater] Erreur inattendue pendant la mise à jour Immich : {e}")
78 |
79 | def smb_update_task():
80 | """Placeholder pour la logique de mise à jour SMB."""
81 | config = load_config()
82 | if config.get("smb_auto_update", False):
83 | print("[Updater] La logique de mise à jour auto pour SMB n'est pas encore implémentée.")
84 |
85 | def background_updater_loop():
86 | """Boucle principale pour le thread de mise à jour."""
87 | check_interval_seconds = 3600 # Vérifier toutes les heures
88 |
89 | while True:
90 | print("\n[Updater] Lancement des vérifications périodiques...")
91 |
92 | immich_update_task()
93 | smb_update_task()
94 |
95 | print(f"[Updater] Vérifications terminées. Prochaine vérification dans {check_interval_seconds / 3600} heure(s).")
96 | time.sleep(check_interval_seconds)
97 |
98 | def start_background_updater():
99 | """Démarre le processus de mise à jour en arrière-plan dans un thread séparé."""
100 | updater_thread = threading.Thread(target=background_updater_loop, daemon=True)
101 | updater_thread.start()
102 | print("Le thread de mise à jour en arrière-plan a démarré.")
--------------------------------------------------------------------------------
/FAQ_en.md:
--------------------------------------------------------------------------------
1 | # ❓ Frequently Asked Questions (FAQ) - Pimmich
2 |
3 | Here is a list of frequently asked questions to help you use and troubleshoot Pimmich.
4 |
5 | ---
6 |
7 | ### General Questions
8 |
9 | **Q: What is Pimmich?**
10 |
11 | **A:** Pimmich is software that turns a Raspberry Pi into a smart digital photo frame. It can display photos from an [Immich](https://immich.app/) server, a USB stick, a network share (Samba/Windows), a smartphone, or even via the Telegram messaging app.
12 |
13 | **Q: What do I need to use Pimmich?**
14 |
15 | **A:** You will need:
16 | - A Raspberry Pi (model 3, 4, or 5 recommended) with its power supply.
17 | - An SD card with Raspberry Pi OS (64-bit) installed.
18 | - A screen.
19 | - An internet connection (Wi-Fi or Ethernet).
20 |
21 | ---
22 |
23 | ### Installation and Configuration
24 |
25 | **Q: How do I install Pimmich?**
26 |
27 | **A:** The installation is designed to be simple:
28 | 1. Clone the GitHub repository: `git clone https://github.com/gotenash/pimmich.git`
29 | 2. Go into the directory: `cd pimmich`
30 | 3. Make the installation script executable: `chmod +x setup.sh`
31 | 4. Run the script with administrator rights: `sudo ./setup.sh`
32 | The script takes care of installing all dependencies and configuring the system for automatic startup.
33 |
34 | **Q: How do I access the configuration interface?**
35 |
36 | **A:** Once the Raspberry Pi has started, open a web browser on another device (computer, smartphone) connected to the same network and simply type in your Raspberry Pi's IP address. For example: `http://192.168.1.25`. If you don't know the IP, it is often displayed on the frame's screen on the first boot or if no photos are found.
37 |
38 | **Q: I forgot my password for the web interface. How can I reset it?**
39 |
40 | **A:** The initial password is stored in the `/boot/firmware/credentials.json` file. You can connect to your Raspberry Pi via SSH to read this file. If you changed it through the interface and forgot it, you will need to delete this file and reboot the Pi for it to generate a new one (warning: this will reset the user).
41 |
42 | **Q: How do I get an Immich API Token?**
43 |
44 | **A:**
45 | 1. Log in to your Immich web interface.
46 | 2. Go to "Account Settings" (via your profile icon).
47 | 3. In the "API Keys" section, click "Generate New API Key".
48 | 4. Give it a name (e.g., "Pimmich") and copy the generated key.
49 |
50 | *Tip:* For better security, create a dedicated Immich user for the frame with limited access to a single shared album.
51 |
52 | ---
53 |
54 | ### Features
55 |
56 | **Q: How does the Telegram feature work?**
57 |
58 | **A:** It allows you and your guests to send photos directly to the frame.
59 | 1. **Create a bot** on Telegram by talking to `@BotFather`. It will give you a **Token**.
60 | 2. **Get your user ID** on Telegram by talking to a bot like `@userinfobot`.
61 | 3. Enter both pieces of information in the "Telegram" tab in Pimmich.
62 | 4. You can then create secure, temporary invitation links for your loved ones.
63 |
64 | **Q: What is the "Favorites" tab for?**
65 |
66 | **A:** By marking a photo as a favorite (using the star icon in the "Preview" tab), you increase its display frequency in the slideshow. You can adjust the "boost factor" in the "Display" tab to make them appear more or less often.
67 |
68 | **Q: What is the "Postcard" effect?**
69 |
70 | **A:** It's a filter that adds a white border and a space for a caption (if you add one via the interface) to your photos, giving them a postcard look. Photos sent via Telegram use this effect by default for a more personal and warm touch.
71 |
72 | ---
73 |
74 | ### Troubleshooting
75 |
76 | **Q: I have a problem, where can I find help?**
77 |
78 | **A:** The **System** tab is the best place to start. It contains a **Logs** section.
79 | - `app.py` contains the logs for the web server (configuration interface).
80 | - `local_slideshow_stdout` and `local_slideshow_stderr` contain the logs for the slideshow itself. Errors will most often appear in `stderr`.
81 |
82 | **Q: Videos are not smooth or don't display. What should I do?**
83 |
84 | **A:** In the **Display** tab, try enabling the "**Enable hardware video decoding**" option. It is much more performant, especially on a Raspberry Pi. If it causes issues (black/blue screen after a video), disable it.
85 |
86 | **Q: The Wi-Fi won't connect, but Ethernet (cable) works. Why?**
87 |
88 | **A:** Sometimes, if an Ethernet cable is plugged in, the system gives it priority. In the **System** tab, you can try to temporarily disable the "**Wired Interface (eth0)**" to force the system to use Wi-Fi exclusively.
89 |
90 | **Q: How do I update Pimmich?**
91 |
92 | **A:** Go to the **System** tab and click the "**Check for updates**" button. Pimmich will download the latest version from GitHub and restart automatically.
93 |
94 | **Q: I changed a setting, but nothing changes on the slideshow.**
95 |
96 | **A:** Some changes, especially those related to display (font, weather, etc.), require the slideshow to be restarted to take effect. You can do this from the **Actions** tab by clicking "Stop" and then "Start Slideshow". For more significant changes, a restart of the web application or the system (from the **System** tab) may be necessary.
--------------------------------------------------------------------------------
/utils/download_album.py:
--------------------------------------------------------------------------------
1 | import os
2 | import requests
3 | import shutil
4 | import time
5 | import json
6 | from pathlib import Path
7 | from utils.archive_manager import download_album_archive, unzip_archive, clean_archive
8 |
9 | # Définir le chemin du cache pour le mappage des descriptions
10 | CACHE_DIR = Path("cache")
11 | CACHE_DIR.mkdir(exist_ok=True)
12 | DESCRIPTION_MAP_CACHE_FILE = CACHE_DIR / "immich_description_map.json"
13 |
14 | def download_and_extract_album(config):
15 | server_url = config.get("immich_url")
16 | api_key = config.get("immich_token")
17 | album_name = config.get("album_name")
18 |
19 | if not all([server_url, api_key, album_name]):
20 | yield {"type": "error", "message": "Configuration incomplète : serveur, token ou nom d'album manquant."}
21 | return
22 |
23 | yield {"type": "progress", "stage": "CONNECTING", "percent": 5, "message": "Connexion à Immich..."}
24 | time.sleep(0.5)
25 |
26 | headers = { "x-api-key": api_key }
27 | album_list_url = f"{server_url}/api/albums"
28 |
29 | try:
30 | response = requests.get(album_list_url, headers=headers, timeout=10)
31 | response.raise_for_status()
32 | except requests.exceptions.RequestException as e:
33 | yield {"type": "error", "message": f"Impossible de se connecter au serveur Immich : {str(e)}"}
34 | return
35 |
36 | yield {"type": "progress", "stage": "SEARCHING", "percent": 10, "message": "Recherche de l'album..."}
37 |
38 | albums = response.json()
39 | album_id = next((album["id"] for album in albums if album["albumName"] == album_name), None)
40 | if not album_id:
41 | available_albums = [album["albumName"] for album in albums[:5]] # Limiter à 5 pour l'affichage
42 | yield {"type": "error", "message": f"Album '{album_name}' introuvable. Albums disponibles : {', '.join(available_albums)}"}
43 | return
44 |
45 | yield {"type": "progress", "stage": "FETCHING_ASSETS", "percent": 15, "message": "Récupération de la liste des photos..."}
46 |
47 | assets_url = f"{server_url}/api/albums/{album_id}"
48 | response = requests.get(assets_url, headers=headers, timeout=30)
49 | response.raise_for_status()
50 |
51 | album_data = response.json()
52 | assets = album_data.get("assets", [])
53 | asset_ids = [asset["id"] for asset in assets]
54 |
55 | if not asset_ids:
56 | yield {"type": "error", "message": "L'album est vide ou ne contient aucune photo accessible."}
57 | return
58 |
59 | # Créer un mappage nom de fichier -> description
60 | filename_to_description_map = {}
61 | for asset in assets:
62 | original_filename = asset.get("originalFileName")
63 | # La description est dans exifInfo
64 | description = asset.get("exifInfo", {}).get("description")
65 | if original_filename and description:
66 | filename_to_description_map[original_filename] = description
67 |
68 | # Sauvegarder le mappage dans un fichier cache pour que l'étape de préparation puisse l'utiliser.
69 | try:
70 | with open(DESCRIPTION_MAP_CACHE_FILE, 'w', encoding='utf-8') as f:
71 | json.dump(filename_to_description_map, f, ensure_ascii=False, indent=2)
72 | print(f"[Immich Import] Mappage des descriptions sauvegardé dans {DESCRIPTION_MAP_CACHE_FILE}")
73 | except Exception as e:
74 | # On ne bloque pas le processus, on affiche juste un avertissement.
75 | yield {"type": "warning", "message": f"Avertissement : Impossible de sauvegarder le mappage des descriptions : {e}"}
76 |
77 | nb_photos = len(asset_ids)
78 | yield {"type": "progress", "stage": "DOWNLOADING", "percent": 25, "message": f"Téléchargement de l'archive ({nb_photos} photos)..."}
79 |
80 | zip_path = "temp_album.zip"
81 |
82 | try:
83 | if not download_album_archive(server_url, api_key, asset_ids, zip_path):
84 | yield {"type": "error", "message": "Échec du téléchargement de l'archive."}
85 | return
86 | except Exception as e:
87 | yield {"type": "error", "message": f"Erreur critique lors du téléchargement : {str(e)}"}
88 | return
89 |
90 | yield {"type": "progress", "stage": "EXTRACTING", "percent": 60, "message": "Extraction des photos..."}
91 | photos_folder = os.path.join("static", "photos", "immich")
92 | prepared_folder = os.path.join("static", "prepared", "immich")
93 |
94 | # Vider les dossiers de destination (source et préparé) avant l'import pour éviter les mélanges.
95 | if os.path.exists(photos_folder):
96 | shutil.rmtree(photos_folder)
97 | os.makedirs(photos_folder, exist_ok=True)
98 |
99 | if os.path.exists(prepared_folder):
100 | shutil.rmtree(prepared_folder)
101 | os.makedirs(prepared_folder, exist_ok=True)
102 |
103 | try:
104 | unzip_archive(zip_path, photos_folder)
105 | clean_archive(zip_path)
106 | except Exception as e:
107 | yield {"type": "error", "message": f"Erreur lors de l'extraction : {str(e)}"}
108 | return
109 |
110 | yield { "type": "done", "stage": "DOWNLOAD_COMPLETE", "percent": 80, "message": f"{nb_photos} photos prêtes pour préparation.", "total_downloaded": nb_photos }
111 |
--------------------------------------------------------------------------------
/utils/display_manager.py:
--------------------------------------------------------------------------------
1 | import os
2 | import subprocess
3 | import time
4 | import json
5 | import glob
6 | import requests
7 | from pathlib import Path
8 | from .config_manager import load_config
9 |
10 | def get_display_output_name():
11 | """
12 | Trouve le nom de la sortie d'affichage principale (celle qui est active ou a un mode).
13 | """
14 | try:
15 | if "SWAYSOCK" not in os.environ:
16 | user_id = os.getuid()
17 | sock_path_pattern = f"/run/user/{user_id}/sway-ipc.*"
18 | socks = glob.glob(sock_path_pattern)
19 | if socks:
20 | os.environ["SWAYSOCK"] = socks[0]
21 | else:
22 | return None
23 |
24 | result = subprocess.run(['swaymsg', '-t', 'get_outputs'], capture_output=True, text=True, check=True, env=os.environ)
25 | outputs = json.loads(result.stdout)
26 |
27 | for output in outputs:
28 | if output.get('active', False) or output.get('current_mode'):
29 | return output.get('name')
30 | return None
31 | except Exception as e:
32 | print(f"Erreur lors de la récupération du nom de la sortie d'affichage : {e}")
33 | return None
34 |
35 | def _send_smart_plug_command(url):
36 | """Envoie une requête HTTP à l'URL de la prise connectée."""
37 | if not url:
38 | return False, "URL de la prise connectée non configurée."
39 | try:
40 | # Utiliser un timeout court pour ne pas bloquer le système
41 | response = requests.post(url, timeout=5)
42 | # On considère que c'est un succès si la requête aboutit (code 2xx)
43 | if 200 <= response.status_code < 300:
44 | print(f"Commande prise connectée envoyée avec succès à {url}")
45 | return True, "Commande envoyée à la prise."
46 | else:
47 | error_msg = f"La prise connectée a répondu avec une erreur {response.status_code}."
48 | print(error_msg)
49 | return False, error_msg
50 | except requests.RequestException as e:
51 | error_msg = f"Erreur de communication avec la prise connectée : {e}"
52 | print(error_msg)
53 | return False, error_msg
54 |
55 | def set_display_power(on=True):
56 | """
57 | Allume ou éteint l'écran, en utilisant une prise connectée si configurée,
58 | sinon en utilisant la commande logicielle (swaymsg).
59 | """
60 | config = load_config()
61 |
62 | if config.get("smart_plug_enabled"):
63 | # --- Logique de la prise connectée ---
64 | if on:
65 | # --- SÉQUENCE D'ALLUMAGE AVEC REDÉMARRAGE SYSTÈME ---
66 | print("[Display Manager] Allumage de la prise connectée...")
67 | on_url = config.get("smart_plug_on_url")
68 | success, message = _send_smart_plug_command(on_url)
69 | if not success:
70 | return False, f"Échec de l'allumage de la prise : {message}"
71 |
72 | # Attendre que l'écran s'allume avant de redémarrer
73 | delay = int(config.get("smart_plug_on_delay", 5))
74 | print(f"Attente de {delay} secondes pour l'initialisation de l'écran...")
75 | time.sleep(delay)
76 |
77 | # Créer un fichier drapeau pour indiquer qu'un redémarrage est intentionnel
78 | # pour éviter une boucle de redémarrage.
79 | # On le place dans le dossier 'cache' pour qu'il persiste après le redémarrage.
80 | flag_path = Path(__file__).resolve().parent.parent / 'cache' / 'pimmich_reboot_flag.tmp'
81 | flag_path.parent.mkdir(exist_ok=True) # S'assurer que le dossier cache existe
82 | flag_path.touch()
83 |
84 | print("[Display Manager] Lancement du redémarrage du système pour garantir la bonne résolution...")
85 | os.system('sudo reboot')
86 | # Le script s'arrêtera ici car le système redémarre.
87 | return True, "Redémarrage système initié."
88 | else:
89 | # --- SÉQUENCE D'EXTINCTION ---
90 | # 1. Mettre l'écran en veille logicielle d'abord
91 | _set_software_display_power(on=False)
92 | time.sleep(1) # Petite pause
93 | # 2. Couper l'alimentation de la prise
94 | off_url = config.get("smart_plug_off_url")
95 | return _send_smart_plug_command(off_url)
96 | else:
97 | # --- Logique logicielle par défaut ---
98 | return _set_software_display_power(on)
99 |
100 | def _set_software_display_power(on=True):
101 | """Allume ou éteint l'écran en utilisant swaymsg (contrôle logiciel)."""
102 | output_name = get_display_output_name()
103 | if not output_name:
104 | return False, "Aucune sortie d'affichage principale trouvée."
105 |
106 | state = "on" if on else "off"
107 | try:
108 | subprocess.run(['swaymsg', 'output', output_name, 'dpms', state], check=True, capture_output=True, text=True)
109 | print(f"Écran '{output_name}' passé en mode DPMS '{state}'.")
110 | return True, f"Écran passé en mode {state}."
111 | except Exception as e:
112 | error_message = f"Erreur lors du changement d'état de l'écran : {e}"
113 | print(error_message)
114 | return False, error_message
--------------------------------------------------------------------------------
/README_en.md:
--------------------------------------------------------------------------------
1 | # 🖼️ Pimmich – Smart Connected Photo Frame
2 |
3 | Pimmich is a Python application designed to turn a Raspberry Pi into a smart and customizable digital photo frame. It can display photos from multiple sources, be controlled by voice, and much more.
4 |
5 |
47 |  }})
48 |
73 |
48 | {{ _('Envoyer des photos pour le cadre') }}
49 |{{ _('Les photos seront soumises à validation avant d\'être affichées.') }}
50 | 51 | 62 | 65 | 72 |
6 |
7 | ---
8 |
9 | ## 📖 Table of Contents
10 |
11 | - ✨ Main Features
12 | - 🧰 Technologies Used
13 | - 🚀 Installation
14 | - 🔧 Configuration
15 | - 🗣️ Voice Control
16 | - ❓ Troubleshooting (FAQ)
17 | - 🛣️ Roadmap
18 | - June 2025
19 | - July 2025
20 | - August 2025
21 | - 💖 Credits
22 |
23 | ---
24 |
25 | ## ✨ Main Features
26 |
27 | Pimmich is packed with features to provide a complete and customizable experience:
28 |
29 | #### 🖼️ **Display & Slideshow**
30 | - **Multi-source:** Display photos from Immich, a network share (Samba/Windows), a USB drive, a smartphone, or via Telegram.
31 | - **Advanced Customization:** Set display duration, active hours, transitions (fade, slide), and enable a "Pan & Zoom" motion effect.
32 | - **Creative Filters:** Apply filters to your photos (Black & White, Sepia, Vintage) and unique effects like **Polaroid** or **Postcard**.
33 | - **Format Handling:** Smart support for portrait photos (blurred background) and videos (with sound and optional hardware acceleration).
34 |
35 | #### ⚙️ **Interface & Control**
36 | - **Comprehensive Web Interface:** A local configuration page, password-protected and organized into thematic groups and tabs for an intuitive navigation.
37 | - **Voice Control:** Control your frame with voice commands like *"Magic Frame, next photo"* or *"Magic Frame, play Vacation playlist"*.
38 | - **Content Management:**
39 | - **Playlists:** Create virtual albums, reorder photos with drag-and-drop, and launch themed slideshows with a dynamic title screen (photo jumble on a corkboard background).
40 | - **Favorites:** Mark your favorite photos to make them appear more often.
41 | - **Captions:** Add custom text to your photos and postcards.
42 |
43 | #### 🌐 **Connectivity & Interactions**
44 | - **Telegram:** Allow friends and family to send photos to the frame via a Telegram bot, with a secure and temporary invitation system.
45 | - **Wi-Fi & Network:** Configure Wi-Fi, scan for networks, and manage network interfaces directly from the interface.
46 | - **Smartphone Upload:** Import photos directly from your phone's browser.
47 |
48 | #### 🛠️ **Maintenance & Monitoring**
49 | - **Easy Updates:** Update Pimmich with a single click from the interface.
50 | - **Backup & Restore:** Back up and restore your entire configuration.
51 | - **System Monitoring:** Track real-time temperature, CPU, RAM, and disk usage with history graphs.
52 | - **Detailed Logs:** Access logs for each service (web server, slideshow, voice control) for easy troubleshooting.
53 |
54 | ---
55 |
56 | ## 🧰 Technologies Used
57 |
58 | - **Backend:** Python, Flask
59 | - **Frontend:** HTML, TailwindCSS, JavaScript
60 | - **Slideshow:** Pygame
61 | - **Image Processing:** Pillow
62 | - **Voice Control:** Picovoice Porcupine (wake word) & Vosk (recognition)
63 | - **Web Server:** NGINX (as a reverse proxy)
64 |
65 | ---
66 |
67 | ## 🚀 Installation
68 |
69 | There are two methods to install Pimmich.
70 |
71 | ### Method 1: Pre-configured Image (Recommended and easier)
72 |
73 | This method is ideal for a quick first-time installation.
74 |
75 | 1. **Download the current month's image**
76 | Go to the Pimmich Releases page and download the `.img` file of the latest version.
77 |
78 | 2. **Flash the image to an SD card**
79 | Use software like Raspberry Pi Imager or BalenaEtcher to write the image file you just downloaded to your microSD card.
80 |
81 | 3. **Start your Raspberry Pi**
82 | Insert the SD card into the Raspberry Pi, connect the screen and power supply. Pimmich will start automatically.
83 |
84 | ### Method 2: Manual Installation from Git Repository
85 |
86 | This method is for advanced users or those who want to follow development closely.
87 |
88 | #### ✅ Prerequisites
89 |
90 | - A Raspberry Pi (model 3B+, 4, or 5 recommended) with Raspberry Pi OS Desktop (64-bit).
91 | - An SD card, a power supply, a screen.
92 | - An Internet connection.
93 |
94 | #### 📝 Installation Steps
95 |
96 | 1. **Clone the repository**
97 | Open a terminal on your Raspberry Pi and run:
98 | ```bash
99 | git clone https://github.com/gotenash/pimmich.git
100 | cd pimmich
101 | ```
102 |
103 | 2. **Run the installation script**
104 | This script installs all dependencies, configures the environment, and prepares for automatic startup.
105 | ```bash
106 | chmod +x setup.sh
107 | sudo ./setup.sh
108 | ```
109 |
110 | This script installs system and Python dependencies, sets up the environment, and configures auto-start of the slideshow.
111 |
112 | ---
113 |
114 | ### 🔑 Get Your Immich API Token
115 |
116 | 1. Log into your Immich web interface
117 | 2. Go to **Account Settings**
118 |
119 | Click your profile icon (top-right), then choose **Account Settings**.
120 |
121 | 3. Generate a new API key
122 | In the **API Key** section, click **Generate new API Key** and give it a name (e.g., `PimmichFrame`).
123 |
124 | ⚠️ Once the token is shown, **copy it immediately** — you won’t be able to see it again. If lost, you’ll need to generate a new one.
125 |
126 | 🔒 We recommend creating a dedicated Immich account for the photo frame, with access to a single shared album.
127 |
128 | ---
129 |
130 | ### Connect to Pimmich
131 |
132 | From a web browser on another device, access:
133 |
134 | ```
135 | http://
18 | {% for category, message in messages %}
19 |
32 | {% endfor %}
33 |
34 |
44 | {% endif %}
45 | {% endwith %}
46 |
47 |
48 |
87 |
88 |
112 |
113 |
--------------------------------------------------------------------------------
/utils/import_samba.py:
--------------------------------------------------------------------------------
1 | import os
2 | import shutil
3 | from pathlib import Path
4 | import smbclient
5 | from smbprotocol.exceptions import SMBException
6 |
7 | TARGET_DIR = Path("static/photos/samba")
8 | ALLOWED_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.gif', '.heic', '.heif'}
9 |
10 | def is_image_file(filename):
11 | return Path(filename).suffix.lower() in ALLOWED_EXTENSIONS
12 |
13 | def import_samba_photos(config):
14 | """
15 | Synchronise les photos depuis un partage Samba et retourne des objets structurés pour le suivi.
16 | Copie uniquement les fichiers nouveaux ou modifiés et supprime les fichiers locaux obsolètes.
17 | """
18 | server = config.get("smb_host")
19 | share = config.get("smb_share")
20 | path = config.get("smb_path", "")
21 | user = config.get("smb_user")
22 | password = config.get("smb_password")
23 |
24 | if not all([server, share]):
25 | yield {"type": "error", "message": "Configuration Samba incomplète : serveur ou nom de partage manquant."}
26 | return
27 |
28 | # Construction robuste du chemin UNC pour éviter les problèmes de slashs finaux.
29 | path_in_share = path.strip('/')
30 | if path_in_share:
31 | full_samba_path = f"//{server}/{share}/{path_in_share}"
32 | else:
33 | full_samba_path = f"//{server}/{share}"
34 | yield {"type": "progress", "stage": "CONNECTING", "percent": 5, "message": f"Connexion à {full_samba_path}..."}
35 |
36 | try:
37 | # On ne gère plus les sessions manuellement pour être compatible avec d'anciennes versions de smbclient.
38 | # Les identifiants sont passés directement aux fonctions.
39 | if not smbclient.path.exists(full_samba_path, username=user, password=password, connection_timeout=15):
40 | yield {"type": "error", "message": f"Le chemin Samba est introuvable : {full_samba_path}"}
41 | return
42 |
43 | # --- Phase 1: Lister les fichiers distants et locaux ---
44 | yield {"type": "progress", "stage": "SCANNING", "percent": 10, "message": "Analyse des fichiers distants et locaux..."}
45 |
46 | # Vider les dossiers de destination (source et préparé) avant l'import pour éviter les mélanges.
47 | prepared_samba_dir = Path("static/prepared/samba")
48 | if TARGET_DIR.exists():
49 | shutil.rmtree(TARGET_DIR)
50 | TARGET_DIR.mkdir(parents=True, exist_ok=True)
51 | if prepared_samba_dir.exists():
52 | shutil.rmtree(prepared_samba_dir)
53 | prepared_samba_dir.mkdir(parents=True, exist_ok=True)
54 |
55 | # Récupérer les fichiers distants avec leur date de modification
56 | remote_files = {}
57 | for filename in smbclient.listdir(full_samba_path, username=user, password=password):
58 | if is_image_file(filename):
59 | try:
60 | remote_file_path = os.path.join(full_samba_path, filename)
61 | if smbclient.path.isfile(remote_file_path, username=user, password=password):
62 | stat_info = smbclient.stat(remote_file_path, username=user, password=password)
63 | remote_files[filename] = stat_info.st_mtime
64 | except Exception as e:
65 | yield {"type": "warning", "message": f"Impossible d'accéder aux informations de {filename}: {e}"}
66 |
67 | # Récupérer les fichiers locaux avec leur date de modification
68 | TARGET_DIR.mkdir(parents=True, exist_ok=True)
69 | local_files = {f.name: f.stat().st_mtime for f in TARGET_DIR.iterdir() if f.is_file()}
70 |
71 | # --- Phase 2: Déterminer les actions à effectuer ---
72 | files_to_copy = {f for f, mtime in remote_files.items() if f not in local_files or mtime > local_files.get(f, 0)}
73 | files_to_delete = {f for f in local_files if f not in remote_files}
74 |
75 | # --- Phase 3: Supprimer les fichiers locaux obsolètes ---
76 | if files_to_delete:
77 | yield {"type": "progress", "stage": "CLEANING", "percent": 15, "message": f"Suppression de {len(files_to_delete)} photos obsolètes..."}
78 | for filename in files_to_delete:
79 | try:
80 | (TARGET_DIR / filename).unlink()
81 | except OSError as e:
82 | yield {"type": "warning", "message": f"Impossible de supprimer {filename}: {e}"}
83 |
84 | # --- Phase 4: Copier les fichiers nouveaux ou modifiés ---
85 | total_to_copy = len(files_to_copy)
86 | if total_to_copy == 0:
87 | yield {"type": "info", "message": "Aucune nouvelle photo à importer. Le dossier est à jour."}
88 | yield {"type": "done", "stage": "IMPORT_COMPLETE", "percent": 100, "message": "Synchronisation terminée. Aucune nouvelle photo."}
89 | return
90 |
91 | yield {"type": "stats", "stage": "COPYING", "percent": 20, "message": f"Début de la copie de {total_to_copy} photos...", "total": total_to_copy}
92 |
93 | for i, filename in enumerate(sorted(list(files_to_copy)), 1):
94 | source_file = os.path.join(full_samba_path, filename)
95 | dest_file = TARGET_DIR / filename
96 |
97 | try:
98 | with smbclient.open_file(source_file, mode='rb', username=user, password=password) as remote_f:
99 | with open(dest_file, 'wb') as local_f:
100 | shutil.copyfileobj(remote_f, local_f)
101 |
102 | # Mettre à jour la date de modification du fichier local pour correspondre au distant
103 | os.utime(dest_file, (remote_files[filename], remote_files[filename]))
104 |
105 | percent = 20 + int((i / total_to_copy) * 60) # La copie représente 60% de la barre (de 20% à 80%)
106 | yield {
107 | "type": "progress", "stage": "COPYING", "percent": percent,
108 | "message": f"Copie en cours... ({i}/{total_to_copy})",
109 | "current": i, "total": total_to_copy
110 | }
111 | except Exception as e:
112 | yield {"type": "warning", "message": f"Impossible de copier {filename}: {str(e)}"}
113 |
114 | yield {"type": "done", "stage": "IMPORT_COMPLETE", "percent": 80, "message": f"{total_to_copy} photos synchronisées.", "total_imported": total_to_copy}
115 |
116 | except SMBException as e:
117 | yield {"type": "error", "message": f"Erreur Samba : {str(e)}"}
118 | except Exception as e:
119 | yield {"type": "error", "message": f"Erreur inattendue : {str(e)}"}
--------------------------------------------------------------------------------
/utils/slideshow_manager.py:
--------------------------------------------------------------------------------
1 | import os
2 | import signal
3 | import psutil
4 | import subprocess, sys
5 | import time
6 | from .display_manager import set_display_power
7 | from .config_manager import load_config
8 |
9 | PID_FILE = "/tmp/pimmich_slideshow.pid"
10 | _log_files = {} # Dictionnaire pour garder les références aux fichiers de log ouverts
11 |
12 | def is_slideshow_running():
13 | if not os.path.exists(PID_FILE):
14 | return False
15 | try:
16 | with open(PID_FILE, "r") as f:
17 | pid = int(f.read().strip())
18 | if not psutil.pid_exists(pid):
19 | return False
20 | p = psutil.Process(pid)
21 | return p.is_running() and any("local_slideshow.py" in s for s in p.cmdline())
22 | except (psutil.NoSuchProcess, FileNotFoundError, ValueError):
23 | return False
24 |
25 | def start_slideshow():
26 | # Nettoyage si un ancien fichier PID existe sans process actif
27 | if os.path.exists(PID_FILE):
28 | try:
29 | with open(PID_FILE, "r") as f:
30 | pid = int(f.read())
31 | if not psutil.pid_exists(pid):
32 | os.remove(PID_FILE)
33 | except Exception:
34 | pass
35 |
36 | # Vérifie si un slideshow est déjà en cours
37 | if is_slideshow_running():
38 | return
39 |
40 | # Préparer l’environnement Wayland/Sway
41 |
42 | # Utiliser le même exécutable python que celui qui lance l'application web
43 | # pour garantir que le diaporama s'exécute dans le même environnement (venv).
44 | python_executable = sys.executable
45 | # Lance le diaporama
46 | stdout_log = open("logs/slideshow_stdout.log", "a")
47 | stderr_log = open("logs/slideshow_stderr.log", "a")
48 | proc = subprocess.Popen([python_executable, "-u", "local_slideshow.py"], stdout=stdout_log, stderr=stderr_log, env=os.environ.copy())
49 |
50 | # Sauvegarde le PID du nouveau processus
51 | with open(PID_FILE, "w") as f:
52 | f.write(str(proc.pid))
53 |
54 | # Garder une référence aux fichiers de log pour qu'ils ne soient pas fermés
55 | _log_files[proc.pid] = (stdout_log, stderr_log)
56 |
57 | def _stop_process_by_pid(pid):
58 | """Helper function to stop a process and close its log files."""
59 | if psutil.pid_exists(pid):
60 | print(f"Arrêt du processus de diaporama {pid}...")
61 | p = psutil.Process(pid)
62 | p.terminate()
63 | try:
64 | p.wait(timeout=3)
65 | except psutil.TimeoutExpired:
66 | print(f"Le processus {pid} n'a pas répondu, forçage de l'arrêt.")
67 | p.kill()
68 | # Fermer et supprimer les références aux fichiers de log
69 | if pid in _log_files:
70 | for log_file in _log_files[pid]:
71 | if not log_file.closed: log_file.close()
72 | del _log_files[pid]
73 |
74 | def stop_slideshow():
75 | """Arrête le processus du diaporama de manière robuste, en attendant sa terminaison."""
76 | config = load_config()
77 | is_smart_plug_enabled = config.get("smart_plug_enabled", False)
78 |
79 | # Si une prise connectée est utilisée, on arrête d'abord le diaporama
80 | # avant de couper l'alimentation de l'écran.
81 | # Sinon, on arrête juste le diaporama et on laisse set_display_power gérer le DPMS.
82 |
83 | if os.path.exists(PID_FILE):
84 | try:
85 | with open(PID_FILE, "r") as f:
86 | pid = int(f.read().strip())
87 | _stop_process_by_pid(pid)
88 | except (IOError, ValueError, psutil.NoSuchProcess) as e:
89 | print(f"Avertissement lors de l'arrêt du diaporama : {e}")
90 | finally:
91 | # S'assurer que le fichier PID est supprimé
92 | if os.path.exists(PID_FILE):
93 | os.remove(PID_FILE)
94 |
95 | # Double sécurité : tuer tous les processus restants qui pourraient être des zombies
96 | for proc in psutil.process_iter(attrs=["pid", "cmdline"]):
97 | try:
98 | if proc.info["cmdline"] and any("local_slideshow.py" in part for part in proc.info["cmdline"]):
99 | print(f"Nettoyage d'un processus de diaporama zombie trouvé (PID: {proc.pid}).")
100 | proc.kill()
101 | except (psutil.NoSuchProcess, psutil.AccessDenied):
102 | continue
103 |
104 | # Éteindre l’écran proprement (via prise ou DPMS)
105 | set_display_power(on=False)
106 |
107 | def restart_slideshow_for_update():
108 | """
109 | Redémarre le diaporama après une mise à jour de contenu, sans éteindre l'écran.
110 | C'est la fonction à utiliser par les workers de mise à jour automatique.
111 | """
112 | print("[Slideshow Manager] Redémarrage du diaporama pour mise à jour de contenu.")
113 |
114 | # 1. Arrêter le processus existant (sans appeler set_display_power)
115 | if os.path.exists(PID_FILE):
116 | try:
117 | with open(PID_FILE, "r") as f: pid = int(f.read().strip())
118 | _stop_process_by_pid(pid)
119 | if os.path.exists(PID_FILE): os.remove(PID_FILE)
120 | except Exception as e:
121 | print(f"Avertissement lors de l'arrêt pour mise à jour : {e}")
122 |
123 | # 2. Démarrer un nouveau processus
124 | start_slideshow()
125 |
126 | def restart_slideshow_process():
127 | """
128 | Redémarre uniquement le processus du diaporama, sans affecter l'alimentation de l'écran.
129 | Idéal pour appliquer les changements de configuration sans cycle de redémarrage complet.
130 | """
131 | print("[Slideshow Manager] Redémarrage du processus de diaporama demandé.")
132 |
133 | # 1. Arrêter le processus existant (sans appeler set_display_power)
134 | if os.path.exists(PID_FILE):
135 | with open(PID_FILE, "r") as f: pid = int(f.read().strip())
136 | _stop_process_by_pid(pid)
137 | if os.path.exists(PID_FILE):
138 | try:
139 | os.remove(PID_FILE)
140 | except OSError as e:
141 | print(f"Avertissement: Impossible de supprimer le fichier PID : {e}")
142 |
143 | # Afficher un message de redémarrage sur l'écran
144 | try:
145 | python_executable = sys.executable
146 | message = "Redémarrage du diaporama..."
147 | # Utiliser Popen pour ne pas bloquer, et s'assurer que l'environnement est correct
148 | env = os.environ.copy()
149 | if "SWAYSOCK" not in env:
150 | user_id = os.getuid()
151 | socks = glob.glob(f"/run/user/{user_id}/sway-ipc.*")
152 | if socks: env["SWAYSOCK"] = socks[0]
153 | subprocess.Popen([python_executable, "utils/display_message.py", message], env=env)
154 | time.sleep(1) # Laisser le temps au message de s'afficher
155 | except Exception as e:
156 | print(f"Avertissement: Impossible d'afficher le message de redémarrage : {e}")
157 |
158 | # 2. Démarrer un nouveau processus
159 | start_slideshow()
160 |
--------------------------------------------------------------------------------
/static/styles.css:
--------------------------------------------------------------------------------
1 | /* styles.css - Version nettoyée */
2 |
3 | /* --- Styles Généraux --- */
4 | body {
5 | font-family: Arial, sans-serif;
6 | margin: 0;
7 | padding: 0;
8 | background: url('/static/background.png') no-repeat center center fixed;
9 | background-size: cover;
10 | }
11 |
12 | .container {
13 | max-width: 1200px; /* Largeur max pour desktop */
14 | margin: 40px auto;
15 | padding: 2rem;
16 | background: rgba(255, 255, 255, 0.7);
17 | backdrop-filter: blur(10px);
18 | -webkit-backdrop-filter: blur(10px);
19 | border-radius: 16px;
20 | box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
21 | position: relative; /* Pour le positionnement du lien de déconnexion */
22 | }
23 |
24 | .logo {
25 | display: block;
26 | margin: 0 auto 20px;
27 | height: 80px;
28 | }
29 |
30 | h2 {
31 | text-align: center;
32 | margin-bottom: 30px;
33 | color: #333;
34 | }
35 |
36 | /* --- Formulaires --- */
37 | form {
38 | display: flex;
39 | flex-direction: column;
40 | gap: 15px;
41 | }
42 |
43 | fieldset {
44 | border: 1px solid #ccc;
45 | border-radius: 8px;
46 | padding: 15px;
47 | margin-top: 20px;
48 | background-color: #f0f0f0;
49 | }
50 |
51 | legend {
52 | font-weight: 700;
53 | padding: 0 10px;
54 | color: #333;
55 | }
56 |
57 |
58 | .tabcontent input[type="number"],
59 | .tabcontent input[type="password"],
60 | .tabcontent input[type="text"],
61 | .tabcontent input[type="time"],
62 | .tabcontent input[type="url"],
63 | .tabcontent select {
64 | padding: 10px;
65 | border-radius: 5px;
66 | border: 1px solid #ccc;
67 | width: 100%;
68 | margin-top: 5px;
69 | box-sizing: border-box;
70 | font-size: 1rem;
71 | height: 40px;
72 | }
73 |
74 | button {
75 | margin-top: 15px;
76 | padding: 10px 15px;
77 | background-color: #2b2e83;
78 | color: #fff;
79 | font-weight: 700;
80 | border: none;
81 | border-radius: 6px;
82 | width: 100%;
83 | cursor: pointer;
84 | font-size: 1rem;
85 | transition: background-color 0.3s ease;
86 | }
87 |
88 | button:hover {
89 | background-color: #1c1f5e;
90 | }
91 |
92 | /* Styles spécifiques pour les boutons qui doivent prendre toute la largeur */
93 | .save-button,
94 | .import-button,
95 | .system-button {
96 | width: 100%;
97 | display: block; /* S'assure qu'ils se comportent comme des éléments de bloc */
98 | }
99 |
100 | /* Règle pour les boutons "Tout supprimer" pour qu'ils s'adaptent au contenu */
101 | .delete-all-btn {
102 | width: auto; /* Revertir à la largeur naturelle du contenu */
103 | display: inline-flex; /* Maintenir l'alignement de l'icône et du texte */
104 | margin-top: 0; /* Supprimer la marge supérieure si elle est dans une ligne flex */
105 | }
106 | .save-button {
107 | background-color: #c73680;
108 | }
109 |
110 | .save-button:hover {
111 | background-color: #a62864;
112 | }
113 |
114 | .logout-link {
115 | position: absolute;
116 | top: 20px;
117 | right: 30px;
118 | font-size: 0.9em;
119 | }
120 |
121 | .logout-link a {
122 | color: #888;
123 | text-decoration: none;
124 | }
125 |
126 | .logout-link a:hover {
127 | text-decoration: underline;
128 | color: #333;
129 | }
130 |
131 | /* --- Système d'onglets --- */
132 | .tabs {
133 | display: flex;
134 | gap: 10px;
135 | margin-bottom: 20px;
136 | border-bottom: 2px solid #ccc;
137 | flex-wrap: nowrap;
138 | }
139 |
140 | .tablink {
141 | background-color: #0078d7;
142 | color: #fff;
143 | border: 1px solid #005a9e;
144 | border-bottom: none;
145 | padding: 10px 20px;
146 | cursor: pointer;
147 | font-weight: 700;
148 | border-radius: 10px 10px 0 0;
149 | outline: 0;
150 | transition: background-color 0.3s, box-shadow 0.3s;
151 | margin-top: 0; /* Annuler la marge héritée du sélecteur 'button' générique */
152 | box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
153 | }
154 |
155 | .tablink:hover {
156 | background-color: #005a9e;
157 | box-shadow: 0 4px 10px rgba(0, 0, 0, 0.3);
158 | }
159 |
160 | .tablink.active {
161 | background-color: #fff;
162 | color: #0078d7;
163 | border-bottom: 2px solid #fff;
164 | box-shadow: none;
165 | }
166 |
167 | .tabcontent {
168 | display: none;
169 | padding: 15px;
170 | border: 1px solid #ccc;
171 | border-radius: 0 8px 8px 8px;
172 | background-color: #fff;
173 | }
174 |
175 | /* --- Aperçu des photos --- */
176 | .photo-preview-section {
177 | border: 1px solid #e5e7eb;
178 | border-radius: 0.5rem;
179 | padding: 1rem;
180 | background: rgba(255, 255, 255, 0.8);
181 | backdrop-filter: blur(10px);
182 | }
183 |
184 | .photo-grid {
185 | display: grid;
186 | gap: 1rem;
187 | padding: 1rem;
188 | max-height: 70vh;
189 | overflow-y: auto;
190 | grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
191 | }
192 |
193 | .photo-tile {
194 | position: relative;
195 | display: flex;
196 | flex-direction: column;
197 | align-items: center;
198 | justify-content: center;
199 | }
200 |
201 | .photo-tile img {
202 | width: 100%;
203 | height: auto;
204 | aspect-ratio: 1;
205 | object-fit: cover;
206 | border-radius: 0.5rem;
207 | transition: transform 0.2s ease;
208 | }
209 |
210 | .photo-tile img:hover {
211 | transform: scale(1.05);
212 | }
213 |
214 | /* --- Messages de statut (pour les imports) --- */
215 | .status-message {
216 | padding: 0.5rem;
217 | margin: 0.25rem 0;
218 | border-radius: 0.375rem;
219 | font-weight: 500;
220 | display: flex;
221 | align-items: center;
222 | gap: 0.5rem;
223 | }
224 |
225 | .status-success {
226 | background-color: #dcfce7;
227 | color: #166534;
228 | border-left: 4px solid #22c55e;
229 | }
230 |
231 | .status-error {
232 | background-color: #fef2f2;
233 | color: #dc2626;
234 | border-left: 4px solid #ef4444;
235 | }
236 |
237 | .status-warning {
238 | background-color: #fef3c7;
239 | color: #d97706;
240 | border-left: 4px solid #f59e0b;
241 | }
242 |
243 | .status-info {
244 | background-color: #eff6ff;
245 | color: #2563eb;
246 | border-left: 4px solid #3b82f6;
247 | }
248 |
249 | /* --- GLightbox (visionneuse) --- */
250 | .glightbox-container {
251 | position: fixed !important;
252 | top: 50% !important;
253 | left: 50% !important;
254 | transform: translate(-50%, -50%) !important;
255 | z-index: 9999 !important;
256 | }
257 |
258 | /* --- Responsive --- */
259 | @media (max-width: 639px) {
260 | .container {
261 | width: 100%;
262 | max-width: 100%;
263 | padding: 1rem; /* Conserver un peu de padding intérieur */
264 | margin-left: 0;
265 | margin-right: 0;
266 | border-radius: 0; /* Pas de coins arrondis en plein écran */
267 | }
268 |
269 | fieldset {
270 | padding: 1rem;
271 | }
272 |
273 | input, select, button {
274 | width: 100%;
275 | margin-bottom: 0.5rem;
276 | }
277 |
278 | .tabs {
279 | flex-wrap: nowrap; /* Forcer une seule ligne pour permettre le défilement */
280 | }
281 |
282 | .tablink {
283 | flex-shrink: 0; /* Empêcher les boutons de rétrécir pour le défilement */
284 | font-size: 0.875rem;
285 | padding: 0.5rem 1rem; /* Ajuster le padding pour un meilleur espacement */
286 | }
287 |
288 | .photo-preview-section {
289 | padding: 0.5rem;
290 | max-height: 60vh;
291 | }
292 |
293 | .photo-grid {
294 | padding: 0.5rem;
295 | gap: 0.75rem;
296 | grid-template-columns: repeat(auto-fill, minmax(120px, 1fr));
297 | }
298 | }
--------------------------------------------------------------------------------
/utils/import_usb_photos.py:
--------------------------------------------------------------------------------
1 | import os
2 | import shutil
3 | import json
4 | import subprocess
5 | from pathlib import Path
6 | import tempfile
7 | import time
8 |
9 | CANCEL_FLAG = Path('/tmp/pimmich_cancel_import.flag')
10 | TARGET_DIR = Path("static/photos/usb")
11 | ALLOWED_EXTENSIONS = {".jpg", ".jpeg", ".png", ".gif"}
12 |
13 | def is_image_file(filename):
14 | return Path(filename).suffix.lower() in ALLOWED_EXTENSIONS
15 |
16 | def find_and_mount_usb():
17 | """
18 | Recherche un périphérique USB. S'il est déjà monté, retourne le point de montage.
19 | Sinon, le monte dans un répertoire temporaire et retourne ce chemin.
20 | Retourne un tuple: (chemin_montage, chemin_périphérique, a_été_monté_par_script)
21 | """
22 | try:
23 | # Utiliser lsblk pour une détection fiable, en demandant le chemin du périphérique (PATH)
24 | result = subprocess.run(
25 | ['/usr/bin/lsblk', '-J', '-o', 'NAME,MOUNTPOINT,TRAN,PATH'],
26 | capture_output=True, text=True, check=True, timeout=10
27 | )
28 | data = json.loads(result.stdout)
29 |
30 | for device in data.get('blockdevices', []):
31 | if device.get('tran') == 'usb':
32 | # Parcourir les partitions du périphérique
33 | for partition in device.get('children', []):
34 | mountpoint = partition.get('mountpoint')
35 | device_path = partition.get('path')
36 |
37 | if not device_path:
38 | continue
39 |
40 | # Cas 1: Déjà monté par le système
41 | if mountpoint:
42 | print(f"Périphérique USB trouvé et déjà monté sur : {mountpoint}")
43 | return Path(mountpoint), device_path, False
44 |
45 | # Cas 2: Non monté, on le monte nous-mêmes
46 | print(f"Périphérique USB non monté détecté : {device_path}. Tentative de montage...")
47 |
48 | # Créer un répertoire de montage temporaire
49 | temp_mount_dir = tempfile.mkdtemp(prefix="pimmich_usb_")
50 |
51 | # Monter le périphérique avec les droits sudo
52 | mount_cmd = ['sudo', '/usr/bin/mount', device_path, temp_mount_dir]
53 | subprocess.run(mount_cmd, check=True, capture_output=True, text=True, timeout=15)
54 |
55 | print(f"Périphérique {device_path} monté avec succès sur {temp_mount_dir}")
56 | return Path(temp_mount_dir), device_path, True
57 |
58 | except (FileNotFoundError, subprocess.CalledProcessError, json.JSONDecodeError, subprocess.TimeoutExpired) as e:
59 | print(f"Erreur lors de la détection USB via lsblk : {e}. Assurez-vous que 'lsblk' est installé.")
60 |
61 | return None, None, False # Retourne None si rien n'est trouvé ou en cas d'erreur
62 |
63 | def import_usb_photos():
64 | """Importe les photos depuis une clé USB, en la montant si nécessaire."""
65 | yield {"type": "progress", "stage": "SEARCHING", "percent": 5, "message": "Recherche de clés USB connectées..."}
66 | time.sleep(1)
67 |
68 | mount_path = None
69 | device_path = None
70 | mounted_by_script = False
71 |
72 | try:
73 | mount_path, device_path, mounted_by_script = find_and_mount_usb()
74 |
75 | if not mount_path:
76 | yield {"type": "error", "message": "Aucune clé USB détectée. Vérifiez la connexion et le format de la clé (ex: FAT32, exFAT)."}
77 | return
78 |
79 | yield {"type": "progress", "stage": "DETECTED", "percent": 10, "message": f"Clé USB détectée : {mount_path}"}
80 |
81 | # Vider les dossiers de destination (source et préparé) avant l'import pour éviter les mélanges.
82 | prepared_usb_dir = Path("static/prepared/usb")
83 | if TARGET_DIR.exists():
84 | shutil.rmtree(TARGET_DIR)
85 | TARGET_DIR.mkdir(parents=True, exist_ok=True)
86 | if prepared_usb_dir.exists():
87 | shutil.rmtree(prepared_usb_dir)
88 | prepared_usb_dir.mkdir(parents=True, exist_ok=True)
89 |
90 | yield {"type": "progress", "stage": "SCANNING", "percent": 15, "message": "Analyse des images sur la clé USB..."}
91 |
92 | image_files = []
93 | for root, dirs, files in os.walk(mount_path):
94 | for filename in files:
95 | if is_image_file(filename):
96 | image_files.append(Path(root) / filename)
97 |
98 | total = len(image_files)
99 | if total == 0:
100 | yield {"type": "error", "message": "Aucune image compatible trouvée sur la clé USB (formats supportés : JPG, JPEG, PNG, GIF)."}
101 | return
102 |
103 | yield {"type": "stats", "stage": "STATS", "percent": 20, "message": f"{total} images trouvées, début de l'import...", "total": total}
104 |
105 | for i, file_path in enumerate(image_files):
106 | # Vérifier si l'annulation a été demandée
107 | if CANCEL_FLAG.exists():
108 | yield {"type": "warning", "message": "Importation annulée par l'utilisateur."}
109 | return
110 |
111 | try:
112 | dest_file = TARGET_DIR / file_path.name
113 | counter = 1
114 | original_dest = dest_file
115 | while dest_file.exists():
116 | stem = original_dest.stem
117 | suffix = original_dest.suffix
118 | dest_file = TARGET_DIR / f"{stem}_{counter}{suffix}"
119 | counter += 1
120 |
121 | shutil.copy2(file_path, dest_file)
122 |
123 | percent = 20 + int(((i + 1) / total) * 60)
124 | yield {
125 | "type": "progress", "stage": "COPYING", "percent": percent,
126 | "message": f"Copie en cours... ({i + 1}/{total})",
127 | "current": i + 1, "total": total
128 | }
129 | except Exception as e:
130 | yield {"type": "warning", "message": f"Impossible de copier {file_path.name} : {str(e)}"}
131 |
132 | yield {"type": "done", "stage": "IMPORT_COMPLETE", "percent": 80, "message": f"{total} photos importées.", "total_imported": total}
133 |
134 | finally:
135 | # Cette section s'exécute toujours, même en cas d'erreur, pour nettoyer.
136 | if mounted_by_script and mount_path:
137 | yield {"type": "progress", "stage": "UNMOUNTING", "percent": 99, "message": "Démontage de la clé USB..."}
138 | time.sleep(1)
139 | try:
140 | umount_cmd = ['sudo', '/usr/bin/umount', str(mount_path)]
141 | subprocess.run(umount_cmd, check=True, capture_output=True, text=True, timeout=15)
142 | print(f"Démontage de {device_path} réussi.")
143 | # Supprimer le répertoire de montage temporaire
144 | shutil.rmtree(mount_path)
145 | print(f"Dossier de montage temporaire {mount_path} supprimé.")
146 | except Exception as e:
147 | yield {"type": "warning", "message": f"Avertissement : Impossible de démonter proprement la clé USB : {e}"}
--------------------------------------------------------------------------------
/FAQ.md:
--------------------------------------------------------------------------------
1 | # ❓ Foire Aux Questions (FAQ) - Pimmich
2 |
3 | Voici une liste de questions fréquemment posées pour vous aider à utiliser et dépanner Pimmich.
4 |
5 | ---
6 |
7 | ### Questions Générales
8 |
9 | **Q : Qu'est-ce que Pimmich ?**
10 |
11 | **R :** Pimmich est un logiciel qui transforme un Raspberry Pi en un cadre photo numérique intelligent. Il peut afficher des photos depuis un serveur [Immich](https://immich.app/), une clé USB, un partage réseau (Samba/Windows), un smartphone ou même via l'application de messagerie Telegram.
12 |
13 | **Q : De quoi ai-je besoin pour utiliser Pimmich ?**
14 |
15 | **R :** Il vous faut :
16 | - Un Raspberry Pi (modèle 3, 4 ou 5 recommandé) avec son alimentation.
17 | - Une carte SD avec Raspberry Pi OS (64-bit) installé.
18 | - Un écran.
19 | - Une connexion Internet (Wi-Fi ou Ethernet).
20 |
21 | ---
22 |
23 | ### Installation et Configuration
24 |
25 | **Q : Comment installer Pimmich ?**
26 |
27 | **R :** L'installation est conçue pour être simple :
28 | 1. Clonez le dépôt GitHub : `git clone https://github.com/gotenash/pimmich.git`
29 | 2. Allez dans le dossier : `cd pimmich`
30 | 3. Rendez le script d'installation exécutable : `chmod +x setup.sh`
31 | 4. Lancez le script avec les droits d'administrateur : `sudo ./setup.sh`
32 | Le script s'occupe d'installer toutes les dépendances et de configurer le système pour un démarrage automatique.
33 |
34 | **Q : Comment accéder à l'interface de configuration ?**
35 |
36 | **R :** Une fois le Raspberry Pi démarré, ouvrez un navigateur web sur un autre appareil (ordinateur, smartphone) connecté au même réseau et tapez simplement l'adresse IP de votre Raspberry Pi. Par exemple : `http://192.168.1.25`. Si vous ne connaissez pas l'IP, elle est souvent affichée sur l'écran du cadre au premier démarrage ou si aucune photo n'est trouvée.
37 |
38 | **Q : J'ai oublié mon mot de passe pour l'interface web. Comment le réinitialiser ?**
39 |
40 | **R :** La méthode la plus simple pour regénérer un mot de passe est de relancer une partie du script d'installation.
41 | 1. Connectez-vous en SSH à votre Raspberry Pi.
42 | 2. Supprimez l'ancien fichier d'identifiants avec la commande : `sudo rm /boot/firmware/credentials.json`
43 | 3. Allez dans le dossier du projet : `cd pimmich`
44 | 4. Relancez le script d'installation : `sudo ./setup.sh`
45 |
46 | Le script est conçu pour être relancé sans risque. Il détectera l'absence du fichier d'identifiants et en créera un nouveau. Le nouveau mot de passe sera affiché directement dans le terminal à la fin du processus. Pensez à le noter !
47 |
48 | **Q : Comment obtenir un Token API Immich ?**
49 |
50 | **R :**
51 | 1. Connectez-vous à votre interface web Immich.
52 | 2. Allez dans "Paramètres du compte" (via votre icône de profil).
53 | 3. Dans la section "Clés API", cliquez sur "Générer une nouvelle clé API".
54 | 4. Donnez-lui un nom (ex: "Pimmich") et copiez la clé générée.
55 |
56 | *Conseil :* Pour plus de sécurité, créez un utilisateur Immich dédié pour le cadre avec un accès limité à un seul album partagé.
57 |
58 | ---
59 |
60 | ### Fonctionnalités
61 |
62 | **Q : Comment fonctionne la fonction Telegram ?**
63 |
64 | **R :** Elle vous permet, ainsi qu'à des invités, d'envoyer des photos directement sur le cadre.
65 | 1. **Créez un bot** sur Telegram en parlant à `@BotFather`. Il vous donnera un **Token**.
66 | 2. **Obtenez votre ID utilisateur** Telegram en parlant à un bot comme `@userinfobot`.
67 | 3. Entrez ces deux informations dans l'onglet "Telegram" de Pimmich.
68 | 4. Vous pouvez ensuite créer des liens d'invitation sécurisés et temporaires pour vos proches.
69 |
70 | **Q : À quoi sert l'onglet "Favoris" ?**
71 |
72 | **R :** En marquant une photo comme favorite (via l'icône étoile dans l'onglet "Aperçu"), vous augmentez sa fréquence d'apparition dans le diaporama. Vous pouvez régler le "facteur de boost" dans l'onglet "Affichage" pour qu'elles apparaissent plus ou moins souvent.
73 |
74 | **Q : Qu'est-ce que l'effet "Carte Postale" ?**
75 |
76 | **R :** C'est un filtre qui ajoute un cadre blanc et un espace pour une légende (si vous en ajoutez une via l'interface) à vos photos, leur donnant un aspect de carte postale. Les photos envoyées via Telegram utilisent cet effet par défaut pour un rendu plus personnel et chaleureux.
77 |
78 | **Q : Quelles sont les commandes vocales disponibles ?**
79 |
80 | **R :** Une fois le contrôle vocal activé, commencez toutes vos commandes par le mot-clé **"Cadre Magique"**. Voici les commandes principales :
81 |
82 | * **Contrôle du Diaporama :**
83 | * *"photo suivante"* / *"photo précédente"*
84 | * *"pause"* / *"lecture"* (pour mettre en pause ou reprendre)
85 | * **Gestion de l'Affichage :**
86 | * *"règle la durée à 15 secondes"*
87 | * *"affiche pendant 30 secondes"*
88 | * **Gestion des Playlists & Sources :**
89 | * *"lance la playlist Vacances"*
90 | * *"afficher les cartes postales"* (lance un diaporama des photos Telegram)
91 | * *"activer la source Samba"* / *"désactiver la source USB"*
92 | * **Contrôle du Système :**
93 | * *"passer en mode veille"* (éteint l'écran)
94 | * *"réveiller le cadre"* (rallume l'écran)
95 | * *"éteindre le cadre"* (éteint complètement le Raspberry Pi)
96 | * *"revenir au diaporama principal"* (quitte une playlist en cours et relance le diaporama normal)
97 |
98 | ---
99 |
100 | ### Dépannage (Troubleshooting)
101 |
102 | **Q : J'ai un problème, où puis-je trouver de l'aide ?**
103 |
104 | **R :** L'onglet **Système** est le meilleur endroit pour commencer. Il contient une section **Logs**.
105 | - `app.py` contient les logs du serveur web (interface de configuration).
106 | - `local_slideshow_stdout` et `local_slideshow_stderr` contiennent les logs du diaporama lui-même. Les erreurs s'afficheront le plus souvent dans `stderr`.
107 |
108 | **Q : Mon écran ne s'éteint pas complètement, il reste rétro-éclairé. Que faire ?**
109 |
110 | **R :** Certains écrans ne répondent pas correctement à la commande de mise en veille logicielle (DPMS). La solution la plus fiable est d'utiliser une prise connectée Wi-Fi pour couper physiquement l'alimentation de l'écran. Pimmich intègre une fonctionnalité pour piloter ces prises. Allez dans l'onglet `Affichage`, activez l'option "Prise Connectée" et renseignez les URLs pour allumer et éteindre votre prise. De nombreuses prises (Tasmota, Shelly, Kasa, etc.) peuvent être contrôlées par de simples requêtes HTTP.
111 |
112 | **Q : Les vidéos ne sont pas fluides ou ne s'affichent pas. Que faire ?**
113 |
114 | **R :** Dans l'onglet **Affichage**, essayez d'activer l'option "**Activer le décodage vidéo matériel**". C'est beaucoup plus performant, surtout sur Raspberry Pi. Si cela cause des problèmes (écran noir/bleu après une vidéo), désactivez-la.
115 |
116 | **Q : Le Wi-Fi ne se connecte pas, mais l'Ethernet (câble) fonctionne. Pourquoi ?**
117 |
118 | **R :** Parfois, si un câble Ethernet est branché, le système lui donne la priorité. Dans l'onglet **Système**, vous pouvez essayer de désactiver temporairement l'interface "**Interface Filaire (eth0)**" pour forcer le système à utiliser exclusivement le Wi-Fi.
119 |
120 | **Q : Comment mettre à jour Pimmich ?**
121 |
122 | **R :** Allez dans l'onglet **Système** et cliquez sur le bouton "**Vérifier les mises à jour**". Pimmich se chargera de télécharger la dernière version depuis GitHub et de redémarrer automatiquement.
123 |
124 | **Q : J'ai modifié une configuration mais rien ne change sur le diaporama.**
125 |
126 | **R :** Certaines modifications, notamment celles liées à l'affichage (police, météo, etc.), nécessitent un redémarrage du diaporama pour être prises en compte. Vous pouvez le faire depuis l'onglet **Actions** en cliquant sur "Arrêter" puis "Démarrer le diaporama". Pour les changements plus profonds, un redémarrage de l'application web ou du système (depuis l'onglet **Système**) peut être nécessaire.
--------------------------------------------------------------------------------
/utils/telegram_bot.py:
--------------------------------------------------------------------------------
1 | import logging
2 | from pathlib import Path
3 | from telegram import Update
4 | from telegram.ext import Application, MessageHandler, filters, ContextTypes, CommandHandler
5 | from telegram import constants
6 | import asyncio
7 | import re
8 |
9 | # Configure logging
10 | logging.basicConfig(
11 | format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
12 | level=logging.INFO
13 | )
14 | logger = logging.getLogger(__name__)
15 |
16 | class PimmichBot:
17 | """
18 | Encapsulates the Telegram bot logic for Pimmich.
19 | Handles user authorization, photo reception, and invitation codes.
20 | """
21 | def __init__(self, token, authorized_users_str, guest_users, photo_callback, validation_callback):
22 | self.token = token
23 | try:
24 | self.authorized_users = {int(uid.strip()) for uid in authorized_users_str.split(',') if uid.strip().isdigit()}
25 | except (ValueError, TypeError):
26 | self.authorized_users = set()
27 | logger.warning("Could not parse telegram_authorized_users. No admin will be set.")
28 |
29 | self.guest_users = {int(uid): name for uid, name in guest_users.items()}
30 | self.photo_callback = photo_callback
31 | self.validation_callback = validation_callback
32 |
33 | # Build the application
34 | self.app = Application.builder().token(self.token).build()
35 | self._register_handlers()
36 |
37 | def _register_handlers(self):
38 | """Registers all the command and message handlers for the bot."""
39 | self.app.add_handler(CommandHandler(["start", "help"], self.start_command_handler))
40 | self.app.add_handler(MessageHandler(filters.PHOTO, self.photo_handler))
41 | self.app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self.text_message_handler))
42 | # A fallback for any other message type
43 | self.app.add_handler(MessageHandler(~filters.COMMAND & ~filters.PHOTO & ~filters.TEXT, self.unsupported_message_handler))
44 |
45 | def _is_user_authorized(self, user_id):
46 | """Checks if a user is either an admin or an authorized guest."""
47 | return user_id in self.authorized_users or user_id in self.guest_users
48 |
49 | def _get_user_display_name(self, user):
50 | """Gets the display name for a user, preferring the guest name if available."""
51 | if user.id in self.guest_users:
52 | return self.guest_users[user.id]
53 | return user.first_name
54 |
55 | async def start_command_handler(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
56 | """Handles the /start and /help commands, including invitation code validation."""
57 | user = update.effective_user
58 |
59 | # Case 1: The /start command includes an invitation code (e.g., /start MyCode123)
60 | if context.args:
61 | code = context.args[0]
62 | logger.info(f"User {user.id} ({user.first_name}) is attempting to use invitation code: {code}")
63 | # The validation callback is a sync function from app.py
64 | result = self.validation_callback(code, user.id, user.first_name)
65 | await update.message.reply_text(result['message'])
66 | # If validation was successful, update the bot's internal guest list
67 | if result.get('success'):
68 | self.guest_users[user.id] = result.get('guest_name', user.first_name)
69 | return
70 |
71 | # Case 2: The user is already authorized
72 | if self._is_user_authorized(user.id):
73 | display_name = self._get_user_display_name(user)
74 | help_text = (
75 | f"👋 Bonjour {display_name} !\n\n"
76 | "Je suis le bot du cadre photo Pimmich. Voici comment m'utiliser :\n\n"
77 | "1️⃣ *Envoyez-moi une photo* pour l'afficher sur le cadre.\n"
78 | "2️⃣ *Ajoutez une légende* à votre photo pour qu'elle s'affiche en dessous.\n\n"
79 | "C'est tout ! Vos souvenirs apparaîtront comme par magie. ✨"
80 | )
81 | await update.message.reply_text(help_text, parse_mode=constants.ParseMode.MARKDOWN)
82 | # Case 3: The user is not authorized and did not provide a code
83 | else:
84 | logger.warning(f"Unauthorized user {user.id} ({user.first_name}) tried to use the bot.")
85 | unauthorized_text = (
86 | "🚫 Bonjour ! Pour envoyer des photos, vous avez besoin d'un code d'invitation.\n\n"
87 | "Veuillez demander le code à l'administrateur du cadre et envoyez-le moi directement, "
88 | "ou utilisez le lien d'invitation."
89 | )
90 | await update.message.reply_text(unauthorized_text)
91 |
92 | async def photo_handler(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
93 | """Handles photo messages from authorized users."""
94 | user = update.effective_user
95 |
96 | if not self._is_user_authorized(user.id):
97 | logger.warning(f"Unauthorized user {user.id} ({user.first_name}) tried to send a photo.")
98 | await update.message.reply_text("🚫 Désolé, vous n'êtes pas autorisé à envoyer de photos.")
99 | return
100 |
101 | display_name = self._get_user_display_name(user)
102 | await update.message.reply_text("📬 Photo bien reçue ! Traitement en cours...")
103 |
104 | try:
105 | photo = update.message.photo[-1] # Highest resolution
106 | caption = update.message.caption or ""
107 |
108 | temp_dir = Path("cache/telegram_temp")
109 | temp_dir.mkdir(exist_ok=True)
110 | temp_photo_path = temp_dir / f"{user.id}_{photo.file_unique_id}.jpg"
111 |
112 | photo_file = await photo.get_file()
113 | await photo_file.download_to_drive(str(temp_photo_path))
114 | logger.info(f"Photo from {display_name} ({user.id}) downloaded to {temp_photo_path}")
115 |
116 | # Call the synchronous callback in a separate thread to avoid blocking the event loop
117 | loop = asyncio.get_running_loop()
118 | await loop.run_in_executor(None, self.photo_callback, str(temp_photo_path), caption, display_name)
119 |
120 | await update.message.reply_text("✅ Votre photo a été ajoutée au cadre !")
121 | except Exception as e:
122 | logger.error(f"Error processing photo from {user.id}: {e}", exc_info=True)
123 | await update.message.reply_text(f"❌ Oups, une erreur est survenue lors du traitement de votre photo. L'administrateur a été notifié.")
124 |
125 | async def text_message_handler(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
126 | """Handles plain text messages, checking for potential invitation codes."""
127 | user = update.effective_user
128 | message_text = update.message.text.strip()
129 |
130 | # If user is already authorized, just give a helpful message
131 | if self._is_user_authorized(user.id):
132 | await update.message.reply_text("📷 Pour ajouter une photo, il suffit de me l'envoyer directement ! Vous pouvez y ajouter une légende.")
133 | return
134 |
135 | # If user is not authorized, treat the message as a potential invitation code
136 | logger.info(f"Potential invitation code '{message_text}' received from user {user.id} ({user.first_name}).")
137 | result = self.validation_callback(message_text, user.id, user.first_name)
138 | await update.message.reply_text(result['message'])
139 |
140 | # If validation was successful, update the bot's internal guest list
141 | if result.get('success'):
142 | self.guest_users[user.id] = result.get('guest_name', user.first_name)
143 |
144 | async def unsupported_message_handler(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
145 | """Handles any message type that is not a command, photo, or text."""
146 | user = update.effective_user
147 | if self._is_user_authorized(user.id):
148 | await update.message.reply_text("🤔 Je ne sais pas quoi faire avec ça. Essayez de m'envoyer une photo !")
149 | else:
150 | await update.message.reply_text("🚫 Pour commencer, veuillez m'envoyer votre code d'invitation.")
151 |
152 | def run(self):
153 | """
154 | Lance le bot en mode polling.
155 | Désactive les gestionnaires de signaux (stop_signals=None) car le bot tourne
156 | dans un thread secondaire, ce qui est nécessaire pour éviter une erreur au démarrage.
157 | """
158 | print("🤖 Bot Telegram Pimmich actif. En attente de messages...")
159 | self.app.run_polling(stop_signals=None)
--------------------------------------------------------------------------------
/setup.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | echo "=== [1/12] Mise à jour de la liste des paquets (apt update) ==="
4 | sudo apt update
5 |
6 |
7 | echo "=== [2/12] Installation des dépendances ==="
8 | # Remplacement de libatlas-base-dev (obsolète sur Debian 12+) par libopenblas-dev pour la compilation de numpy.
9 | if ! sudo apt install -y sway xterm python3 python3-venv python3-pip libjpeg-dev libopenjp2-7-dev libtiff-dev libopenblas-dev ffmpeg git cifs-utils smbclient network-manager jq mpv gettext portaudio19-dev unzip; then
10 | echo "L'installation avec portaudio19-dev a échoué. Tentative avec libportaudio-dev..."
11 | # Fallback pour les futures versions de Debian/Raspberry Pi OS où le paquet pourrait être renommé
12 | sudo apt install -y sway xterm python3 python3-venv python3-pip libjpeg-dev libopenjp2-7-dev libtiff-dev libopenblas-dev ffmpeg git cifs-utils smbclient network-manager jq mpv gettext libportaudio-dev unzip
13 | fi
14 |
15 |
16 | echo "=== [3/12] Désactivation de l'économie d'énergie Wi-Fi ==="
17 | # Installation conditionnelle de RPi.GPIO (pour le ventilateur)
18 | if [ -f "/etc/os-release" ]; then
19 | source /etc/os-release
20 | if [[ "$ID" == "raspbian" || "$ID" == "debian" ]]; then
21 | echo "Détection de Raspberry Pi OS (ou Debian). Installation de RPi.GPIO..."
22 | sudo apt-get install -y python3-rpi.gpio
23 | fi
24 | fi
25 |
26 | CONF_FILE="/etc/NetworkManager/conf.d/99-disable-wifi-powersave.conf"
27 | if [ ! -f "$CONF_FILE" ]; then
28 | echo "Création du fichier de configuration pour désactiver l'économie d'énergie Wi-Fi..."
29 | sudo tee "$CONF_FILE" > /dev/null <<'EOL'
30 | [connection]
31 | wifi.powersave = 2
32 | EOL
33 | echo "✅ Économie d'énergie Wi-Fi désactivée. Redémarrage de NetworkManager..."
34 | sudo systemctl restart NetworkManager
35 | sleep 2 # Petite pause pour laisser le service redémarrer
36 | else
37 | echo "✅ L'économie d'énergie Wi-Fi est déjà désactivée."
38 | fi
39 |
40 | echo "=== [4/12] Configuration automatique du fuseau horaire ==="
41 | DETECTED_TIMEZONE="UTC" # Valeur par défaut
42 | TIMEZONE_SOURCE="fallback" # Source par défaut
43 |
44 | echo "Tentative de détection du fuseau horaire via l'adresse IP publique..."
45 | # Utilise l'API ip-api.com et l'outil jq pour extraire le fuseau horaire
46 | TIMEZONE_FROM_API=$(curl -s http://ip-api.com/json | jq -r '.timezone')
47 |
48 | # Vérifie si la détection a réussi
49 | if [ -n "$TIMEZONE_FROM_API" ] && [ "$TIMEZONE_FROM_API" != "null" ]; then
50 | echo "Fuseau horaire détecté : $TIMEZONE_FROM_API"
51 | sudo timedatectl set-timezone "$TIMEZONE_FROM_API"
52 | DETECTED_TIMEZONE="$TIMEZONE_FROM_API"
53 | TIMEZONE_SOURCE="auto"
54 | echo "✅ Fuseau horaire configuré automatiquement. Heure actuelle : $(date)"
55 | else
56 | echo "⚠️ La détection automatique a échoué. Le fuseau horaire sera réglé sur UTC par défaut."
57 | sudo timedatectl set-timezone UTC
58 | echo "Vous pourrez le changer manuellement plus tard avec : sudo timedatectl set-timezone Votre/Ville"
59 | fi
60 |
61 | echo "=== [5/12] Installation et configuration de NGINX pour redirection sans :5000 ==="
62 | # Installer NGINX si ce n'est pas déjà fait
63 | if ! command -v nginx &> /dev/null; then
64 | echo "Installation de NGINX..."
65 | sudo apt install -y nginx
66 | else
67 | echo "✅ NGINX est déjà installé"
68 | fi
69 |
70 | # Supprimer la config par défaut si elle existe
71 | if [ -f /etc/nginx/sites-enabled/default ]; then
72 | sudo rm /etc/nginx/sites-enabled/default
73 | echo "⛔ Fichier de config par défaut supprimé"
74 | fi
75 |
76 | # Créer une nouvelle config pour Pimmich
77 | sudo tee /etc/nginx/sites-available/pimmich > /dev/null <<'EOL'
78 | server {
79 | listen 80;
80 | server_name _;
81 |
82 | client_max_body_size 200M;
83 |
84 | location / {
85 | proxy_pass http://127.0.0.1:5000;
86 | proxy_set_header Host \$host;
87 | proxy_set_header X-Real-IP \$remote_addr;
88 | proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
89 | proxy_set_header X-Forwarded-Proto \$scheme;
90 |
91 | # Augmenter les timeouts pour les opérations longues comme l'import de vidéos
92 | proxy_connect_timeout 600s;
93 | proxy_send_timeout 600s;
94 | proxy_read_timeout 600s;
95 | }
96 | }
97 | EOL
98 |
99 | # Activer la nouvelle config
100 | if [ ! -f /etc/nginx/sites-enabled/pimmich ]; then
101 | sudo ln -s /etc/nginx/sites-available/pimmich /etc/nginx/sites-enabled/
102 | echo "✅ Configuration Pimmich activée dans NGINX"
103 | fi
104 |
105 | # Redémarrer NGINX
106 | sudo systemctl restart nginx
107 | echo "✅ NGINX redémarré et prêt"
108 |
109 | echo "=== [6/12] Création de l’environnement Python ==="
110 | cd "$(dirname "$0")"
111 | python3 -m venv venv
112 | source venv/bin/activate
113 | pip install -r requirements.txt
114 | echo "Installation de la bibliothèque pour les QR codes..."
115 | pip install "qrcode[pil]"
116 | echo "Mise à jour de la bibliothèque pour le bot Telegram..."
117 | pip install --upgrade python-telegram-bot
118 | echo "Installation des bibliothèques pour le contrôle vocal..."
119 | pip install vosk sounddevice numpy resampy thefuzz python-Levenshtein pygame num2words
120 | echo "Réinstallation forcée de pvporcupine pour inclure les modèles de langue..."
121 | pip install --force-reinstall --no-cache-dir pvporcupine
122 | echo "Vérification manuelle et téléchargement du modèle de langue français si manquant..."
123 |
124 | SITE_PACKAGES_DIR=$(python3 -c "import site; print(site.getsitepackages()[0])")
125 | FR_MODEL_PATH="$SITE_PACKAGES_DIR/pvporcupine/lib/common/porcupine_params_fr.pv"
126 |
127 | if [ ! -f "$FR_MODEL_PATH" ]; then
128 | echo "⚠️ Le modèle de langue français est manquant. Tentative de téléchargement manuel..."
129 | FR_MODEL_URL="https://github.com/Picovoice/porcupine/raw/master/lib/common/porcupine_params_fr.pv"
130 | DEST_DIR=$(dirname "$FR_MODEL_PATH")
131 | mkdir -p "$DEST_DIR"
132 | if ! wget -q -O "$FR_MODEL_PATH" "$FR_MODEL_URL"; then
133 | echo "❌ ERREUR: Le téléchargement manuel du modèle de langue a échoué. Le contrôle vocal ne fonctionnera pas."
134 | else
135 | echo "✅ Modèle de langue français téléchargé et installé manuellement."
136 | fi
137 | else
138 | echo "✅ Le modèle de langue français est déjà présent."
139 | fi
140 |
141 | echo "=== [NOUVEAU] Téléchargement du son de notification vocale ==="
142 | SOUNDS_DIR="static/sounds"
143 | NOTIFICATION_SOUND="$SOUNDS_DIR/ding.wav"
144 | if [ ! -f "$NOTIFICATION_SOUND" ]; then
145 | echo "Son de notification non trouvé. Téléchargement..."
146 | mkdir -p "$SOUNDS_DIR"
147 | wget -q -O "$NOTIFICATION_SOUND" "https://github.com/actions/sounds/raw/main/sounds/notification.wav"
148 | echo "✅ Son de notification installé."
149 | else
150 | echo "✅ Le son de notification est déjà présent."
151 | fi
152 | echo "=== [NOUVEAU] Téléchargement du modèle de reconnaissance vocale (Vosk) ==="
153 | MODELS_DIR="models"
154 | VOSK_MODEL_DIR="$MODELS_DIR/vosk-model-small-fr-0.22"
155 | VOSK_ZIP_FILE="$MODELS_DIR/vosk-model-fr.zip"
156 |
157 | if [ ! -d "$VOSK_MODEL_DIR" ]; then
158 | echo "Le modèle Vosk n'est pas trouvé. Téléchargement..."
159 | mkdir -p "$MODELS_DIR"
160 | wget -q --show-progress -O "$VOSK_ZIP_FILE" "https://alphacephei.com/vosk/models/vosk-model-small-fr-0.22.zip"
161 | unzip -o "$VOSK_ZIP_FILE" -d "$MODELS_DIR"
162 | rm "$VOSK_ZIP_FILE"
163 | echo "✅ Modèle Vosk français installé."
164 | else
165 | echo "✅ Le modèle Vosk français est déjà présent."
166 | fi
167 | echo "=== [NOUVEAU] Téléchargement du modèle de reconnaissance vocale Anglais (Vosk) ==="
168 | VOSK_MODEL_EN_DIR="$MODELS_DIR/vosk-model-small-en-us-0.15"
169 | VOSK_ZIP_EN_FILE="$MODELS_DIR/vosk-model-en.zip"
170 |
171 | if [ ! -d "$VOSK_MODEL_EN_DIR" ]; then
172 | echo "Le modèle Vosk Anglais n'est pas trouvé. Téléchargement..."
173 | mkdir -p "$MODELS_DIR"
174 | wget -q --show-progress -O "$VOSK_ZIP_EN_FILE" "https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip"
175 | unzip -o "$VOSK_ZIP_EN_FILE" -d "$MODELS_DIR"
176 | rm "$VOSK_ZIP_EN_FILE"
177 | echo "✅ Modèle Vosk Anglais installé."
178 | else
179 | echo "✅ Le modèle Vosk Anglais est déjà présent."
180 | fi
181 |
182 | echo "=== [7/12] Création de l'arborescence des dossiers nécessaires ==="
183 | mkdir -p logs
184 | mkdir -p cache
185 | mkdir -p static/photos
186 | mkdir -p static/prepared
187 | mkdir -p static/pending_uploads
188 | mkdir -p config
189 | echo "✅ Arborescence des dossiers créée."
190 |
191 | # Corriger les permissions même si script lancé avec sudo
192 | REAL_USER=$(logname)
193 | sudo chown -R "$REAL_USER:$REAL_USER" static logs cache config
194 | chmod -R u+rwX static logs cache config
195 |
196 | echo "=== [8/12] Création du fichier d'identification sécurisé ==="
197 | CREDENTIALS_FILE="/boot/firmware/credentials.json"
198 |
199 | if [ ! -f "$CREDENTIALS_FILE" ]; then
200 | echo "Génération d'un mot de passe aléatoire et création du fichier d'identification..."
201 | # On utilise sudo pour exécuter le script python qui a besoin des droits pour écrire dans /boot/firmware
202 | # Le script python est exécuté via l'interpréteur de l'environnement virtuel pour avoir accès à werkzeug.
203 | # Le script affichera lui-même le mot de passe généré.
204 | sudo venv/bin/python3 utils/create_initial_user.py --output "$CREDENTIALS_FILE"
205 | else
206 | echo "✅ Le fichier d'identification $CREDENTIALS_FILE existe déjà. Aucune modification."
207 | fi
208 |
209 | echo "=== [9/12] Configuration du démarrage en mode console (CLI) ==="
210 | sudo raspi-config nonint do_boot_behaviour B2
211 | echo "✅ Système configuré pour démarrer en mode console avec auto-login."
212 |
213 |
214 | echo "=== [10/12] Configuration du lancement automatique de Sway ==="
215 | BASH_PROFILE="/home/pi/.bash_profile"
216 | if ! grep -q 'exec sway' "$BASH_PROFILE"; then
217 | echo 'if [[ -z $DISPLAY ]] && [[ $(tty) = /dev/tty1 ]]; then' >> "$BASH_PROFILE"
218 | echo ' exec sway' >> "$BASH_PROFILE"
219 | echo 'fi' >> "$BASH_PROFILE"
220 | echo "Ajout du démarrage automatique de Sway dans $BASH_PROFILE"
221 | else
222 | echo "✅ Sway déjà configuré pour se lancer automatiquement"
223 | fi
224 |
225 | echo "=== [11/12] Configuration du lancement automatique de Pimmich dans Sway ==="
226 | SWAY_CONFIG_DIR="/home/pi/.config/sway"
227 | SWAY_CONFIG_FILE="$SWAY_CONFIG_DIR/config"
228 | mkdir -p "$SWAY_CONFIG_DIR"
229 |
230 | # Rendre exécutable
231 | chmod +x /home/pi/pimmich/start_pimmich.sh
232 |
233 | # Ajout de l'exec_always si absent
234 | if ! grep -q 'start_pimmich.sh' "$SWAY_CONFIG_FILE" 2>/dev/null; then
235 | echo 'exec_always --no-startup-id /home/pi/pimmich/start_pimmich.sh' >> "$SWAY_CONFIG_FILE"
236 | echo "Ajout de start_pimmich.sh dans la config sway"
237 | else
238 | echo "✅ start_pimmich.sh déjà présent dans la config sway"
239 | fi
240 |
241 | echo "=== [12/12] Installation terminée ==="
242 | echo "✅ Installation terminée. Redémarrez pour lancer automatiquement Sway + Pimmich."
243 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # 🖼️ Pimmich – Cadre photo connecté intelligent
2 |
3 | Pimmich est une application Python conçue pour transformer un Raspberry Pi en un cadre photo numérique intelligent et personnalisable. Il peut afficher des photos depuis de multiples sources, être contrôlé à la voix, et bien plus encore.
4 |
5 |
49 |
50 |
51 |
75 |
86 |
50 |
51 |
75 |
76 | {{ _('Envoyer des photos (Invité)') }}
77 |
78 |
85 |
6 |
7 | ---
8 |
9 | ## 📖 Table des matières
10 |
11 | - [✨ Fonctionnalités Principales](#-fonctionnalités-principales)
12 | - [🧰 Technologies utilisées](#-technologies-utilisées)
13 | - [🚀 Installation](#-installation)
14 | - [🔧 Configuration](#-configuration)
15 | - [🗣️ Contrôle Vocal](#️-contrôle-vocal)
16 | - [❓ Dépannage (FAQ)](#-dépannage-faq)
17 | - [🛣️ Feuille de Route](#️-feuille-de-route)
18 | - [Juin 2025](#-juin-2025-)
19 | - [Juillet 2025](#-juillet-2025---version-actuelle)
20 | - [Août 2025](#️-août-2025----sortie-prévue-le-15-aoüt)
21 | - [💖 Crédits](#-crédits)
22 |
23 | ---
24 |
25 | ## ✨ Fonctionnalités Principales
26 |
27 | Pimmich est riche en fonctionnalités pour offrir une expérience complète et personnalisable :
28 |
29 | #### 🖼️ **Affichage & Diaporama**
30 | - **Multi-sources :** Affichez des photos depuis [Immich](https://immich.app/), un partage réseau (Samba/Windows), une clé USB, un smartphone ou via Telegram.
31 | - **Personnalisation avancée :** Réglez la durée d'affichage, les heures d'activité, les transitions (fondu, glissement), et activez un effet de mouvement "Pan & Zoom".
32 | - **Filtres créatifs :** Appliquez des filtres à vos photos (Noir & Blanc, Sépia, Vintage) et des effets uniques comme le **Polaroid** ou la **Carte Postale**.
33 | - **Gestion des formats :** Prise en charge intelligente des photos portraits (fond flou) et des vidéos (avec son et accélération matérielle optionnelle).
34 |
35 | #### ⚙️ **Interface & Contrôle**
36 | - **Interface Web complète :** Une page de configuration locale, sécurisée par mot de passe et organisée en onglets clairs (Diaporama, Contenu, Interactions, Maintenance).
37 | - **Contrôle Vocal :** Pilotez votre cadre avec des commandes vocales comme *"Cadre Magique, photo suivante"* ou *"Cadre Magique, lance la playlist Vacances"*.
38 | - **Gestion de contenu :**
39 | - **Playlists :** Créez des albums virtuels, réorganisez les photos par glisser-déposer et lancez des diaporamas thématiques.
40 | - **Favoris :** Marquez vos photos préférées pour qu'elles apparaissent plus souvent.
41 | - **Légendes :** Ajoutez du texte personnalisé sur vos photos et cartes postales.
42 |
43 | #### 🌐 **Connectivité & Interactions**
44 | - **Telegram :** Permettez à vos proches d'envoyer des photos sur le cadre via un bot Telegram, avec un système d'invitations sécurisé et temporaire.
45 | - **Wi-Fi & Réseau :** Configurez le Wi-Fi, scannez les réseaux et gérez les interfaces réseau directement depuis l'interface.
46 | - **Envoi depuis Smartphone :** Importez des photos directement depuis le navigateur de votre téléphone.
47 |
48 | #### 🛠️ **Maintenance & Monitoring**
49 | - **Mise à jour facile :** Mettez à jour Pimmich en un clic depuis l'interface.
50 | - **Sauvegarde & Restauration :** Sauvegardez et restaurez l'ensemble de votre configuration.
51 | - **Monitoring système :** Suivez en temps réel la température, l'utilisation du CPU, de la RAM et du disque avec des graphiques d'historique.
52 | - **Logs détaillés :** Accédez aux journaux de chaque service (serveur web, diaporama, contrôle vocal) pour un dépannage facile.
53 |
54 | ---
55 |
56 | ## 🧰 Technologies utilisées
57 |
58 | - **Backend :** Python, Flask
59 | - **Frontend :** HTML, TailwindCSS, JavaScript
60 | - **Diaporama :** Pygame
61 | - **Traitement d'image :** Pillow
62 | - **Contrôle Vocal :** Picovoice Porcupine (mot-clé) & Vosk (reconnaissance)
63 | - **Serveur Web :** NGINX (en tant que reverse proxy)
64 |
65 | ---
66 |
67 | ## 🚀 Installation
68 |
69 | Il existe deux méthodes pour installer Pimmich.
70 |
71 | ### Méthode 1 : Image pré-configurée (Recommandée et plus simple)
72 |
73 | Cette méthode est idéale pour une première installation rapide.
74 |
75 | 1. **Téléchargez l'image du mois en cours**
76 | Rendez-vous sur la page des [Releases de Pimmich](https://github.com/gotenash/pimmich/releases) et téléchargez le fichier `.img` de la dernière version.
77 |
78 | 2. **Flashez l'image sur une carte SD**
79 | Utilisez un logiciel comme Raspberry Pi Imager ou BalenaEtcher pour écrire le fichier image que vous venez de télécharger sur votre carte microSD.
80 |
81 | 3. **Démarrez votre Raspberry Pi**
82 | Insérez la carte SD dans le Raspberry Pi, branchez l'écran et l'alimentation. Pimmich démarrera automatiquement.
83 |
84 | ### Méthode 2 : Installation manuelle depuis le dépôt Git
85 |
86 | Cette méthode est destinée aux utilisateurs avancés ou à ceux qui souhaitent suivre le développement de près.
87 |
88 | #### ✅ Pré-requis
89 |
90 | - Un Raspberry Pi (modèle 3B+, 4 ou 5 recommandé) avec Raspberry Pi OS Desktop (64-bit).
91 | - Une carte SD, une alimentation, un écran.
92 | - Une connexion Internet.
93 |
94 | #### 📝 Étapes d'installation
95 |
96 | 1. **Clonez le dépôt**
97 | Ouvrez un terminal sur votre Raspberry Pi et exécutez :
98 | ```bash
99 | git clone https://github.com/gotenash/pimmich.git
100 | cd pimmich
101 | ```
102 |
103 | 2. **Lancez le script d'installation**
104 | Ce script installe toutes les dépendances, configure l'environnement et prépare le démarrage automatique.
105 | ```bash
106 | chmod +x setup.sh
107 | sudo ./setup.sh
108 | ```
109 |
110 | 3. **Redémarrez**
111 | Une fois le script terminé, un redémarrage est nécessaire pour que tous les services se lancent correctement.
112 | ```bash
113 | sudo reboot
114 | ```
115 |
116 | ---
117 |
118 | ## 🔧 Configuration
119 |
120 | ### 1. Première Connexion
121 |
122 | - Au redémarrage, le cadre affichera un QR Code et l'adresse IP du Raspberry Pi.
123 | - Scannez le QR Code ou ouvrez un navigateur sur un autre appareil (PC, smartphone) sur le même réseau et entrez l'adresse IP (ex: `http://192.168.1.XX`).
124 | - Le mot de passe initial est généré aléatoirement lors de l'installation et est stocké dans le fichier `/boot/firmware/credentials.json`. Il est fortement recommandé de le changer via l'interface (onglet `Système` > `Sécurité`).
125 |
126 | ### 2. Configuration des Sources
127 |
128 | - **Immich :** Pour connecter votre serveur Immich, vous aurez besoin de :
129 | 1. **L'URL de votre serveur** (ex: `http://192.168.1.YY:2283`).
130 | 2. **Un Token API :** Dans Immich, allez dans `Paramètres du compte` > `Clés API` > `Générer une nouvelle clé`.
131 | 3. **Le nom technique de l'album** que vous souhaitez afficher.
132 | - **Samba / Partage Windows :** Renseignez les informations de votre partage réseau.
133 | - **USB :** Branchez une clé USB et utilisez le bouton d'import dans l'onglet `Actions`.
134 |
135 | ### 3. Personnalisation
136 |
137 | Explorez les différents onglets pour personnaliser votre cadre :
138 | - **Diaporama > Affichage :** Réglez les durées, les transitions, les effets...
139 | - **Diaporama > Horloge & Infos :** Activez et configurez l'affichage de l'heure, de la météo ou des marées.
140 | - **Contenu > Sources :** Cochez les sources que vous souhaitez voir dans le diaporama.
141 |
142 | ---
143 |
144 | ## 🗣️ Contrôle Vocal
145 |
146 | Pimmich supporte le contrôle vocal en **Français** et en **Anglais**.
147 |
148 | Pour utiliser un mot-clé personnalisé ("Cadre Magique", "Magic Frame"...), une étape manuelle est requise :
149 | 1. Créez un compte gratuit sur la Picovoice Console.
150 | 2. Allez dans la section "Porcupine" et créez votre mot-clé personnalisé.
151 | 3. Téléchargez le modèle pour la plateforme **Raspberry Pi**.
152 | 4. Renommez le fichier `.ppn` téléchargé en `cadre-magique_raspberry-pi.ppn` (pour le français) ou `magic-frame_raspberry-pi_en.ppn` (pour l'anglais, exemple).
153 | 5. Placez ce fichier dans le dossier `voice_models` à la racine du projet Pimmich.
154 | 6. Dans l'interface Pimmich, allez dans l'onglet `Vocal`, sélectionnez la langue, entrez votre "Access Key" Picovoice et activez le service.
155 |
156 | ### Commandes Disponibles
157 |
158 | Une fois le contrôle vocal activé, commencez toutes vos commandes par le mot-clé **"Cadre Magique"**.
159 |
160 | **Contrôle du Diaporama :**
161 | - *"photo suivante"*
162 | - *"photo précédente"*
163 | - *"pause"* / *"lecture"* (pour mettre en pause ou reprendre)
164 |
165 | **Gestion de l'Affichage :**
166 | - *"règle la durée à 15 secondes"*
167 | - *"affiche pendant 30 secondes"*
168 |
169 | **Gestion des Playlists & Sources :**
170 | - *"lance la playlist Vacances"*
171 | - *"afficher les cartes postales"* (lance un diaporama des photos Telegram)
172 | - *"activer la source Samba"*
173 | - *"désactiver la source USB"*
174 |
175 | **Contrôle du Système :**
176 | - *"passer en mode veille"* (éteint l'écran)
177 | - *"réveiller le cadre"* (rallume l'écran)
178 | - *"éteindre le cadre"* (éteint complètement le Raspberry Pi)
179 | - *"revenir au diaporama principal"* (quitte une playlist et relance le diaporama normal)
180 |
181 | ---
182 |
183 | ## ❓ Dépannage (FAQ)
184 |
185 | Pour toute question ou problème, consultez notre **Foire Aux Questions (FAQ.md)**. Vous y trouverez des solutions aux problèmes courants (Wi-Fi, affichage, etc.) et des astuces pour utiliser Pimmich au mieux.
186 |
187 | ---
188 |
189 | ## 🛣️ Feuille de Route
190 |
191 | Voici un aperçu des fonctionnalités à venir :
192 |
193 | - **Octobre 2025 :**
194 | - 📱 Création d’une application Android "télécommande" pour contrôler le cadre.
195 | - 🔘 Gestion d'un bouton physique pour interagir avec le diaporama.
196 |
197 | - **Idées pour le futur :**
198 | - 📺 Version pour Android TV.
199 | - ☁️ Import depuis d'autres services comme Google Photos ou PhotoPrism.
200 |
201 | ---
202 |
203 | ## 💖 Crédits
204 |
205 | - **Auteurs :** Gotenash et Shenron
206 | - **Projet du :** Gadgetaulab
207 |
208 |
209 |
210 | 
211 |
212 |