fix: Add multiple labels in backend

.env

@@ -1,6 +1,9 @@
 # use windows path separator for compat
 COMPOSE_PATH_SEPARATOR=;
 COMPOSE_FILE=docker-compose.yml;docker/dev.yml
+
+DOCKER_TAG=dev
+
 # domain name
 TAXONOMY_EDITOR_DOMAIN=taxonomy.localhost
 # exposition

backend/Dockerfile

@@ -1,6 +1,9 @@
 FROM python:3.8
 WORKDIR /code
-COPY ./requirements.txt /code/requirements.txt
+COPY backend/requirements.txt /code/requirements.txt
+COPY backend/editor /code/editor
+COPY parser  /parser
 RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-COPY ./editor /code/editor
+# this is purely cosmetic
+RUN     ln -s /parser/openfoodfacts_taxonomy_parser /code/openfoodfacts_taxonomy_parser
 CMD ["uvicorn", "editor.api:app", "--host", "0.0.0.0", "--port", "80"]

backend/editor/api.py

@@ -2,7 +2,7 @@
 Taxonomy Editor Backend API
 """
 # Required imports
-#------------------------------------------------------------------------#
+#----------------------------------------------------------------------------#
 from datetime import datetime
 
 # FastAPI
@@ -14,10 +14,8 @@
 
 # DB helper imports
 from . import graph_db
-from .entries import get_all_nodes, get_nodes, get_children, get_parents, get_label, full_text_search
-from .entries import update_nodes, update_node_children
-from .entries import create_node, add_node_to_end, add_node_to_beginning, delete_node
-#------------------------------------------------------------------------#
+from .entries import TaxonomyGraph
+#----------------------------------------------------------------------------#
 
 app = FastAPI(title="Open Food Facts Taxonomy Editor API")
 
@@ -83,128 +81,141 @@ async def pong(response: Response):
     pong = datetime.now()
     return {"ping": "pong @ %s" % pong}
 
-@app.get("/nodes")
-async def findAllNodes(response: Response):
+@app.get("/{taxonomy_name}/{branch}/nodes")
+async def findAllNodes(response: Response, branch: str, taxonomy_name: str):
     """
     Get all nodes within taxonomy
     """
-    result = get_all_nodes("")
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_all_nodes("")
     allNodes = list(result)
     return allNodes
 
-@app.get("/entry/{entry}")
-async def findOneEntry(response: Response, entry: str):
+@app.get("/{taxonomy_name}/{branch}/entry/{entry}")
+async def findOneEntry(response: Response, branch: str, taxonomy_name: str, entry: str):
     """
     Get entry corresponding to id within taxonomy
     """
-    result = get_nodes("ENTRY", entry)
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_nodes("ENTRY", entry)
     oneEntry = list(result)
 
     check_single(oneEntry)
 
     return oneEntry[0]
 
-@app.get("/entry/{entry}/parents")
-async def findOneEntryParents(response: Response, entry: str):
+@app.get("/{taxonomy_name}/{branch}/entry/{entry}/parents")
+async def findOneEntryParents(response: Response, branch: str, taxonomy_name: str, entry: str):
     """
     Get parents for a entry corresponding to id within taxonomy
     """
-    result = get_parents(entry)
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_parents(entry)
     oneEntryParents = list(result)
 
     return oneEntryParents
 
-@app.get("/entry/{entry}/children")
-async def findOneEntryChildren(response: Response, entry: str):
+@app.get("/{taxonomy_name}/{branch}/entry/{entry}/children")
+async def findOneEntryChildren(response: Response, branch: str, taxonomy_name: str, entry: str):
     """
     Get children for a entry corresponding to id within taxonomy
     """
-    result = get_children(entry)
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_children(entry)
     oneEntryChildren = list(result)
 
     return oneEntryChildren
 
-@app.get("/entry")
-async def findAllEntries(response: Response):
+@app.get("/{taxonomy_name}/{branch}/entry")
+async def findAllEntries(response: Response, branch: str, taxonomy_name: str):
     """
     Get all entries within taxonomy
     """
-    result = get_all_nodes("ENTRY")
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_all_nodes("ENTRY")
     allEntries = list(result)
     return allEntries
 
-@app.get("/synonym/{synonym}")
-async def findOneSynonym(response: Response, synonym: str):
+@app.get("/{taxonomy_name}/{branch}/synonym/{synonym}")
+async def findOneSynonym(response: Response, branch: str, taxonomy_name: str, synonym: str):
     """
     Get synonym corresponding to id within taxonomy
     """
-    result = get_nodes("SYNONYMS", synonym)
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_nodes("SYNONYMS", synonym)
     oneSynonym = list(result)
 
     check_single(oneSynonym)
 
     return oneSynonym[0]
 
-@app.get("/synonym")
-async def findAllSynonyms(response: Response):
+@app.get("/{taxonomy_name}/{branch}/synonym")
+async def findAllSynonyms(response: Response, branch: str, taxonomy_name: str):
     """
     Get all synonyms within taxonomy
     """
-    result = get_all_nodes("SYNONYMS")
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_all_nodes("SYNONYMS")
     allSyononyms = list(result)
     return allSyononyms
 
-@app.get("/stopword/{stopword}")
-async def findOneStopword(response: Response, stopword: str):
+@app.get("/{taxonomy_name}/{branch}/stopword/{stopword}")
+async def findOneStopword(response: Response, branch: str, taxonomy_name: str, stopword: str):
     """
     Get stopword corresponding to id within taxonomy
     """
-    result = get_nodes("STOPWORDS", stopword)
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_nodes("STOPWORDS", stopword)
     oneStopword = list(result)
 
     check_single(oneStopword)
 
     return oneStopword[0]
 
-@app.get("/stopword")
-async def findAllStopwords(response: Response):
+@app.get("/{taxonomy_name}/{branch}/stopword")
+async def findAllStopwords(response: Response, branch: str, taxonomy_name: str):
     """
     Get all stopwords within taxonomy
     """
-    result = get_all_nodes("STOPWORDS")
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_all_nodes("STOPWORDS")
     allStopwords = list(result)
     return allStopwords
 
-@app.get("/header")
-async def findHeader(response: Response):
+@app.get("/{taxonomy_name}/{branch}/header")
+async def findHeader(response: Response, branch: str, taxonomy_name: str):
     """
     Get __header__ within taxonomy
     """
-    result = get_nodes("TEXT", "__header__")
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_nodes("TEXT", "__header__")
     header = list(result)
     return header[0]
 
-@app.get("/footer")
-async def findFooter(response: Response):
+@app.get("/{taxonomy_name}/{branch}/footer")
+async def findFooter(response: Response, branch: str, taxonomy_name: str):
     """
     Get __footer__ within taxonomy
     """
-    result = get_nodes("TEXT", "__footer__")
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.get_nodes("TEXT", "__footer__")
     footer = list(result)
     return footer[0]
 
-@app.get("/search")
-async def searchNode(response: Response, query: str):
-    result = full_text_search(query)
+@app.get("/{taxonomy_name}/{branch}/search")
+async def searchNode(response: Response, branch: str, taxonomy_name: str, query: str):
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
+    result = taxonomy.full_text_search(query)
     return result
 
 # Post methods
 
-@app.post("/nodes")
-async def createNode(request: Request):
+@app.post("/{taxonomy_name}/{branch}/nodes")
+async def createNode(request: Request, branch: str, taxonomy_name: str):
     """
     Creating a new node in a taxonomy
     """
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
     incomingData = await request.json()
     id = incomingData["id"]
     main_language = incomingData["main_language"]
@@ -213,87 +224,94 @@ async def createNode(request: Request):
     if (main_language == None):
         raise HTTPException(status_code=400, detail="Invalid main language code")
 
-    create_node(get_label(id), id, main_language)
-    if (get_label(id) == "ENTRY"):
-        add_node_to_end(get_label(id), id)
+    taxonomy.create_node(taxonomy.get_label(id), id, main_language)
+    if (taxonomy.get_label(id) == "ENTRY"):
+        taxonomy.add_node_to_end(taxonomy.get_label(id), id)
     else:
-        add_node_to_beginning(get_label(id), id)
+        taxonomy.add_node_to_beginning(taxonomy.get_label(id), id)
 
-@app.post("/entry/{entry}")
-async def editEntry(request: Request, entry: str):
+@app.post("/{taxonomy_name}/{branch}/entry/{entry}")
+async def editEntry(request: Request, branch: str, taxonomy_name: str, entry: str):
     """
     Editing an entry in a taxonomy.
     New key-value pairs can be added, old key-value pairs can be updated.
     URL will be of format '/entry/<id>'
     """
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
     incomingData = await request.json()
-    result = update_nodes("ENTRY", entry, incomingData)
+    result = taxonomy.update_nodes("ENTRY", entry, incomingData)
     updatedEntry = list(result)
     return updatedEntry
 
-@app.post("/entry/{entry}/children")
-async def editEntryChildren(request: Request, entry: str):
+@app.post("/{taxonomy_name}/{branch}/entry/{entry}/children")
+async def editEntryChildren(request: Request, branch: str, taxonomy_name: str, entry: str):
     """
     Editing an entry's children in a taxonomy.
     New children can be added, old children can be removed.
     URL will be of format '/entry/<id>/children'
     """
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
     incomingData = await request.json()
-    result = update_node_children(entry, incomingData)
+    result = taxonomy.update_node_children(entry, incomingData)
     updatedChildren = list(result)
     return updatedChildren
 
-@app.post("/synonym/{synonym}")
-async def editSynonyms(request: Request, synonym: str):
+@app.post("/{taxonomy_name}/{branch}/synonym/{synonym}")
+async def editSynonyms(request: Request, branch: str, taxonomy_name: str, synonym: str):
     """
     Editing a synonym in a taxonomy.
     New key-value pairs can be added, old key-value pairs can be updated.
     URL will be of format '/synonym/<id>'
     """
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
     incomingData = await request.json()
-    result = update_nodes("SYNONYMS", synonym, incomingData)
+    result = taxonomy.update_nodes("SYNONYMS", synonym, incomingData)
     updatedSynonym = list(result)
     return updatedSynonym
 
-@app.post("/stopword/{stopword}")
-async def editStopwords(request: Request, stopword: str):
+@app.post("/{taxonomy_name}/{branch}/stopword/{stopword}")
+async def editStopwords(request: Request, branch: str, taxonomy_name: str, stopword: str):
     """
     Editing a stopword in a taxonomy.
     New key-value pairs can be added, old key-value pairs can be updated.
     URL will be of format '/stopword/<id>'
     """
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
     incomingData = await request.json()
-    result = update_nodes("STOPWORDS", stopword, incomingData)
+    result = taxonomy.update_nodes("STOPWORDS", stopword, incomingData)
     updatedStopword = list(result)
     return updatedStopword
 
-@app.post("/header")
-async def editHeader(incomingData: Header):
+@app.post("/{taxonomy_name}/{branch}/header")
+async def editHeader(incomingData: Header, branch: str, taxonomy_name: str):
     """
     Editing the __header__ in a taxonomy.
     """
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
     convertedData = incomingData.dict()
-    result = update_nodes("TEXT", "__header__", convertedData)
+    result = taxonomy.update_nodes("TEXT", "__header__", convertedData)
     updatedHeader = list(result)
     return updatedHeader
 
-@app.post("/footer")
-async def editFooter(incomingData: Footer):
+@app.post("/{taxonomy_name}/{branch}/footer")
+async def editFooter(incomingData: Footer, branch: str, taxonomy_name: str):
     """
     Editing the __footer__ in a taxonomy.
     """
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
     convertedData = incomingData.dict()
-    result = update_nodes("TEXT", "__footer__", convertedData)
+    result = taxonomy.update_nodes("TEXT", "__footer__", convertedData)
     updatedFooter = list(result)
     return updatedFooter
 
 # Delete methods
 
-@app.delete("/nodes")
-async def deleteNode(request: Request):
+@app.delete("/{taxonomy_name}/{branch}/nodes")
+async def deleteNode(request: Request, branch: str, taxonomy_name: str):
     """
     Deleting given node from a taxonomy
     """
+    taxonomy = TaxonomyGraph(branch, taxonomy_name)
     incomingData = await request.json()
     id = incomingData["id"]
-    delete_node(get_label(id), id)
+    taxonomy.delete_node(taxonomy.get_label(id), id)