final update

back.py

@@ -1,50 +0,0 @@
-import time
-from pydantic import BaseModel
-import base64
-from fastapi import FastAPI, APIRouter
-from fastapi.middleware.cors import CORSMiddleware
-
-app = FastAPI()
-
-origins = [
-    "http://localhost:7860", 
-    "https://example.com",
-]
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins, 
-    allow_credentials=True,
-    allow_methods=["*"],  
-    allow_headers=["*"],  
-)
-
-class ImageData(BaseModel):
-    image: str
-
-class ImagesData(BaseModel):
-    idCard: str
-    profileImage: str
-
-@app.post("/uploadpdf")
-async def upload_pdf(image_data: ImageData):
-    header, encoded = image_data.image.split(',', 1)
-    binary_data = base64.b64decode(encoded)  
-
-    time.sleep(20);
-
-    return {"message": "Image reçue et sauvegardée"}
-
-@app.post("/uploadids")
-async def upload_ids(images_data: ImagesData):
-    header, encoded = images_data.idCard.split(',', 1)
-    id_card_binary_data = base64.b64decode(encoded)
-
-    header, encoded = images_data.idCard.split(',', 1)
-    profile_image_binary_data = base64.b64decode(encoded)
-
-    time.sleep(20);
-
-    return {"message": "Image reçue et sauvegardée"}
-
-

back/client.py

@@ -0,0 +1,116 @@
+
+"""Client script.
+
+This script does the following:
+    - Query crypto-parameters and pre/post-processing parameters (client.zip)
+    - Quantize the inputs using the parameters
+    - Encrypt data using the crypto-parameters
+    - Send the encrypted data to the server (async using grequests)
+    - Collect the data and decrypt it
+    - De-quantize the decrypted results
+"""
+
+import io
+import os
+import sys
+from pathlib import Path
+
+import grequests
+import numpy
+import requests
+import torch
+import torchvision
+import torchvision.transforms as transforms
+
+from concrete.ml.deployment import FHEModelClient
+
+PORT = os.environ.get("PORT", "5000")
+IP = os.environ.get("IP", "localhost")
+URL = os.environ.get("URL", f"http://{IP}:{PORT}")
+NUM_SAMPLES = int(os.environ.get("NUM_SAMPLES", 1))
+STATUS_OK = 200
+
+
+def main():
+    # Get the necessary data for the client
+    # client.zip
+
+    train_sub_set = ...
+
+    zip_response = requests.get(f"{URL}/get_client")
+    assert zip_response.status_code == STATUS_OK
+    with open("./client.zip", "wb") as file:
+        file.write(zip_response.content)
+
+    # Get the data to infer
+    X = train_sub_set[:1]
+
+    # Create the client
+    client = FHEModelClient(path_dir="./", key_dir="./keys")
+
+    # The client first need to create the private and evaluation keys.
+    serialized_evaluation_keys = client.get_serialized_evaluation_keys()
+
+    assert isinstance(serialized_evaluation_keys, bytes)
+
+    # Evaluation keys can be quite large files but only have to be shared once with the server.
+
+    # Check the size of the evaluation keys (in MB)
+    print(f"Evaluation keys size: {sys.getsizeof(serialized_evaluation_keys) / 1024 / 1024:.2f} MB")
+
+    # Update all base64 queries encodings with UploadFile
+    response = requests.post(
+        f"{URL}/add_key",
+        files={"key": io.BytesIO(initial_bytes=serialized_evaluation_keys)},
+    )
+    assert response.status_code == STATUS_OK
+    uid = response.json()["uid"]
+
+    inferences = []
+    # Launch the queries
+    clear_input = X[[0], :].numpy()
+    print("Input shape:", clear_input.shape)
+
+    assert isinstance(clear_input, numpy.ndarray)
+    print("Quantize/Encrypt")
+    encrypted_input = client.quantize_encrypt_serialize(clear_input) # Encrypt the data
+    assert isinstance(encrypted_input, bytes)
+
+    print(f"Encrypted input size: {sys.getsizeof(encrypted_input) / 1024 / 1024:.2f} MB")
+
+    print("Posting query")
+    inferences.append(
+        grequests.post(
+            f"{URL}/compute",
+            files={
+                "model_input": io.BytesIO(encrypted_input),
+            },
+            data={
+                "uid": uid,
+            },
+        )
+    )
+
+    del encrypted_input
+    del serialized_evaluation_keys
+
+    print("Posted!")
+
+    # Unpack the results
+    decrypted_predictions = []
+    for result in grequests.map(inferences):
+        if result is None:
+            raise ValueError(
+                "Result is None, probably because the server crashed due to lack of available memory."
+            )
+        assert result.status_code == STATUS_OK
+        print("OK!")
+
+        encrypted_result = result.content
+        decrypted_prediction = client.deserialize_decrypt_dequantize(encrypted_result)[0]
+        decrypted_predictions.append(decrypted_prediction)
+    print(decrypted_predictions)
+
+
+if __name__ == "__main__":
+    main()

back/server_deploy.py

@@ -0,0 +1,92 @@
+
+"""Deployment server.
+
+Routes:
+    - Get client.zip
+    - Add a key
+    - Compute
+"""
+
+import io
+import os
+import uuid
+from pathlib import Path
+from typing import Dict
+
+import uvicorn
+from fastapi import FastAPI, Form, HTTPException, UploadFile
+from fastapi.responses import FileResponse, StreamingResponse
+
+# No relative import here because when not used in the package itself
+from concrete.ml.deployment import FHEModelServer
+
+if __name__ == "__main__":
+    app = FastAPI(debug=False)
+
+    FILE_FOLDER = Path(__file__).parent
+
+    KEY_PATH = Path(os.environ.get("KEY_PATH", FILE_FOLDER / Path("server_keys")))
+    CLIENT_SERVER_PATH = Path(os.environ.get("PATH_TO_MODEL", FILE_FOLDER / Path("dev")))
+    PORT = os.environ.get("PORT", "5000")
+
+    fhe = FHEModelServer(str(CLIENT_SERVER_PATH.resolve()))
+
+    KEYS: Dict[str, bytes] = {}
+
+    PATH_TO_CLIENT = (CLIENT_SERVER_PATH / "client.zip").resolve()
+    PATH_TO_SERVER = (CLIENT_SERVER_PATH / "server.zip").resolve()
+
+    assert PATH_TO_CLIENT.exists()
+    assert PATH_TO_SERVER.exists()
+
+    @app.get("/get_client")
+    def get_client():
+        """Get client.
+
+        Returns:
+            FileResponse: client.zip
+
+        Raises:
+            HTTPException: if the file can't be find locally
+        """
+        path_to_client = (CLIENT_SERVER_PATH / "client.zip").resolve()
+        if not path_to_client.exists():
+            raise HTTPException(status_code=500, detail="Could not find client.")
+        return FileResponse(path_to_client, media_type="application/zip")
+
+    @app.post("/add_key")
+    async def add_key(key: UploadFile):
+        """Add public key.
+
+        Arguments:
+            key (UploadFile): public key
+
+        Returns:
+            Dict[str, str]
+                - uid: uid a personal uid
+        """
+        uid = str(uuid.uuid4())
+        KEYS[uid] = await key.read()
+        return {"uid": uid}
+
+    @app.post("/compute")
+    async def compute(model_input: UploadFile, uid: str = Form()):  # noqa: B008
+        """Compute the circuit over encrypted input.
+
+        Arguments:
+            model_input (UploadFile): input of the circuit
+            uid (str): uid of the public key to use
+
+        Returns:
+            StreamingResponse: the result of the circuit
+        """
+        key = KEYS[uid]
+        encrypted_results = fhe.run(
+            serialized_encrypted_quantized_data=await model_input.read(),
+            serialized_evaluation_keys=key,
+        )
+        return StreamingResponse(
+            io.BytesIO(encrypted_results),
+        )
+
+    uvicorn.run(app, host="0.0.0.0", port=int(PORT))

front/dist/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Vite + React + TS</title>
-    <script type="module" crossorigin src="/assets/index-D_vcNfiC.js"></script>
+    <script type="module" crossorigin src="/assets/index-Cqst1UVv.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DBF5kfs0.css">
   </head>
   <body>

front/src/Homescene.tsx

@@ -17,7 +17,7 @@ export default function HomeScene() {
     formData.append("file", file);
 
     try {
-      const response = await fetch("https://your-backend-api/upload", {
+      const response = await fetch("http://0.0.0.0:7860/uploadpdf", {
         method: "POST",
         body: formData,
       });

front/src/VerificationScene.tsx

@@ -35,16 +35,17 @@ export default function VerificationScene() {
   };
 
   const sendImageToServer = async (
-    imageDataUrl: string,
+    idCard: string,
+    profileImage: string,
     setLoading: (n: boolean) => void,
   ) => {
     try {
-      const response = await fetch("http://0.0.0.0:7860/uploadpdf", {
+      const response = await fetch("http://0.0.0.0:7860/uploadids", {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
         },
-        body: JSON.stringify({ image: imageDataUrl }),
+        body: JSON.stringify({ idCard: idCard, profileImage: profileImage }),
       });
 
       if (!response.ok) {
@@ -145,6 +146,7 @@ export default function VerificationScene() {
       <ResultContainer
         sendImageToServer={sendImageToServer}
         idCardPicture={idCardPicture ?? ""}
+        profileImage={profilePicture ?? ""}
       />
     );
   }

front/src/components/ResultContainer.tsx

@@ -3,14 +3,20 @@ import { useEffect, useState } from "react";
 export default function ResultContainer({
   sendImageToServer,
   idCardPicture,
+  profileImage,
 }: {
-  sendImageToServer: (pic: string, setLoading: (n: boolean) => void) => void;
+  sendImageToServer: (
+    pic: string,
+    pic2: string,
+    setLoading: (n: boolean) => void,
+  ) => void;
   idCardPicture: string;
+  profileImage: string;
 }) {
   const [loading, setLoading] = useState<boolean>(true);
 
   useEffect(() => {
-    sendImageToServer(idCardPicture ?? "", setLoading);
+    sendImageToServer(idCardPicture ?? "", profileImage ?? "", setLoading);
   }, []);
   return <>{loading ? <>Fetching</> : <>Perfect</>}</>;
 }

main.py

@@ -17,6 +17,8 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+pdf = 0 
+
 class ImageData(BaseModel):
     image: str
 
@@ -35,16 +37,16 @@ async def verif() -> FileResponse:
 async def upload_pdf(data: ImageData):
     header, encoded = data.image.split(',', 1)
     binary_data = base64.b64decode(encoded)
-
-    time.sleep(20)
-
+    # Call
+    pdf = binary_data;
+    time.sleep(10)
     return {"message": "Image reçue et sauvegardée"}
 
 @router.post("/uploadids")
 async def upload_ids(data: ImagesData):
+    # Call To The model
     return {"message": "Images reçues et sauvegardées"}
 
-
 app.include_router(router)
 
 app.mount("/", StaticFiles(directory="front/dist", html=True), name="static")