INI: deploy app's first version

app.py

@@ -0,0 +1,241 @@
+from concrete import fhe
+import folium
+import geopandas
+from shapely.geometry import Point
+import streamlit as st
+from streamlit_folium import st_folium
+
+import config 
+from network import get_frames
+from utils import generate_path, set_up_server, set_up_client, display_encrypted
+
+
+st.set_page_config(layout="wide")
+ways = geopandas.read_file(config.roads_filepath)
+nodes, _, rel = get_frames(ways)
+
+server = set_up_server()
+client = set_up_client(server.client_specs.serialize())
+
+m = nodes.explore(
+    color="red",  
+    marker_kwds=dict(radius=5, fill=True, name='node_id'),  
+    tooltip="node_id",  
+    tooltip_kwds=dict(labels=False), 
+    zoom_control=False,
+)
+
+
+c1, c2, c3 = st.columns([1, 3, 1])
+
+with c1:
+    st.write("**Client-side**")
+
+with c3:
+    st.write("**Server-side**")
+
+
+if 'evaluation_key' not in st.session_state:
+    with c1:
+        if st.button('Generate keys'):
+            with st.spinner('Generating keys'):
+                client.keys.load_if_exists_generate_and_save_otherwise(config.keys_filepath)
+                # client.keys.save(config.keys_filepath)
+                st.session_state['evaluation_key'] = client.evaluation_keys.serialize()
+            st.rerun()
+else:
+    with c1:
+        st.write("Encryption/decryption keys and evaluation keys are generated.")
+        st.write("The evaluation key is sent to the server.")
+    with c3:
+        st.write(f"Evaluation key: {display_encrypted(st.session_state['evaluation_key'])}")
+
+            
+    if 'origin' not in st.session_state :
+        with c1:
+            st.write("Select the origin on the map")
+
+        with c2:
+            st_data_origin = st_folium(m, width=725, key="origin", returned_objects=["last_object_clicked"])
+
+        with c3:
+            st.write("")
+            
+        if st_data_origin["last_object_clicked"]:
+            origin = Point(st_data_origin["last_object_clicked"]["lng"], st_data_origin["last_object_clicked"]["lat"])
+            origin_node = nodes[nodes['geometry'] == origin]['node_id'].values[0]
+            st.session_state['origin'] = origin
+            st.session_state['origin_node'] = origin_node
+            st.write(f"Selected node is node number: {origin_node}")  
+            st.rerun()
+
+    if 'origin' in st.session_state and 'destination' not in st.session_state:
+        origin = st.session_state['origin']
+        folium.Marker([origin.y, origin.x], popup="Origin", tooltip="Origin").add_to(m)    
+        origin_node = st.session_state['origin_node']
+        with c1:
+            st.write(f"Selected origin is node number: {origin_node}")   
+            st.write("Select the destination on the map")         
+        with c2:
+            st_data_destination = st_folium(m, width=725, key="destination", returned_objects=["last_object_clicked"])
+        with c3:
+            st.write("")
+            st.write("")
+
+        if st_data_destination["last_object_clicked"]:
+            destination = Point(st_data_destination["last_object_clicked"]["lng"], st_data_destination["last_object_clicked"]["lat"])
+            st.session_state['destination'] = destination
+            st.session_state['destination_node'] = nodes[nodes['geometry'] == destination]['node_id'].values[0]
+            st.write(st_data_destination["last_object_clicked"])
+            st.rerun()
+
+    if 'origin' in st.session_state and 'destination' in st.session_state and 'encrypted_origin' not in st.session_state :
+        origin = st.session_state['origin']
+        folium.Marker([origin.y, origin.x], popup="Origin", tooltip="Origin").add_to(m)
+        destination = st.session_state['destination']
+        folium.Marker([destination.y, destination.x], popup="Destination", tooltip="Destination").add_to(m)
+        # breakpoint()
+        origin_node = st.session_state['origin_node']
+        destination_node = st.session_state['destination_node']
+        with c1:
+            st.write(f"Selected origin is node number: {origin_node}")   
+            st.write(f"Selected destination is node number: {destination_node}")   
+            if st.button('Encrypt and send inputs'):
+                with st.spinner('Encrypting inputs'):
+                    client.keys.load(config.keys_filepath)
+                    origin, destination = client.encrypt(origin_node, destination_node)
+                    st.session_state['encrypted_origin'] = origin.serialize()
+                    st.session_state['encrypted_destination'] = destination.serialize()
+                st.rerun()
+        with c2:
+            st_data_final = st_folium(m, width=725, key="destination", returned_objects=[])
+        with c3:
+            st.write("")
+            st.write("")
+
+    if 'encrypted_origin' in st.session_state and 'encrypted_shortest_path' not in st.session_state:
+        origin = st.session_state['origin']
+        folium.Marker([origin.y, origin.x], popup="Origin", tooltip="Origin").add_to(m)
+        destination = st.session_state['destination']
+        folium.Marker([destination.y, destination.x], popup="Destination", tooltip="Destination").add_to(m)
+        
+        origin_node = st.session_state['origin_node']
+        destination_node = st.session_state['destination_node']
+        with c1:
+            st.write(f"Selected origin is node number: {origin_node}")   
+            st.write(f"Selected destination is node number: {destination_node}")
+        with c2:
+            origin = st.session_state['origin']
+            folium.Marker([origin.y, origin.x], popup="Origin", tooltip="Origin").add_to(m)  
+            destination = st.session_state['destination']
+            folium.Marker([destination.y, destination.x], popup="Destination", tooltip="Destination").add_to(m)
+            st_data_final = st_folium(m, width=725, key="destination", returned_objects=[])
+        with c3:
+            st.write("")    
+            st.write("")    
+            st.write(f"Received origin: {display_encrypted(st.session_state['encrypted_origin'])}")
+            st.write(f"Received destination: {display_encrypted(st.session_state['encrypted_destination'])}")
+            if st.button('Compute shortest path'):
+                with st.spinner('Computing'):
+                    deserialized_origin = fhe.Value.deserialize(st.session_state['encrypted_origin'])
+                    deserialized_destination = fhe.Value.deserialize(st.session_state['encrypted_destination'])
+                    deserialized_evaluation_keys = fhe.EvaluationKeys.deserialize(st.session_state['evaluation_key'])
+                    client.keys.load_if_exists_generate_and_save_otherwise(config.keys_filepath)
+                    origin = st.session_state['origin_node']
+                    destination = st.session_state['destination_node']
+                    path = [origin, ]
+                    encrypted_path = [st.session_state['encrypted_origin'], ]
+                    o, d = deserialized_origin, deserialized_destination
+                    for _ in range(nodes.shape[0] - 1):
+                        # Careful: breaking early could lead to information leak
+                        if origin == destination:
+                            break
+                        o = server.run(o, d, evaluation_keys=client.evaluation_keys)
+                        origin = client.decrypt(o)
+                        encrypted_path.append(o.serialize())
+                        path.append(origin)
+                        
+                    st.session_state['encrypted_shortest_path'] = encrypted_path
+                    st.session_state['decrypted_shortest_path'] = path
+                st.rerun()
+
+    if 'encrypted_shortest_path' in st.session_state and 'decrypted_result' not in st.session_state :  
+        origin = st.session_state['origin']
+        folium.Marker([origin.y, origin.x], popup="Origin", tooltip="Origin").add_to(m)
+        destination = st.session_state['destination']
+        folium.Marker([destination.y, destination.x], popup="Destination", tooltip="Destination").add_to(m)
+        
+        origin_node = st.session_state['origin_node']
+        destination_node = st.session_state['destination_node']
+        with c1:
+            st.write(f"Selected origin is node number: {origin_node}")   
+            st.write(f"Selected destination is node number: {destination_node}") 
+            st.write("Received path is:")
+            st.write(f"{display_encrypted(st.session_state['encrypted_shortest_path'][0])}")
+            st.write("...")
+            st.write(f"{display_encrypted(st.session_state['encrypted_shortest_path'][-1])}")
+            
+            if st.button('Decrypt and show shortest path'):
+                with st.spinner('Computing'):
+                    client.keys.load_if_exists_generate_and_save_otherwise(config.keys_filepath)
+                    path = []
+                    for enc_value in st.session_state['encrypted_shortest_path']:
+                        deserialized_result = fhe.Value.deserialize(enc_value)
+                        path.append(client.decrypt(deserialized_result))
+                    st.session_state['decrypted_result'] = path
+                st.rerun()
+        with c2:
+            
+            origin = st.session_state['origin']
+            folium.Marker([origin.y, origin.x], popup="Origin", tooltip="Origin").add_to(m)  
+            
+            destination = st.session_state['destination']
+            folium.Marker([destination.y, destination.x], popup="Destination", tooltip="Destination").add_to(m)
+            st_data_final = st_folium(m, width=725, key="destination", returned_objects=[])
+        with c3:
+            st.write("")    
+            st.write("")    
+            st.write(f"Received origin: {display_encrypted(st.session_state['encrypted_origin'])}")
+            st.write(f"Received destination: {display_encrypted(st.session_state['encrypted_destination'])}")
+            # st.write(f"Next node is {display_encrypted(st.session_state['encrypted_shortest_path'])} and is sent to client")
+    if 'decrypted_result' in st.session_state :
+        origin = st.session_state['origin']
+        folium.Marker([origin.y, origin.x], popup="Origin", tooltip="Origin").add_to(m)
+        destination = st.session_state['destination']
+        folium.Marker([destination.y, destination.x], popup="Destination", tooltip="Destination").add_to(m)
+        
+        origin_node = st.session_state['origin_node']
+        destination_node = st.session_state['destination_node']
+        with c1:
+            st.write(f"Selected origin is node number: {origin_node}")   
+            st.write(f"Selected destination is node number: {destination_node}") 
+            st.write("Received path is:")
+            st.write(f"{display_encrypted(st.session_state['encrypted_shortest_path'][0])}")
+            st.write("...")
+            st.write(f"{display_encrypted(st.session_state['encrypted_shortest_path'][-1])}")
+            st.write(f"Decrypted result is: {st.session_state['decrypted_result']}")
+            if st.button('Restart'):
+                for key in st.session_state.keys():
+                    del st.session_state[key]
+                st.rerun() 
+        with c2:
+            origin = st.session_state['origin']
+            folium.Marker([origin.y, origin.x], popup="Origin", tooltip="Origin").add_to(m)  
+            destination = st.session_state['destination']
+            folium.Marker([destination.y, destination.x], popup="Destination", tooltip="Destination").add_to(m)
+            shortest_path_list = st.session_state['decrypted_result']
+            final_result = generate_path(shortest_path_list, rel)
+            final_result.explore(
+                m=m,  
+                color="green",
+                style_kwds = {"weight":5},
+                tooltip="name",
+                popup=["name"],
+                name="Quadratic-Paris", 
+            )
+            st_data_final = st_folium(m, width=725, key="destination", returned_objects=[])
+        with c3:
+            st.write("")    
+            st.write("")    
+            st.write(f"Received origin: {display_encrypted(st.session_state['encrypted_origin'])}")
+            st.write(f"Received destination: {display_encrypted(st.session_state['encrypted_destination'])}")

config.py

@@ -0,0 +1,6 @@
+from pathlib import Path
+
+data_path = Path(__file__).parent / "data"
+roads_filepath = data_path / "paris_quadratic_edges.geojson"
+circuit_filepath = data_path / "circuit.zip"
+keys_filepath = data_path / "keys.zip"

network.py

@@ -0,0 +1,41 @@
+import geopandas
+import networkx
+import numpy
+
+
+def get_frames(ways: geopandas.GeoDataFrame):
+    edges = ways.explode(index_parts=False)[["id", "name", "geometry"]]
+    edges.index.name = "way_id"
+    edges = edges.reset_index()
+    nodes = geopandas.GeoDataFrame({"geometry": edges.boundary.explode(index_parts=False).geometry.unique()})
+    nodes.index.name = "node_id"
+    nodes.reset_index(inplace=True)
+    rel = edges.sjoin(nodes).to_crs("epsg:2154")
+    return nodes, edges, rel
+
+
+def get(ways: geopandas.GeoDataFrame) -> networkx.Graph:
+    nodes, edges, rel = get_frames(ways)
+    graph = networkx.Graph()
+    for node in rel['node_id'].unique():
+        graph.add_node(node, shape=nodes.loc[node, "geometry"])
+    for idx in rel['way_id'].unique():
+        node_id1, node_id2 = rel.loc[idx]['node_id']
+        way = edges.loc[idx]
+        way_length = rel.loc[idx]['geometry'].iloc[0].length
+        graph.add_edge(
+            node_id1, node_id2,
+            weight=way.geometry.length,
+            shape=way.geometry,
+            id_=idx,
+        )
+    return graph
+
+
+def weighted_adjacency_matrix(graph: networkx.Graph) -> numpy.ndarray:
+    weights = numpy.full((graph.number_of_nodes(),)*2, numpy.inf)
+    numpy.fill_diagonal(weights, 0., wrap=False)
+    for i in graph:
+        for j in graph[i]:
+            weights[i, j] = graph[i][j]["weight"]
+    return weights

requirements.txt

@@ -0,0 +1,334 @@
+#
+# This file is autogenerated by pip-compile with Python 3.10
+# by the following command:
+#
+#    pip-compile requirements.in
+#
+altair==5.1.1
+    # via streamlit
+asttokens==2.4.0
+    # via stack-data
+attrs==23.1.0
+    # via
+    #   fiona
+    #   jsonschema
+    #   referencing
+backcall==0.2.0
+    # via ipython
+blinker==1.6.2
+    # via streamlit
+branca==0.6.0
+    # via
+    #   folium
+    #   streamlit-folium
+cachetools==5.3.1
+    # via streamlit
+certifi==2023.7.22
+    # via
+    #   fiona
+    #   pyproj
+    #   requests
+charset-normalizer==3.2.0
+    # via requests
+click==8.1.7
+    # via
+    #   click-plugins
+    #   cligj
+    #   fiona
+    #   streamlit
+click-plugins==1.1.1
+    # via fiona
+cligj==0.7.2
+    # via fiona
+cmake==3.27.5
+    # via triton
+comm==0.1.4
+    # via ipykernel
+concrete-python==2.0.0
+    # via -r requirements.in
+contourpy==1.1.1
+    # via matplotlib
+cycler==0.11.0
+    # via matplotlib
+debugpy==1.8.0
+    # via ipykernel
+decorator==5.1.1
+    # via ipython
+exceptiongroup==1.1.3
+    # via ipython
+executing==1.2.0
+    # via stack-data
+filelock==3.12.4
+    # via
+    #   torch
+    #   triton
+fiona==1.9.4.post1
+    # via geopandas
+folium==0.14.0
+    # via
+    #   -r requirements.in
+    #   streamlit-folium
+fonttools==4.42.1
+    # via matplotlib
+geopandas==0.14.0
+    # via -r requirements.in
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.37
+    # via streamlit
+idna==3.4
+    # via requests
+importlib-metadata==6.8.0
+    # via streamlit
+ipykernel==6.25.2
+    # via -r requirements.in
+ipython==8.15.0
+    # via ipykernel
+jedi==0.19.0
+    # via ipython
+jinja2==3.1.2
+    # via
+    #   altair
+    #   branca
+    #   folium
+    #   pydeck
+    #   streamlit-folium
+    #   torch
+joblib==1.3.2
+    # via scikit-learn
+jsonschema==4.19.1
+    # via altair
+jsonschema-specifications==2023.7.1
+    # via jsonschema
+jupyter-client==8.3.1
+    # via ipykernel
+jupyter-core==5.3.1
+    # via
+    #   ipykernel
+    #   jupyter-client
+kiwisolver==1.4.5
+    # via matplotlib
+lit==16.0.6
+    # via triton
+mapclassify==2.6.0
+    # via -r requirements.in
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==2.1.3
+    # via jinja2
+matplotlib==3.8.0
+    # via -r requirements.in
+matplotlib-inline==0.1.6
+    # via
+    #   ipykernel
+    #   ipython
+mdurl==0.1.2
+    # via markdown-it-py
+mpmath==1.3.0
+    # via sympy
+nest-asyncio==1.5.8
+    # via ipykernel
+networkx==3.1
+    # via
+    #   concrete-python
+    #   mapclassify
+    #   torch
+numpy==1.26.0
+    # via
+    #   -r requirements.in
+    #   altair
+    #   concrete-python
+    #   contourpy
+    #   folium
+    #   mapclassify
+    #   matplotlib
+    #   pandas
+    #   pyarrow
+    #   pydeck
+    #   scikit-learn
+    #   scipy
+    #   shapely
+    #   streamlit
+nvidia-cublas-cu11==11.10.3.66
+    # via
+    #   nvidia-cudnn-cu11
+    #   nvidia-cusolver-cu11
+    #   torch
+nvidia-cuda-cupti-cu11==11.7.101
+    # via torch
+nvidia-cuda-nvrtc-cu11==11.7.99
+    # via torch
+nvidia-cuda-runtime-cu11==11.7.99
+    # via torch
+nvidia-cudnn-cu11==8.5.0.96
+    # via torch
+nvidia-cufft-cu11==10.9.0.58
+    # via torch
+nvidia-curand-cu11==10.2.10.91
+    # via torch
+nvidia-cusolver-cu11==11.4.0.1
+    # via torch
+nvidia-cusparse-cu11==11.7.4.91
+    # via torch
+nvidia-nccl-cu11==2.14.3
+    # via torch
+nvidia-nvtx-cu11==11.7.91
+    # via torch
+packaging==23.1
+    # via
+    #   altair
+    #   geopandas
+    #   ipykernel
+    #   matplotlib
+    #   streamlit
+pandas==2.1.1
+    # via
+    #   altair
+    #   geopandas
+    #   mapclassify
+    #   streamlit
+parso==0.8.3
+    # via jedi
+pexpect==4.8.0
+    # via ipython
+pickleshare==0.7.5
+    # via ipython
+pillow==9.5.0
+    # via
+    #   matplotlib
+    #   streamlit
+platformdirs==3.10.0
+    # via jupyter-core
+prompt-toolkit==3.0.39
+    # via ipython
+protobuf==4.24.3
+    # via streamlit
+psutil==5.9.5
+    # via ipykernel
+ptyprocess==0.7.0
+    # via pexpect
+pure-eval==0.2.2
+    # via stack-data
+pyarrow==13.0.0
+    # via streamlit
+pydeck==0.8.1b0
+    # via streamlit
+pygments==2.16.1
+    # via
+    #   ipython
+    #   rich
+pyparsing==3.1.1
+    # via matplotlib
+pyproj==3.6.1
+    # via geopandas
+python-dateutil==2.8.2
+    # via
+    #   jupyter-client
+    #   matplotlib
+    #   pandas
+    #   streamlit
+pytz==2023.3.post1
+    # via pandas
+pyzmq==25.1.1
+    # via
+    #   ipykernel
+    #   jupyter-client
+referencing==0.30.2
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+requests==2.31.0
+    # via
+    #   folium
+    #   streamlit
+rich==13.5.3
+    # via streamlit
+rpds-py==0.10.3
+    # via
+    #   jsonschema
+    #   referencing
+scikit-learn==1.3.1
+    # via mapclassify
+scipy==1.11.2
+    # via
+    #   concrete-python
+    #   mapclassify
+    #   scikit-learn
+shapely==2.0.1
+    # via
+    #   -r requirements.in
+    #   geopandas
+six==1.16.0
+    # via
+    #   asttokens
+    #   fiona
+    #   python-dateutil
+smmap==5.0.1
+    # via gitdb
+stack-data==0.6.2
+    # via ipython
+streamlit==1.27.0
+    # via
+    #   -r requirements.in
+    #   streamlit-folium
+streamlit-folium==0.14.0
+    # via -r requirements.in
+sympy==1.12
+    # via torch
+tenacity==8.2.3
+    # via streamlit
+threadpoolctl==3.2.0
+    # via scikit-learn
+toml==0.10.2
+    # via streamlit
+toolz==0.12.0
+    # via altair
+torch==2.0.1
+    # via
+    #   concrete-python
+    #   triton
+tornado==6.3.3
+    # via
+    #   ipykernel
+    #   jupyter-client
+    #   streamlit
+traitlets==5.10.0
+    # via
+    #   comm
+    #   ipykernel
+    #   ipython
+    #   jupyter-client
+    #   jupyter-core
+    #   matplotlib-inline
+triton==2.0.0
+    # via torch
+typing-extensions==4.8.0
+    # via
+    #   altair
+    #   streamlit
+    #   torch
+tzdata==2023.3
+    # via pandas
+tzlocal==5.0.1
+    # via streamlit
+urllib3==2.0.5
+    # via requests
+validators==0.22.0
+    # via streamlit
+watchdog==3.0.0
+    # via streamlit
+wcwidth==0.2.6
+    # via prompt-toolkit
+wheel==0.41.2
+    # via
+    #   nvidia-cublas-cu11
+    #   nvidia-cuda-cupti-cu11
+    #   nvidia-cuda-runtime-cu11
+    #   nvidia-curand-cu11
+    #   nvidia-cusparse-cu11
+    #   nvidia-nvtx-cu11
+zipp==3.17.0
+    # via importlib-metadata
+
+# The following packages are considered to be unsafe in a requirements file:
+# setuptools

utils.py

@@ -0,0 +1,47 @@
+import pandas as pd
+from concrete import fhe
+from config import circuit_filepath
+
+
+def set_up_server():
+    # Setting up a server
+    try:
+        server = fhe.Server.load(circuit_filepath)
+    except Exception:
+        raise Exception(f"Something went wrong with the circuit. Make sure that the circuit exists in {circuit_filepath}. If not run python generate_circuit.py.") 
+
+    return server
+
+def set_up_client(serialized_client_specs):
+    # Setting up client
+    client_specs = fhe.ClientSpecs.deserialize(serialized_client_specs)
+    client = fhe.Client(client_specs)
+
+    return client
+
+def display_encrypted(encrypted_object):
+    encoded_text = encrypted_object.hex()
+    res = '...' + encoded_text[-10:]
+    return res
+
+def shortest_path(circuit, N_NODES, origin, destination):
+    path = [origin, ]
+    o, d = circuit.encrypt(origin, destination)
+    for _ in range(N_NODES - 1):
+        # Careful: breaking early could lead to information leak
+        if origin == destination:
+            break
+        o = circuit.run(o, d)
+        origin = circuit.decrypt(o)
+        path.append(origin)
+    return path
+
+def generate_path(shortest_path_list, rel):
+    pairs_list = []
+    for i in range(len(shortest_path_list) - 1):
+        current_element = shortest_path_list[i]
+        next_element = shortest_path_list[i + 1]
+        result = rel.groupby('way_id').filter(lambda x: set([current_element, next_element]).issubset(x['node_id']))
+        pairs_list.append(result)
+    final_result = pd.concat(pairs_list)
+    return final_result