feat(parsepy): implémenter les opérations atomiques (Issue #17)Feature/parsepy/atomic operations

.github/workflows/ci.yml

@@ -0,0 +1,41 @@
+name: CI
+
+on:
+  push:
+    branches: [ "main", "develop" ]
+  pull_request:
+    branches: [ "main", "develop" ]
+
+jobs:
+  test:
+    name: Test on Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: 'pip'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e ".[dev]"
+
+    - name: Check code style (Black)
+      run: black --check src/ tests/
+
+    - name: Lint (Ruff)
+      run: ruff check src/ tests/
+
+    - name: Type checking (Mypy)
+      run: mypy src/
+
+    - name: Run unit tests
+      run: pytest tests/unit/

.gitignore

@@ -205,3 +205,8 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+# Documents de formation / présentations — ne pas versionner dans le SDK
+*.pdf
+*.pptx
+*.docx

CONTRIBUTING.md

@@ -66,7 +66,7 @@ git --version      # git version 2.x
 
 ### 1. Forker et cloner le dépôt
 
-`````bash
+```bash
 # 1. Forkez le projet depuis GitHub (bouton "Fork" en haut à droite)
 
 # 2. Clonez votre fork localement
@@ -75,18 +75,16 @@ cd parsepy
 
 # 3. Ajoutez le dépôt original comme remote "upstream"
 git remote add upstream https://github.com/Kether-Labs/parsepy.git
+```
 
-### 4. Créer un environnement virtuel
+### 2. Créer un environnement virtuel
 
 ```bash
 # Avec venv (standard)
 python -m venv .venv
 source .venv/bin/activate        # Linux / macOS
 .venv\Scripts\activate           # Windows
-````
-
-`````
-
+```
 ### 3. Installer les dépendances de développement
 
 ```bash

README.md

@@ -16,8 +16,8 @@ Parse Server dispose de SDK officiels pour JavaScript, iOS, Android et .NET —
 
 | Module | Statut |
 |---|---|
-| `ParseClient` — configuration et HTTP | 🚧 En cours |
-| `ParseObject` — CRUD | 📋 Planifié |
+| `ParseClient` — configuration et HTTP | ✅ Terminé |
+| `ParseObject` — CRUD | ✅ Terminé |
 | `ParseQuery` — requêtes | 📋 Planifié |
 | `ParseUser` — authentification | 📋 Planifié |
 | `ParseFile` — fichiers | 📋 Planifié |

pyproject.toml

@@ -28,19 +28,23 @@ classifiers = [
 requires-python = ">=3.9"
 dependencies = [
   "httpx>=0.25.0",
-  "pydantic>=2.0",
-  "websockets>=12.0",
 ]
 
 [project.optional-dependencies]
 django = ["django>=4.0"]
 fastapi = ["fastapi>=0.100", "python-multipart>=0.0.6"]
 flask = ["flask>=3.0"]
+# Activé automatiquement quand ParseObject utilisera la validation Pydantic
+validation = ["pydantic>=2.0"]
+# Activé quand le module LiveQuery (WebSocket) sera implémenté
+livequery = ["websockets>=12.0"]
 all = [
   "django>=4.0",
   "fastapi>=0.100",
   "python-multipart>=0.0.6",
   "flask>=3.0",
+  "pydantic>=2.0",
+  "websockets>=12.0",
 ]
 dev = [
   "pytest>=7.4",

src/parse_sdk/__init__.py

@@ -65,8 +65,9 @@
     ParseTimeoutError,
     ParseUsernameTakenError,
 )
+from .object import ParseObject
 
-# NOTE : ParseClient, ParseObject, ParseQuery, ParseUser, ParseFile, etc.
+# NOTE : ParseQuery, ParseUser, ParseFile, etc.
 # seront ajoutés ici au fur et à mesure de leur implémentation.
 # Chaque contributeur qui implémente un module doit aussi l'exporter ici.
 
@@ -78,6 +79,7 @@
     # Version
     "__version__",
     "ParseClient",
+    "ParseObject",
     "get_client",
     # Types spéciaux
     "GeoPoint",

src/parse_sdk/_http.py

@@ -1,16 +1,8 @@
 """
-Couche HTTP interne du SDK Parse Server Python.
-
-Ce module est PRIVÉ. Il ne doit jamais être importé directement par les
-utilisateurs du SDK. Tous les modules publics (ParseObject, ParseQuery, etc.)
-passent exclusivement par ce module pour leurs requêtes HTTP.
-
-Responsabilités :
-- Gérer le client httpx (async + sync)
-- Injecter les headers Parse obligatoires
-- Retry automatique avec backoff exponentiel
-- Convertir les erreurs HTTP en exceptions ParseError
-- Logger les requêtes/réponses pour le debug
+Couche HTTP interne pour Parse Server.
+
+Usage interne uniquement — ne pas importer manuellement.
+Tous les modules (ParseObject, ParseQuery, etc.) passent par ici pour leurs requêtes.
 """
 
 from __future__ import annotations
@@ -75,25 +67,16 @@ def __init__(
         self._max_retries = max_retries
         self._session_token: str | None = None
 
-        # Client async partagé — évite de rouvrir une connexion à chaque requête
+        # Client async partagé pour réutiliser les connexions
         self._async_client: httpx.AsyncClient | None = None
 
-    # ------------------------------------------------------------------
-    # Gestion du session token (défini par ParseUser après login)
-    # ------------------------------------------------------------------
-
     def set_session_token(self, token: str | None) -> None:
         """Définit le session token à envoyer dans les requêtes suivantes."""
         self._session_token = token
 
     def clear_session_token(self) -> None:
-        """Supprime le session token (après logout)."""
         self._session_token = None
 
-    # ------------------------------------------------------------------
-    # Construction des headers
-    # ------------------------------------------------------------------
-
     def _build_headers(
         self,
         use_master_key: bool = False,
@@ -125,10 +108,6 @@ def _build_headers(
 
         return headers
 
-    # ------------------------------------------------------------------
-    # Gestion du client async
-    # ------------------------------------------------------------------
-
     async def _get_async_client(self) -> httpx.AsyncClient:
         """Retourne le client async partagé, en le créant si nécessaire."""
         if self._async_client is None or self._async_client.is_closed:
@@ -139,15 +118,10 @@ async def _get_async_client(self) -> httpx.AsyncClient:
         return self._async_client
 
     async def close(self) -> None:
-        """Ferme proprement le client HTTP async."""
         if self._async_client and not self._async_client.is_closed:
             await self._async_client.aclose()
             self._async_client = None
 
-    # ------------------------------------------------------------------
-    # Méthode principale : requête async avec retry
-    # ------------------------------------------------------------------
-
     async def request(
         self,
         method: str,
@@ -246,10 +220,6 @@ async def request(
 
         raise last_error or ParseConnectionError(f"Échec de la requête {method} {path}")
 
-    # ------------------------------------------------------------------
-    # Wrapper synchrone
-    # ------------------------------------------------------------------
-
     def request_sync(
         self,
         method: str,
@@ -312,10 +282,6 @@ def request_sync(
 
         raise last_error or ParseConnectionError(f"Échec de la requête {method} {path}")
 
-    # ------------------------------------------------------------------
-    # Traitement de la réponse HTTP
-    # ------------------------------------------------------------------
-
     def _handle_response(self, response: httpx.Response) -> dict[str, Any]:
         """Parse la réponse HTTP et lève l'exception appropriée si erreur.
 
@@ -342,10 +308,6 @@ def _handle_response(self, response: httpx.Response) -> dict[str, Any]:
 
         return body
 
-    # ------------------------------------------------------------------
-    # Helpers HTTP raccourcis
-    # ------------------------------------------------------------------
-
     async def get(self, path: str, **kwargs: Any) -> dict[str, Any]:
         """GET asynchrone."""
         return await self.request("GET", path, **kwargs)
@@ -359,5 +321,20 @@ async def put(self, path: str, **kwargs: Any) -> dict[str, Any]:
         return await self.request("PUT", path, **kwargs)
 
     async def delete(self, path: str, **kwargs: Any) -> dict[str, Any]:
-        """DELETE asynchrone."""
         return await self.request("DELETE", path, **kwargs)
+
+    def get_sync(self, path: str, **kwargs: Any) -> dict[str, Any]:
+        """GET synchrone."""
+        return self.request_sync("GET", path, **kwargs)
+
+    def post_sync(self, path: str, **kwargs: Any) -> dict[str, Any]:
+        """POST synchrone."""
+        return self.request_sync("POST", path, **kwargs)
+
+    def put_sync(self, path: str, **kwargs: Any) -> dict[str, Any]:
+        """PUT synchrone."""
+        return self.request_sync("PUT", path, **kwargs)
+
+    def delete_sync(self, path: str, **kwargs: Any) -> dict[str, Any]:
+        """DELETE synchrone."""
+        return self.request_sync("DELETE", path, **kwargs)

src/parse_sdk/_types.py

@@ -318,7 +318,7 @@ def to_parse(self) -> dict[str, Any]:
         return {"__op": "Delete"}
 
     @classmethod
-    def from_parse(cls, data: dict[str, Any]) -> DeleteField:
+    def from_parse(cls, _data: dict[str, Any]) -> DeleteField:
         return cls()
 
 

src/parse_sdk/client.py

@@ -1,20 +1,12 @@
 """
-ParseClient — Point d'entrée principal du SDK.
-
-Ce module fournit la classe publique ParseClient que chaque utilisateur
-installe pour configurer sa connexion à Parse Server.
+Point d'entrée principal pour configurer le SDK.
 """
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 from ._http import ParseHTTPClient
 
-if TYPE_CHECKING:
-    pass
-
-# Variable de module pour le pattern singleton/global
+# Instance globale partagée (singleton)
 _current_client: ParseHTTPClient | None = None
 
 
@@ -72,15 +64,14 @@ def __init__(
         self._validate_required_param(rest_key, "rest_key")
         self._validate_required_param(server_url, "server_url")
 
-        # Stocker la configuration (optionnel mais utile pour debugging)
         self._app_id = app_id
         self._rest_key = rest_key
         self._server_url = server_url
         self._master_key = master_key
         self._timeout = timeout
         self._max_retries = max_retries
 
-        # Créer le client HTTP interne
+        # Client HTTP interne
         self._http_client = ParseHTTPClient(
             app_id=app_id,
             rest_key=rest_key,
@@ -90,7 +81,6 @@ def __init__(
             max_retries=max_retries,
         )
 
-        # Enregistrer comme client global
         global _current_client
         _current_client = self._http_client
 

src/parse_sdk/exceptions.py

@@ -354,4 +354,11 @@ def raise_parse_error(code: int, message: str) -> None:
     exc_class = PARSE_ERROR_MAP.get(code, ParseError)
     if exc_class is ParseError:
         raise ParseError(code=code, message=message)
-    raise exc_class(message=message)  # type: ignore[call-arg]
+
+    # Les classes spécialisées ont des constructeurs qui ne correspondent pas
+    # tous à la signature (code, message). On crée l'instance via __new__ et
+    # on l'initialise avec ParseError.__init__ pour conserver le bon type
+    # tout en passant les bons arguments — isinstance() fonctionne toujours.
+    exc = exc_class.__new__(exc_class)
+    ParseError.__init__(exc, code=code, message=message)
+    raise exc