pibooth-pcloud 1.0.0__py2.py3-none-any.whl

pibooth_pcloud-1.0.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: pibooth_pcloud
+Version: 1.0.0
+Summary: Pibooth plugin to upload photos to pCloud and display a QR code
+Home-page: https://github.com/ceeeeb/pibooth-pcloud
+Download-URL: https://github.com/ceeeeb/pibooth-pcloud/archive/1.0.0.tar.gz
+Author: Christophe
+License: MIT license
+Keywords: Raspberry Pi,camera,photobooth,pcloud
+Platform: unix
+Platform: linux
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Natural Language :: English
+Classifier: Topic :: Multimedia :: Graphics :: Capture :: Digital Camera
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: pibooth>=2.0.0
+Requires-Dist: qrcode>=6.1
+Requires-Dist: requests
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: summary
+
+===============
+pibooth-pcloud
+===============
+
+|PythonVersions| |License|
+
+Plugin ``pibooth-pcloud`` pour `pibooth <https://github.com/pibooth/pibooth>`_
+qui envoie automatiquement les photos finales vers un compte
+`pCloud <https://www.pcloud.com>`_ et affiche un QR code vers la galerie
+publique sur l'écran d'attente.
+
+Fonctionnalités :
+
+- Authentification par email + mot de passe (digest par appel, aucun OAuth à
+  créer côté pCloud).
+- Upload d'un album par événement (``folder_path/album_name``) et lien public
+  généré sur ce sous-dossier.
+- Synchronisation de rattrapage : au démarrage et après chaque photo, les
+  fichiers présents en local mais absents de pCloud sont envoyés, ce qui
+  absorbe les coupures Internet pendant un événement.
+
+.. note:: Une connexion internet est requise pendant l'événement (ou plus
+          tard pour rattraper les uploads).
+
+Installation
+------------
+
+::
+
+    pip install pibooth-pcloud
+
+Configuration
+-------------
+
+Vérifier les identifiants pCloud
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Le script fourni valide les identifiants et imprime le bloc à coller dans
+``~/.config/pibooth/pibooth.cfg`` :
+
+::
+
+    pibooth-pcloud-token
+
+L'email doit être vérifié côté pCloud — sans vérification, l'API refuse la
+création de liens publics.
+
+Exemple de configuration
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+Voir ``pibooth.cfg.example`` à la racine du dépôt. Bloc à ajouter dans
+``~/.config/pibooth/pibooth.cfg`` :
+
+.. code-block:: ini
+
+    [PCLOUD]
+
+    # Activer le plugin
+    activate = True
+
+    # Identifiants pCloud (stockés en clair — restreindre les droits du fichier)
+    email = your.email@example.com
+    password = your-password
+
+    # Région du compte (EU ou US)
+    region = EU
+
+    # Dossier parent sur pCloud (créé s'il n'existe pas)
+    folder_path = /Pibooth
+
+    # Sous-dossier événement sur pCloud ; le lien public cible ce sous-dossier
+    album_name = MonEvenement
+
+    # Position du QR code (top-left, top-right, bottom-left, bottom-right, center)
+    qr_position = top-right
+
+    # Taille du QR code (3-10)
+    qr_size = 5
+
+    # Marge du QR code par rapport au bord (pixels)
+    qr_margin = 10
+
+Après édition, restreindre les droits du fichier :
+
+::
+
+    chmod 600 ~/.config/pibooth/pibooth.cfg
+
+Fonctionnement
+--------------
+
+Au démarrage de pibooth :
+
+- Authentification par digest, création du dossier parent et de l'album.
+- Récupération du lien public de l'album, génération du QR code.
+- Première passe de synchronisation : les photos locales absentes de pCloud
+  sont envoyées.
+
+Après chaque photo (``state_processing_exit``) :
+
+- Synchronisation en arrière-plan : la nouvelle photo et toute photo
+  restée en retard sont envoyées. L'opération ne bloque pas l'interface.
+
+.. |PythonVersions| image:: https://img.shields.io/badge/python-3.6+-green.svg
+   :target: https://www.python.org/downloads/
+
+.. |License| image:: https://img.shields.io/badge/license-MIT-blue.svg
+   :target: https://opensource.org/licenses/MIT

pibooth_pcloud-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pibooth_pcloud.py,sha256=dooJGktirwsd0wpFvPIVCRLa2zvG18X9-sKvJNRaALE,12753
+pibooth_pcloud_token.py,sha256=jPI4q5FnLBxI7uewiRUB7L7cXs75oSPJ2RXncp0VHcM,2453
+pibooth_pcloud-1.0.0.dist-info/licenses/LICENSE,sha256=6dgyVqCDdYODzES1xSQng3QB-ku4MXaHwTdXDQxQrsA,1067
+pibooth_pcloud-1.0.0.dist-info/METADATA,sha256=C8rGpGS355YknfLl5qaDZUwsVoxTY4neQ9UD84X5p8w,4332
+pibooth_pcloud-1.0.0.dist-info/WHEEL,sha256=TdQ5LtNwLuxTCjgxN51AgdU5w-KkB9ttmLbzjTH02pg,109
+pibooth_pcloud-1.0.0.dist-info/entry_points.txt,sha256=kG4UkfOw2WJQFCYwbgDZ1xFk3hfZKTtW6WCUIbJ7HR4,110
+pibooth_pcloud-1.0.0.dist-info/top_level.txt,sha256=smhRoBNpbSZURcXRNuv-W-ltAcIRU3lEeJS7WyI8u04,36
+pibooth_pcloud-1.0.0.dist-info/RECORD,,

pibooth_pcloud-1.0.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

pibooth_pcloud-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+pibooth-pcloud-token = pibooth_pcloud_token:main
+
+[pibooth]
+pibooth_pcloud = pibooth_pcloud

pibooth_pcloud-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christophe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pibooth_pcloud-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+pibooth_pcloud
+pibooth_pcloud_token

pibooth_pcloud.py

@@ -0,0 +1,349 @@
+# -*- coding: utf-8 -*-
+
+"""Pibooth plugin for pCloud upload."""
+
+import glob
+import hashlib
+import os
+import threading
+
+import requests
+import qrcode
+import pygame
+
+import pibooth
+from pibooth.utils import LOGGER
+
+__version__ = "1.0.0"
+
+SECTION = "PCLOUD"
+
+# pCloud API hosts per region
+API_HOSTS = {
+    "US": "https://api.pcloud.com",
+    "EU": "https://eapi.pcloud.com",
+}
+
+
+def _api_url(host, method):
+    return f"{host}/{method}"
+
+
+###########################################################################
+# HOOKS pibooth
+###########################################################################
+
+
+@pibooth.hookimpl
+def pibooth_configure(cfg):
+    """Declare the plugin configuration options."""
+    cfg.add_option(SECTION, 'activate', True,
+                   "Enable upload to pCloud",
+                   "Enable upload", ['True', 'False'])
+    cfg.add_option(SECTION, 'email', '',
+                   "pCloud account email",
+                   "Email", '')
+    cfg.add_option(SECTION, 'password', '',
+                   "pCloud account password (stored in clear, chmod 600 recommended)",
+                   "Password", '')
+    cfg.add_option(SECTION, 'region', 'EU',
+                   "pCloud account region (US or EU)",
+                   "Region", ['US', 'EU'])
+    cfg.add_option(SECTION, 'folder_path', '/Pibooth',
+                   "Remote parent folder on pCloud",
+                   "Folder Path", '/Pibooth')
+    cfg.add_option(SECTION, 'album_name', 'Pibooth',
+                   "Sub-folder (event album) inside folder_path; the public link points here",
+                   "Album Name", 'Pibooth')
+    cfg.add_option(SECTION, 'qr_position', 'top-left',
+                   "QR code position (top-left, top-right, bottom-left, bottom-right, center)",
+                   "QR Position", ['top-left', 'top-right', 'bottom-left', 'bottom-right', 'center'])
+    cfg.add_option(SECTION, 'qr_size', 5,
+                   "QR code box_size (3-10)",
+                   "QR Size", '5')
+    cfg.add_option(SECTION, 'qr_margin', 10,
+                   "QR code margin from screen edge in pixels",
+                   "QR Margin", '10')
+
+
+@pibooth.hookimpl
+def pibooth_startup(app, cfg):
+    """Initialize PCloudUpload instance and create QR code."""
+    activate = cfg.getboolean(SECTION, 'activate')
+    if not activate:
+        LOGGER.info("pCloud upload is disabled")
+        app.pcloud = None
+        return
+
+    email = cfg.get(SECTION, 'email').strip()
+    password = cfg.get(SECTION, 'password')
+    if not email or not password:
+        LOGGER.warning("pCloud email or password is not configured")
+        app.pcloud = None
+        return
+
+    region = cfg.get(SECTION, 'region').upper()
+    api_host = API_HOSTS.get(region, API_HOSTS["EU"])
+    parent_path = cfg.get(SECTION, 'folder_path').strip().rstrip('/') or '/Pibooth'
+    if not parent_path.startswith('/'):
+        parent_path = '/' + parent_path
+    album_name = cfg.get(SECTION, 'album_name').strip() or 'Pibooth'
+    album_path = f"{parent_path}/{album_name}"
+
+    app.pcloud = PCloudUpload(email, password, api_host)
+    app.pcloud.qr_position = cfg.get(SECTION, 'qr_position')
+    app.pcloud.qr_size = cfg.getint(SECTION, 'qr_size')
+    app.pcloud.qr_margin = cfg.getint(SECTION, 'qr_margin')
+    app.pcloud.local_rep = cfg.get('GENERAL', 'directory')
+
+    if not app.pcloud.check_credentials():
+        LOGGER.error("pCloud authentication failed, plugin disabled")
+        app.pcloud = None
+        return
+
+    if app.pcloud.ensure_folder(parent_path) is None:
+        LOGGER.error("Cannot create pCloud folder '%s', plugin disabled", parent_path)
+        app.pcloud = None
+        return
+
+    album_id = app.pcloud.ensure_folder(album_path)
+    if album_id is None:
+        LOGGER.error("Cannot create pCloud folder '%s', plugin disabled", album_path)
+        app.pcloud = None
+        return
+
+    app.pcloud.folder_path = album_path
+    app.pcloud.folder_id = album_id
+
+    gallery_link = app.pcloud.get_folder_public_link(album_id)
+    if not gallery_link:
+        LOGGER.warning("Could not create public link, QR code will show folder path")
+        gallery_link = album_path
+
+    app.pcloud.gallery_link = gallery_link
+
+    # Generate QR code
+    qr_box_size = max(3, min(10, app.pcloud.qr_size))
+    qr = qrcode.QRCode(
+        version=1,
+        error_correction=qrcode.constants.ERROR_CORRECT_L,
+        box_size=qr_box_size,
+        border=2,
+    )
+    qr.add_data(gallery_link)
+    qr.make(fit=True)
+    image = qr.make_image(fill_color="black", back_color="white").convert('RGB')
+    image.save(os.path.join(app.pcloud.local_rep, 'QRCODE.png'), "PNG")
+    app.pcloud.qr_image = pygame.image.fromstring(
+        image.tobytes(), image.size, image.mode
+    )
+
+    LOGGER.info("pCloud plugin ready (region=%s, folder=%s)", region, album_path)
+
+    # Catch up anything left over from previous sessions (e.g. offline uploads).
+    _sync_in_background(app)
+
+
+@pibooth.hookimpl
+def state_wait_enter(cfg, app, win):
+    """Display QR code on the wait screen."""
+    if not getattr(app, 'pcloud', None):
+        return
+
+    win_rect = win.get_rect()
+    qr_rect = app.pcloud.qr_image.get_rect()
+    margin = app.pcloud.qr_margin
+    position = app.pcloud.qr_position
+
+    positions = {
+        "top-left": (margin, margin),
+        "top-right": (win_rect.width - qr_rect.width - margin, margin),
+        "bottom-left": (margin, win_rect.height - qr_rect.height - margin),
+        "bottom-right": (win_rect.width - qr_rect.width - margin,
+                         win_rect.height - qr_rect.height - margin),
+        "center": ((win_rect.width - qr_rect.width) // 2,
+                   (win_rect.height - qr_rect.height) // 2),
+    }
+    x, y = positions.get(position, (margin, margin))
+    win.surface.blit(app.pcloud.qr_image, (x, y))
+
+
+PICTURE_PATTERN = "*_pibooth.jpg"
+
+
+def _sync_in_background(app):
+    """Run a catch-up sync in a daemon thread, guarded by the upload lock."""
+    def _do_sync():
+        if not app.pcloud.upload_lock.acquire(blocking=False):
+            LOGGER.debug("pCloud sync already in progress, skipping")
+            return
+        try:
+            app.pcloud.sync_missing(
+                app.pcloud.local_rep, PICTURE_PATTERN,
+                app.pcloud.folder_path, app.pcloud.folder_id,
+            )
+        finally:
+            app.pcloud.upload_lock.release()
+
+    threading.Thread(target=_do_sync, daemon=True).start()
+
+
+@pibooth.hookimpl
+def state_processing_exit(app, cfg):
+    """Upload captured photo and catch up any missing ones (non-blocking)."""
+    if not getattr(app, 'pcloud', None):
+        return
+    _sync_in_background(app)
+
+
+###########################################################################
+# pCloud API client
+###########################################################################
+
+
+class PCloudUpload:
+
+    DIGEST_TTL = 60  # seconds — pCloud digests are short-lived, refresh often
+
+    def __init__(self, email, password, api_host):
+        self.email = email
+        self.password = password
+        self.api_host = api_host
+        self.upload_lock = threading.Lock()
+        self._digest_lock = threading.Lock()
+        self._username_sha1 = hashlib.sha1(email.lower().encode()).hexdigest()
+        self.gallery_link = ""
+        self.folder_path = ""
+        self.folder_id = 0
+        self.qr_image = None
+        self.qr_position = "top-left"
+        self.qr_size = 5
+        self.qr_margin = 10
+        self.local_rep = ""
+
+    def _fresh_auth_params(self):
+        """Fetch a new digest and compute the password digest for a single call."""
+        with self._digest_lock:
+            resp = requests.get(_api_url(self.api_host, "getdigest"), timeout=30)
+            resp.raise_for_status()
+            data = resp.json()
+            if data.get("result") != 0:
+                raise RuntimeError(f"getdigest failed: {data.get('error')}")
+            digest = data["digest"]
+        password_digest = hashlib.sha1(
+            (self.password + self._username_sha1 + digest).encode()
+        ).hexdigest()
+        return {"username": self.email, "digest": digest,
+                "passworddigest": password_digest}
+
+    def _call(self, method, params=None, files=None, timeout=30):
+        """Call a pCloud API method authenticated with a fresh digest."""
+        url = _api_url(self.api_host, method)
+        params = dict(params or {})
+
+        try:
+            params.update(self._fresh_auth_params())
+            if files:
+                resp = requests.post(url, data=params, files=files, timeout=timeout)
+            else:
+                resp = requests.get(url, params=params, timeout=timeout)
+            resp.raise_for_status()
+            data = resp.json()
+            if data.get("result") != 0:
+                LOGGER.error("pCloud API error %s: %s",
+                             data.get("result"), data.get("error", "unknown"))
+                return None
+            return data
+        except (requests.RequestException, RuntimeError) as e:
+            LOGGER.error("pCloud request failed (%s): %s", method, e)
+            return None
+
+    def check_credentials(self):
+        """Verify the email/password authenticate successfully."""
+        data = self._call("userinfo")
+        if data:
+            LOGGER.info("pCloud authenticated as %s", data.get("email", "unknown"))
+            return True
+        return False
+
+    def ensure_folder(self, path):
+        """Create the folder (and parents) if it does not exist.
+        Returns the folder ID or None on error.
+        """
+        data = self._call("createfolderifnotexists", {"path": path})
+        if data and "metadata" in data:
+            folder_id = data["metadata"]["folderid"]
+            LOGGER.info("pCloud folder ready: %s (id=%s)", path, folder_id)
+            return folder_id
+        return None
+
+    def list_folder_filenames(self, folder_id):
+        """Return the set of file names present in a remote folder."""
+        data = self._call("listfolder", {"folderid": folder_id})
+        if not data or "metadata" not in data:
+            return None
+        return {entry["name"] for entry in data["metadata"].get("contents", [])
+                if not entry.get("isfolder")}
+
+    def sync_missing(self, local_dir, pattern, remote_folder_path, folder_id):
+        """Upload local files matching pattern that are absent on pCloud.
+
+        Returns the number of files successfully uploaded.
+        """
+        if not os.path.isdir(local_dir):
+            return 0
+
+        remote_names = self.list_folder_filenames(folder_id)
+        if remote_names is None:
+            LOGGER.warning("pCloud sync: cannot list remote folder, skipping")
+            return 0
+
+        uploaded = 0
+        for local_path in sorted(glob.glob(os.path.join(local_dir, pattern))):
+            if os.path.basename(local_path) in remote_names:
+                continue
+            if self.upload_file(local_path, remote_folder_path):
+                uploaded += 1
+        if uploaded:
+            LOGGER.info("pCloud sync: %d missing file(s) uploaded", uploaded)
+        return uploaded
+
+    def get_folder_public_link(self, folder_id):
+        """Get or create a public link for the folder."""
+        data = self._call("getfolderpublink", {"folderid": folder_id})
+        if data and "link" in data:
+            LOGGER.info("pCloud public link: %s", data["link"])
+            return data["link"]
+        # Try listing existing public links
+        data = self._call("listpublinks")
+        if data and "publinks" in data:
+            for link in data["publinks"]:
+                if link.get("folderid") == folder_id:
+                    return link.get("link", "")
+        LOGGER.warning("Could not get public link for folder %s", folder_id)
+        return ""
+
+    def upload_file(self, local_path, remote_folder_path):
+        """Upload a single file to the given pCloud folder."""
+        filename = os.path.basename(local_path)
+        LOGGER.info("Uploading %s to pCloud:%s", filename, remote_folder_path)
+
+        try:
+            with open(local_path, 'rb') as f:
+                data = self._call(
+                    "uploadfile",
+                    params={"path": remote_folder_path, "filename": filename,
+                            "nopartial": 1, "renameifexists": 1},
+                    files={"file": (filename, f)},
+                    timeout=120,
+                )
+        except OSError as e:
+            LOGGER.error("Cannot read file %s: %s", local_path, e)
+            return False
+
+        if data:
+            LOGGER.info("Photo uploaded to pCloud successfully: %s", filename)
+            return True
+
+        LOGGER.error("Upload to pCloud failed for %s", filename)
+        return False

pibooth_pcloud_token.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Validate pCloud email/password and print the pibooth config block.
+
+pibooth-pcloud authenticates each API call with a fresh digest derived from
+email+password — no long-lived token. This helper just confirms the
+credentials work and formats the config block ready to paste into
+~/.config/pibooth/pibooth.cfg.
+"""
+
+import getpass
+import hashlib
+
+import requests
+
+API_HOSTS = {
+    "EU": "https://eapi.pcloud.com",
+    "US": "https://api.pcloud.com",
+}
+
+
+def main():
+    print("=" * 60)
+    print("  pibooth-pcloud - Verification des identifiants")
+    print("=" * 60)
+    print()
+
+    region = input("Region du compte (EU/US) [EU] : ").strip().upper() or "EU"
+    if region not in API_HOSTS:
+        print(f"Region invalide : {region}")
+        return
+    host = API_HOSTS[region]
+
+    email = input("Email pCloud : ").strip()
+    password = getpass.getpass("Mot de passe pCloud : ")
+    if not email or not password:
+        print("Erreur : email et mot de passe requis.")
+        return
+
+    digest_resp = requests.get(f"{host}/getdigest", timeout=30).json()
+    if digest_resp.get("result") != 0:
+        print(f"Erreur getdigest : {digest_resp.get('error')}")
+        return
+    digest = digest_resp["digest"]
+
+    username_sha1 = hashlib.sha1(email.lower().encode()).hexdigest()
+    password_digest = hashlib.sha1(
+        (password + username_sha1 + digest).encode()
+    ).hexdigest()
+
+    data = requests.get(f"{host}/userinfo", params={
+        "username": email, "digest": digest,
+        "passworddigest": password_digest,
+    }, timeout=30).json()
+
+    if data.get("result") != 0:
+        print(f"Echec : {data.get('error', 'code ' + str(data.get('result')))}")
+        return
+
+    print()
+    print("=" * 60)
+    print("  AUTHENTIFICATION REUSSIE")
+    print("=" * 60)
+    print()
+    print(f"  Compte  : {data.get('email', email)}")
+    print(f"  Region  : {region}")
+    print(f"  Plan    : {data.get('plan', '?')}")
+    print()
+    print("A ajouter dans ~/.config/pibooth/pibooth.cfg :")
+    print()
+    print("  [PCLOUD]")
+    print("  activate = True")
+    print(f"  email = {email}")
+    print(f"  password = {password}")
+    print(f"  region = {region}")
+    print("  folder_path = /Pibooth")
+    print("  qr_position = top-right")
+    print()
+    print("Puis restreindre les droits :")
+    print("  chmod 600 ~/.config/pibooth/pibooth.cfg")
+
+
+if __name__ == "__main__":
+    main()