init: foodviz project files

.github/workflows/ploomber-cloud.yaml

@@ -0,0 +1,40 @@
+name: Ploomber Cloud
+
+on:
+  schedule:
+    - cron: '0 1 * * *'
+
+jobs:
+  deploy-to-ploomber-cloud:
+    runs-on: ubuntu-latest
+    environment: production
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.10'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install ploomber-cloud
+
+      - name: Create environment file
+        shell: bash
+        env:
+          SECRET_URL: ${{ secrets.SUPABASE_URL }}
+          SECRET_KEY: ${{ secrets.SUPABASE_KEY }}
+        run: |
+          printf "SUPABASE_URL=\"$SECRET_URL\"\nSUPABASE_KEY=\"$SECRET_KEY\"" > ./app/.env
+
+      - name: Deploy
+        env:
+          PLOOMBER_CLOUD_KEY: ${{ secrets.PLOOMBER_CLOUD_KEY }}
+        run: |
+          cd app/
+          cat .env
+          ploomber-cloud deploy --watch
+        # The --watch flag will print deployment status updates to the logs.
+        # To learn more, visit: https://docs.cloud.ploomber.io/en/latest/user-guide/github.html

.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+app/.streamlit/secrets.toml
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/

.pre-commit-config.yaml

@@ -0,0 +1,83 @@
+ci:
+    skip: [python-safety-dependencies-check]
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: requirements-txt-fixer
+
+  - repo: https://github.com/PyCQA/autoflake
+    rev: v2.3.1
+    hooks:
+      - id: autoflake
+        verbose: true
+
+  - repo: https://github.com/miki725/importanize/
+    rev: '0.7'
+    hooks:
+      - id: importanize
+        language_version: python3
+        language: python
+        args: [ --verbose ]
+
+  - repo: https://github.com/pycqa/flake8
+    rev: 7.0.0
+    hooks:
+      - id: flake8
+        exclude: ^.*__init__.py$
+        stages: [commit, push, manual]
+        args: [--max-line-length=120]
+
+  - repo: https://github.com/hhatto/autopep8
+    rev:  v2.0.4
+    hooks:
+      - id: autopep8
+        args: [--in-place, --aggressive, --aggressive, --max-line-length=120, --verbose]
+
+  - repo: https://github.com/PyCQA/docformatter
+    rev: v1.7.5
+    hooks:
+      - id: docformatter
+
+  - repo: https://github.com/thibaudcolas/curlylint
+    rev: v0.13.1
+    hooks:
+      - id: curlylint
+
+#  - repo: https://github.com/Lucas-C/pre-commit-hooks-safety
+#    rev: v1.3.1
+#    hooks:
+#      - id: python-safety-dependencies-check
+#        files: requirements
+
+  - repo: https://github.com/PyCQA/bandit
+    rev: '1.7.8'
+    hooks:
+      - id: bandit
+
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.3.4
+    hooks:
+      - id: ruff
+        args:
+          - --fix
+          - --line-length=120
+
+  - repo: https://github.com/psf/black
+    rev: 23.11.0
+    hooks:
+      - id: black
+        language_version: python3
+        args: [--line-length=120]
+
+  - repo: https://github.com/python-poetry/poetry
+    rev: '1.8.2'
+    hooks:
+      - id: poetry-check
+      - id: poetry-lock
+      - id: poetry-export
+        args: ["-C", "./app", "--without-hashes", "--without=dev", "-f", "requirements.txt", "-o", "./app/requirements.txt"]

.streamlit/config.toml

@@ -0,0 +1,62 @@
+[theme]
+#primaryColor="#f21111"
+#backgroundColor="#0e1117"
+#secondaryBackgroundColor="#31333F"
+#textColor="#fafafa"
+# -- dark chocolate --
+#primaryColor="#2c3e50"
+#backgroundColor="#1a1a1a"
+#secondaryBackgroundColor="#333333"
+#textColor="#dcdcdc"
+# -- midnight feast --
+#primaryColor="#2c3e50"
+#backgroundColor="#1a1a1a"
+#secondaryBackgroundColor="#333333"
+#textColor="#dcdcdc"
+# -- umami delight --
+#primaryColor="#556b2f"
+#backgroundColor="#1a1a1a"
+#secondaryBackgroundColor="#4c721d"
+#textColor="#f0e68c"
+# -- spicy wasabi --
+#primaryColor="#33CC99"
+#backgroundColor="#222222"
+#secondaryBackgroundColor="#333333"
+#textColor="#f0f0f0"
+# -- night sky --
+#primaryColor="#a62c81"
+#backgroundColor="#191919"
+#secondaryBackgroundColor="#222222"
+#textColor="#dddddd"
+# -- modern minimalist --
+#primaryColor="#00bcd4"
+#backgroundColor="#212121"
+#secondaryBackgroundColor="#303030"
+#textColor="#e0e0e0"
+# -- cocoa indulgence --
+#primaryColor="#8b4513"
+#backgroundColor="#1c1c1c"
+#secondaryBackgroundColor="#3d2c1f"
+#textColor="#ffe4b5"
+# -- spicy heat --
+#primaryColor="#d9534f"
+#backgroundColor="#000000"
+#secondaryBackgroundColor="#8b0000"
+#textColor="#b0c4de"
+#font="monospace"
+# -- fit blue --
+primaryColor="#0066ee"
+backgroundColor="#11131C"
+secondaryBackgroundColor="#373f51"
+textColor="#fdfeff"
+# -- grey and teal
+#primaryColor="#049a77"
+#backgroundColor="#000000"
+#secondaryBackgroundColor="#2d3446"
+#textColor="#e5e5e5"
+
+
+
+[client]
+toolbarMode="minimal"
+showSidebarNavigation=false

Dockerfile

@@ -0,0 +1,36 @@
+FROM ubuntu:22.04
+LABEL authors="p1utoze"
+
+# Install dependencies
+RUN apt-get update && apt-get install -y \
+    python3 \
+    python3-pip \
+    python3-dev \
+    build-essential \
+    libssl-dev \
+    libffi-dev \
+    python3-setuptools \
+    python3-venv \
+    git \
+    && apt-get clean
+
+WORKDIR /app
+
+# Install python packages
+COPY requirements.txt /app/requirements.txt
+RUN #python3 -m pip install torch --index-url https://download.pytorch.org/whl/cpu
+RUN python3 -m pip install --upgrade pip
+RUN python3 -m pip install -r requirements.txt
+
+# Copy the Entry Point script
+COPY app.py /app/app.py
+
+COPY foodviz/pages/ /app/pages
+COPY foodviz/ /app/foodviz/
+COPY .streamlit /app/.streamlit
+
+# Expose the port
+EXPOSE 8501
+
+# Command to run on container start
+CMD ["streamlit", "run", "app.py", "--server.port=8501"]

app.py

@@ -0,0 +1,63 @@
+import streamlit as st
+import streamlit_antd_components as sac
+from dotenv import load_dotenv
+# from foodviz.pages.comparer import run as comparer_run
+from foodviz.pages import home_run, comparer_run, search_run, viewer_run
+# from foodviz.pages.viewer import run as viewer_run
+# from foodviz.pages.search import run as search_run
+from foodviz.utils import SupabaseConnection
+
+# Loads the environment variables
+load_dotenv()
+
+pages = {
+    "Home": [home_run, 0, "house"],
+    "View": [viewer_run, 1, "eye"],
+    "Compare": [comparer_run, 2, "bar-chart-steps"],
+    "Search": [search_run, 3, "search"],
+}
+
+
+def menu_callback():
+    st.session_state.page_index = pages[st.session_state.tab_item][1]
+
+
+if __name__ == "__main__":
+    st.set_page_config(
+        page_title="IFCT Food Database",
+        page_icon="🍔",
+        layout="wide",
+    )
+    
+    # Set the page index to Home.
+    if "page_index" not in st.session_state:
+        st.session_state.page_index = 0
+
+    # Initialize connection.
+    if "_conn" not in st.session_state:
+        st.session_state["_conn"] = st.connection("supabase", type=SupabaseConnection)
+
+    st.markdown(
+        """
+        <style>
+    .appview-container .main .block-container{{
+            padding-top: {padding_top}rem;    }}
+    </style>
+    """.format(
+            padding_top=1.5
+        ),
+        unsafe_allow_html=True,
+    )
+    sac.tabs(
+        [sac.TabsItem(label=i, icon=pages[i][2]) for i in pages.keys()],
+        variant="outline",
+        index=st.session_state.page_index,
+        use_container_width=True,
+        on_change=menu_callback,
+        key="tab_item",
+    )
+    try:
+        pages[st.session_state.tab_item][0]()
+    except Exception as e:
+        st.error(f"Page '{st.session_state.tab_item}' not found.")
+        st.error(f"Error: {e}")

foodviz/agents/llm.py

@@ -0,0 +1,117 @@
+import os
+from typing import List, Dict
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, ServiceContext
+from llama_index.core.llms import HuggingFaceLLM
+from llama_index.core.tools import QueryEngineTool, ToolMetadata
+from llama_index.core.agent import ReActAgent
+from llama_index.core.callbacks import CallbackManager, LlamaDebugHandler
+from duckduckgo_search import DDGS
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+import torch
+
+# Initialize LlamaIndex
+llama_debug = LlamaDebugHandler(print_trace_on_end=True)
+callback_manager = CallbackManager([llama_debug])
+
+# Load Hugging Face model with 4-bit quantization
+model_name = "meta-llama/Llama-2-7b-chat-hf"  # You can change this to any compatible model
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_use_double_quant=True,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_compute_dtype=torch.bfloat16
+)
+
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    quantization_config=bnb_config,
+    device_map="auto",
+)
+
+# Create HuggingFaceLLM
+llm = HuggingFaceLLM(
+    context_window=4096,
+    max_new_tokens=256,
+    generate_kwargs={"temperature": 0.7, "do_sample": False},
+    tokenizer=tokenizer,
+    model=model,
+)
+
+# Set up service context
+service_context = ServiceContext.from_defaults(llm=llm, callback_manager=callback_manager)
+
+# Load documents and create index
+documents = SimpleDirectoryReader("path/to/your/documents").load_data()
+index = VectorStoreIndex.from_documents(documents, service_context=service_context)
+
+# Create query engine
+query_engine = index.as_query_engine()
+
+
+# DuckDuckGo search tool
+def web_search(query: str) -> List[Dict[str, str]]:
+    with DDGS() as ddgs:
+        results = list(ddgs.text(query, max_results=3))
+    return results
+
+
+# Custom tool for web search
+class WebSearchTool:
+    def __init__(self):
+        self.metadata = ToolMetadata(
+            name="web_search",
+            description="Useful for searching the web for current information"
+        )
+
+    def __call__(self, input_text: str) -> str:
+        results = web_search(input_text)
+        return str(results)
+
+
+# Create tools
+query_engine_tool = QueryEngineTool(
+    query_engine=query_engine,
+    metadata=ToolMetadata(
+        name="vector_index",
+        description="Useful for answering questions about the documents in the vector index"
+    )
+)
+
+web_search_tool = WebSearchTool()
+
+# Create ReAct agent
+agent = ReActAgent.from_tools([query_engine_tool, web_search_tool], llm=llm, verbose=True)
+
+
+def generate_response(query: str) -> str:
+    # Get response from the agent
+    response = agent.chat(query)
+
+    # Extract sources from the vector index query
+    vector_sources = [node.node.metadata for node in response.source_nodes]
+
+    # Extract web search results
+    web_sources = []
+    for tool_use in response.tool_usage:
+        if tool_use.tool_name == "web_search":
+            web_sources = eval(tool_use.output)
+
+    # Combine sources
+    all_sources = vector_sources + web_sources
+
+    # Format the response with sources
+    formatted_response = f"Answer: {response.response}\n\nSources:\n"
+    for idx, source in enumerate(all_sources, 1):
+        if isinstance(source, dict):
+            formatted_response += f"{idx}. {source.get('title', 'N/A')} - {source.get('href', 'N/A')}\n"
+        else:
+            formatted_response += f"{idx}. {source}\n"
+
+    return formatted_response
+
+
+# Example usage
+query = "What are the latest advancements in renewable energy?"
+result = generate_response(query)
+print(result)

foodviz/agents/parse_data.py

@@ -0,0 +1,88 @@
+import os
+import re
+
+import faiss
+import pandas as pd
+from dotenv import load_dotenv
+from llama_index.core import VectorStoreIndex, StorageContext
+from llama_index.core.node_parser import SimpleNodeParser
+from llama_index.core.schema import Document, MetadataMode
+from llama_index.embeddings.voyageai import VoyageEmbedding
+from llama_index.vector_stores.faiss import FaissVectorStore
+
+from foodviz.utils.config import PROJECT_ROOT
+
+load_dotenv()
+
+d = 1536
+faiss_index = faiss.IndexFlatL2(d)
+
+# Load the VoyageEmbedding model
+embed_model = VoyageEmbedding(model_name="voyage-large-2", voyage_api_key=os.environ["VOYAGE_API_KEY"])
+
+
+# Load and preprocess the data
+def preprocess_and_vectorize_data(file_path, data_store_path=None):
+    df = process_data(file_path)
+
+    # Combine all information into a single string for each item
+    # print(df.head())
+
+    # Create documents for LlamaIndex
+    documents = []
+    for _, row in df.iterrows():
+        document = Document(
+            text=row['local_name'],
+            metadata={"name": row['name'], "scientific_name": row['scie'], "tags": row['tags'], "lang": row['full_lang_name']},
+            metadata_seperator="::",
+            metadata_template="{key}=>{value}",
+            text_template="Metadata: {metadata_str}\n-----\nContent: {content}",
+        )
+        documents.append(document)
+
+    print(documents[5], documents[5].metadata, documents[5].get_content(metadata_mode=MetadataMode.EMBED), sep='\n')
+
+    vector_store = FaissVectorStore(faiss_index=faiss_index)
+    # create storage context using default stores
+    storage_context = StorageContext.from_defaults(
+        vector_store=vector_store,
+    )
+    storage_context.persist(data_store_path)
+
+    # Create nodes from documents
+    parser = SimpleNodeParser.from_defaults(separator=";")  # Default separator is "\n"
+    nodes = parser.get_nodes_from_documents(documents)
+    index = VectorStoreIndex(embed_model=embed_model, nodes=nodes, storage_context=storage_context, show_progress=True)
+    index.storage_context.persist(data_store_path)
+    return index
+
+
+
+
+def process_data(file_path):
+    df = pd.read_csv(file_path)
+    langs = pd.read_csv(PROJECT_ROOT / "data" / "languages.csv")
+    df["lang_names"] = df["lang"].apply(lambda x: str(x).split("; "))
+    df = df.explode("lang_names").reset_index(drop=True)
+    df["lang_names"] = df["lang_names"].apply(lambda x: x.strip())
+    df["lang_names"] = df["lang_names"].astype(str)
+    df["lang"] = df["lang"].astype(str)
+    df["abbr"] = df["lang_names"].apply(lambda x: re.split(r"(?<=\.)\s", x)[0])
+    df["local_name"] = df["lang_names"].str.extract(r"\. (.*)")
+    df2 = pd.merge(df, langs, left_on="abbr", right_on="abbr", how="left")
+    df2 = df2.rename(columns={"lang_y": "full_lang_name"})
+    df2.drop(columns=["abbr", "id"], inplace=True)
+    # print(df2[["name", "local_name", "full_lang_name"]].head(15))
+    return df2
+
+if __name__ == "__main__":
+    # process_data(PROJECT_ROOT / "data" / "food_local_langs.csv")
+    data_path = "../data/context_storage"
+    # index = preprocess_and_vectorize_data(file_path=PROJECT_ROOT / "data" / "food_local_langs.csv", data_store_path=data_path)
+    index = load_retriever(data_path)
+    retriever = index.as_retriever(similarity_top_k=5)
+    nodes = retriever.retrieve("dunglina dakadi")
+    for node in nodes:
+        print(node.text, node.metadata, node.score)
+
+

foodviz/data/.~lock.food_local_langs_processed.csv#

@@ -1 +0,0 @@
-,p1utoze,uwuntu,20.07.2024 01:53,file:///home/p1utoze/.config/libreoffice/4;

foodviz/pages/__init__.py

@@ -0,0 +1,6 @@
+from .home import run as home_run
+from .comparer import run as comparer_run
+from .viewer import run as viewer_run
+from .search import run as search_run
+
+__all__ = ["home_run", "comparer_run", "viewer_run", "search_run"]

foodviz/pages/comparer.py

@@ -0,0 +1,82 @@
+import pandas as pd
+import streamlit as st
+from foodviz.utils import prepare_unit_data
+from foodviz.utils.config import COLOR_MAP, PROJECT_ROOT
+
+
+def run():
+    _sess_state = st.session_state
+
+    if "units_data" not in _sess_state:
+        path = PROJECT_ROOT / "data" / "units_with_e.csv"
+        _sess_state["units_df"] = prepare_unit_data(path, "")
+    if "tooltips" not in _sess_state:
+        _sess_state["tooltips"] = {
+            "mg": "Milligrams",
+            "g": "Grams",
+            "kg": "Kilograms",
+            "ug": "Micrograms",
+            "kJ": "Kilojoules",
+        }
+
+    def highlight_category(val, df):
+        val = df.loc[df["name"] == val, "grup"].values[0].upper()
+        return f"background-color: {COLOR_MAP[val]}"
+
+    def get_food_code(extra_cols=None) -> list:
+        if extra_cols is None:
+            extra_cols = []
+        ss = _sess_state["units_df"].loc[
+            (_sess_state["units_df"]["name"].isin(_sess_state["nutrient"])), ["code"] + extra_cols]
+        return ss[~ss.code.str.endswith("_e")].values.T.tolist()
+
+    @st.cache_data(ttl=600)
+    def get_nutrient_column(table: str, return_columns: str = "*", as_df: bool = True):
+        return_columns = f"name, {return_columns}"
+        res = _sess_state["_conn"].table(table).select(return_columns).execute()
+        if as_df:
+            return pd.DataFrame(res.data)
+        return res.data
+
+    st.header("📊 Nutrient Comparison Table Chart")
+
+    st.multiselect(
+        "Select Nutrient",
+        _sess_state["units_df"].loc[_sess_state["units_df"]["type"].isin(["mass", "energy"]), "name"].unique(),
+        key="nutrient",
+        max_selections=10,
+    )
+
+    st.empty()
+    if "nutrient" in _sess_state and _sess_state["nutrient"]:
+        cols = get_food_code(["name"])
+        cols, names = cols[0], cols[1]
+        cols.append("grup")
+        response = get_nutrient_column("food_ifct", return_columns=",".join(cols))
+        response.set_index("name", inplace=True)
+        config = {}
+        cols.remove("grup")
+        units = _sess_state["units_df"].loc[_sess_state["units_df"]["code"].isin(cols), "unit"].tolist()
+        factors = _sess_state["units_df"].loc[_sess_state["units_df"]["code"].isin(cols), "factor"].tolist()
+        for i in range(len(cols)):
+            response[cols[i]] = response[cols[i]] * factors[i]
+            config[cols[i]] = st.column_config.ProgressColumn(
+                f"{names[i].upper()}",
+                format=f"%.2f {units[i]}",
+                help=f"Values in {_sess_state['tooltips'][units[i]]}",
+                min_value=float(response[cols[i]].min()),
+                max_value=float(response[cols[i]].max()),
+            )
+
+        response.reset_index(inplace=True)
+        color_df = response[["name", "grup"]]
+        response.drop("grup", axis=1, inplace=True)
+        styled_df = response.style.map(highlight_category, df=color_df, subset=["name"])
+        st.dataframe(styled_df, column_config=config, use_container_width=True, height=500, hide_index=True)
+
+        with st.expander("Color Map Reference"):
+            text = []
+            for key, value in COLOR_MAP.items():
+                text.append(f"<span style='color:{value}'>{key}</span>")
+
+            st.markdown(" | ".join(text), unsafe_allow_html=True)

foodviz/pages/frontend/bubble.html

@@ -0,0 +1,180 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>D3.js Bubble Chart with Drag and Collision</title>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/d3/7.8.5/d3.min.js"></script>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+            margin: 0;
+            background-color: #373f51;
+        }
+        
+        .tooltip {
+            position: absolute;
+            background-color: rgba(0, 0, 0, 0.7);
+            color: white;
+            padding: 5px 10px;
+            border-radius: 5px;
+            font-size: 12px;
+            pointer-events: none;
+            opacity: 0;
+            transition: opacity 0.3s;
+        }
+        .bubble-label {
+            /* font-size: 10px; */
+            text-anchor: middle;
+            dominant-baseline: middle;
+            pointer-events: none;
+        }
+        svg {
+            background-color: #11131C;
+            box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+        }
+
+        image {
+            clip-path: inset(5% round 50%); 
+            position: relative;
+            /* top: -50%;
+            left: -50%; */
+        }
+    </style>
+</head>
+<body>
+    <svg width="800" height="600"></svg>
+    <div class="tooltip"></div>
+    <script>
+        const svg = d3.select("svg");
+const width = +svg.attr("width");
+const height = +svg.attr("height");
+const tooltip = d3.select(".tooltip");
+
+async function getData() {
+    try {
+        return await d3.csv('https://raw.githubusercontent.com/p1utoze/FoodViz/refs/heads/main/src/data/food-types.csv');
+    } catch (error) {
+        console.error("Error loading CSV:", error);
+        throw error;
+    }
+}
+
+async function initializeVisualization() {
+    const csvData = await getData();
+
+    // Find min and max of items
+    const items = csvData.map(d => +d.items);
+    const minItems = d3.min(items);
+    const maxItems = d3.max(items);
+
+    // Create a scale for the radius
+    const radiusScale = d3.scaleLinear()
+        .domain([minItems, maxItems])
+        .range([25, 100]);  // You can adjust these values to change the min and max bubble sizes
+
+    const data = csvData.map((k) => ({
+        id: k.grup,
+        r: radiusScale(+k.items),  // Use the scaled radius
+        name: k.grup,
+        url: k.url,
+        items: +k.items,  // Store the original items value
+        x: Math.random() * width,
+        y: Math.random() * height,
+        vx: 1,
+        vy: 1,
+    }));
+
+
+    console.log("Processed data:", data);
+
+    // Color scale
+    const color = d3.scaleOrdinal(d3.schemeCategory10);
+
+    // Create the simulation
+    const simulation = d3.forceSimulation(data)
+        .force("x", d3.forceX(width / 2).strength(0.05))
+        .force("y", d3.forceY(height / 2).strength(0.05))
+        .force("charge", d3.forceManyBody().strength(-10).distanceMin(d => d.r + 2))
+        .force("collide", d3.forceCollide().radius(d => d.r + 1).iterations(2));
+
+    // Create the bubbles
+    const bubbles = svg.selectAll("g")
+        .data(data)
+        .enter().append("g")
+        .call(d3.drag()
+            .on("start", dragstarted)
+            .on("drag", dragged)
+            .on("end", dragended))
+        .on("mouseover", showTooltip)
+        .on("mousemove", moveTooltip)
+        .on("mouseout", hideTooltip);
+
+    bubbles.append("circle")
+        .attr("r", d => d.r)
+        .attr("fill", (d, i) => color(i));
+
+    bubbles.append("image")
+        .attr("href", d => d.url)  // Use the URL from the CSV data
+        .attr("width", d => 2 * d.r)
+        .attr("height", d => 2 * d.r);
+
+    let draggedNode = null;
+
+    // Update bubble positions on each tick of the simulation
+    simulation.on("tick", () => {
+        bubbles.select("circle")
+            .attr("cx", d => d.x)
+            .attr("cy", d => d.y);
+        bubbles.select("image")
+            .attr("x", d => d.x - d.r)
+            .attr("y", d => d.y - d.r);
+
+        // Your existing collision detection code here
+        // ...
+    });
+
+    // Drag functions
+    function dragstarted(event, d) {
+        if (!event.active) simulation.alphaTarget(0.4).restart();
+        d.fx = d.x;
+        d.fy = d.y;
+    }
+
+    function dragged(event, d) {
+        d.fx = event.x;
+        d.fy = event.y;
+    }
+
+    function dragended(event, d) {
+        if (!event.active) simulation.alphaTarget(0);
+        d.fx = null;
+        d.fy = null;
+        draggedNode = null;
+    }
+
+    function showTooltip(event, d) {
+        tooltip.style("opacity", 1)
+            .html(`Name: ${d.name}<br>Items: ${d.items}`);
+        moveTooltip(event);
+    }
+
+    function moveTooltip(event) {
+        tooltip.style("left", (event.pageX + 10) + "px")
+               .style("top", (event.pageY - 10) + "px");
+    }
+
+    function hideTooltip() {
+        tooltip.style("opacity", 0);
+    }
+}
+
+// Call the function to initialize the visualization
+initializeVisualization().catch(error => console.error('Failed to initialize visualization:', error));
+    </script>
+</body>
+</html>

foodviz/pages/frontend/bubble.js

@@ -0,0 +1,112 @@
+const svg = d3.select("svg");
+const width = +svg.attr("width");
+const height = +svg.attr("height");
+const tooltip = d3.select(".tooltip");
+
+async function getData() {
+    try {
+        return await d3.csv('../../data/food-types.csv');
+    } catch (error) {
+        console.error("Error loading CSV:", error);
+        throw error;
+    }
+}
+
+async function initializeVisualization() {
+    const csvData = await getData();
+    const data = csvData.map((k) => ({
+        id: k.grup,  // Using 'grup' as id
+        r: +k.items, // Convert to number
+        name: k.grup,
+        url: k.url,
+        x: Math.random() * width,
+        y: Math.random() * height,
+        vx: 1,
+        vy: 1,
+    }));
+
+    console.log("Processed data:", data);
+
+    // Color scale
+    const color = d3.scaleOrdinal(d3.schemeCategory10);
+
+    // Create the simulation
+    const simulation = d3.forceSimulation(data)
+        .force("x", d3.forceX(width / 2).strength(0.05))
+        .force("y", d3.forceY(height / 2).strength(0.05))
+        .force("charge", d3.forceManyBody().strength(-10).distanceMin(d => d.r + 2))
+        .force("collide", d3.forceCollide().radius(d => d.r + 1).iterations(2));
+
+    // Create the bubbles
+    const bubbles = svg.selectAll("g")
+        .data(data)
+        .enter().append("g")
+        .call(d3.drag()
+            .on("start", dragstarted)
+            .on("drag", dragged)
+            .on("end", dragended))
+        .on("mouseover", showTooltip)
+        .on("mousemove", moveTooltip)
+        .on("mouseout", hideTooltip);
+
+    bubbles.append("circle")
+        .attr("r", d => d.r)
+        .attr("fill", (d, i) => color(i));
+
+    bubbles.append("image")
+        .attr("href", d => d.url)  // Use the URL from the CSV data
+        .attr("width", d => 1.5 * d.r)
+        .attr("height", d => 1.5 * d.r);
+
+    let draggedNode = null;
+
+    // Update bubble positions on each tick of the simulation
+    simulation.on("tick", () => {
+        bubbles.select("circle")
+            .attr("cx", d => d.x)
+            .attr("cy", d => d.y);
+        bubbles.select("image")
+            .attr("x", d => d.x - d.r * 0.75)
+            .attr("y", d => d.y - d.r * 0.75);
+
+        // Your existing collision detection code here
+        // ...
+    });
+
+    // Drag functions
+    function dragstarted(event, d) {
+        if (!event.active) simulation.alphaTarget(0.4).restart();
+        d.fx = d.x;
+        d.fy = d.y;
+    }
+
+    function dragged(event, d) {
+        d.fx = event.x;
+        d.fy = event.y;
+    }
+
+    function dragended(event, d) {
+        if (!event.active) simulation.alphaTarget(0);
+        d.fx = null;
+        d.fy = null;
+        draggedNode = null;
+    }
+
+    function showTooltip(event, d) {
+        tooltip.style("opacity", 1)
+            .html(`Name: ${d.name}<br>Items: ${d.r}`);
+        moveTooltip(event);
+    }
+
+    function moveTooltip(event) {
+        tooltip.style("left", (event.pageX + 10) + "px")
+               .style("top", (event.pageY - 10) + "px");
+    }
+
+    function hideTooltip() {
+        tooltip.style("opacity", 0);
+    }
+}
+
+// Call the function to initialize the visualization
+initializeVisualization().catch(error => console.error('Failed to initialize visualization:', error));

foodviz/pages/home.py

@@ -0,0 +1,72 @@
+import streamlit as st
+import streamlit.components.v1 as components
+from pathlib import Path
+from foodviz.utils.helpers import load_bubble_data
+from foodviz.utils.config import PROJECT_ROOT
+
+custom_chart = Path(__file__).parent / "frontend" / "bubble.html"
+chart_data = PROJECT_ROOT / "data" / "food-types.csv"
+
+def run():
+    empty = st.empty()
+    with empty.container():
+        col1, col2 = st.columns([1, 1])
+        col1.markdown(
+            """
+            <h1 style="font-size: 8em; font-weight: bold; color: #e63946;">FoodViz</h1>
+            <h3 style="font-size: 4em; color: #a8dadc;">Interactive Indian Food Composition Explorer</h3>
+            """,
+            unsafe_allow_html=True,
+        )
+        with open(custom_chart.absolute(), "r") as f:
+            canvas = f.read()
+
+        with col2:
+            components.html(canvas, height=600, width=800)
+        # col2.image(
+        #     "https://img.freepik.com/premium-photo/different-types-meats-vegetables-fruits-lay-"
+        #     "supermarkets-generative-ai_572887-4418.jpg",
+        #     use_column_width=True,
+        # )
+
+    st.divider()
+
+    with st.container():
+        cphrase = "Are you a Gym freak or a Health enthusiast?"
+        cphrase_sub = (
+            "Either way, you are at the right place! Explore the food composition of your favourite indian meals."
+        )
+        st.markdown(
+            f"""
+            <h2 style="font-size: 3em; font-weight: bold; text-align: center; color: #457b9d">{cphrase}</h2>
+            <h5 style="font-size: 2em; text-align: center;">{cphrase_sub}</h5>
+            """,
+            unsafe_allow_html=True,
+        )
+        st.divider()
+        st.markdown(
+            """
+            I have created this web app to help you find all the food related sources.
+            The explorer is based on the Indian Food Composition Table (IFCT) database which is a comprehensive database
+            consisting of **:blue[542 food items]**
+            My goal is to provide you with a simple and interactive way to discover and compare the nutritional contents
+            and values of different food items.
+
+            **:orange[The Indian Food Composition Table]** (IFCT) is a comprehensive database consisting of 542 food
+            items. The database provides information on the proximate principles and dietary fibre content of Indian
+            foods. The database is useful for nutritionists, dieticians, and health professionals for planning and
+            assessing diets.
+            """
+        )
+        st.divider()
+        st.subheader("How to use the explorer?")
+        st.markdown(
+            """
+            The explorer is divided into two main sections:
+            #### 👁‍🗨️ Viewer Page:
+            - :blue[**Overview**]: This tab provides a brief overview of the food item categorized by food groups.
+            - :blue[**Details**]: This tab provides detailed nutritional information about the selected food item's
+            various food compositions.
+            #### 📊 Comparison Page
+            """
+        )

foodviz/pages/search.py

@@ -0,0 +1,104 @@
+import streamlit as st
+from streamlit_card import card
+
+from foodviz.utils.config import PROJECT_ROOT
+from foodviz.utils.helpers import load_retriever, generate_color_range
+
+start_green = (0, 255, 0)
+end_red = (255, 0, 0)
+
+
+def run():
+    css = """
+        <style>
+            [data-testid="stMetricDelta"] svg {
+                display: none;
+            }
+            [data-testid="stMetricDelta"] > div::before {
+                content:"±";
+                font-weight: bold;
+                font-size: 1.3rem;
+            }
+        .row-gradient {
+            background: linear-gradient(to right, #ff7f50, #ffa500);
+            padding: 10px;
+            margin-bottom: 5px;
+            color: white;
+        }
+        </style>
+        """
+    st.markdown(css, unsafe_allow_html=True)
+    _sess_state = st.session_state
+
+    if "_conn" not in _sess_state:
+        st.error("Please connect to the database first.")
+        return
+
+    if "retriever" not in _sess_state:
+        data_store_path = PROJECT_ROOT / "data" / "context_storage"
+        _sess_state.retriever = load_retriever(data_store_path)
+
+    if "color_range" not in _sess_state:
+        _sess_state.color_range = generate_color_range(start_green, end_red, 5)
+
+    # Load and preprocess the data
+
+    # Define the search function
+    @st.cache_data(ttl=600)
+    def retrieve_top_matches_callback(query: str):
+        return _sess_state.retriever.retrieve(query)
+
+    # Streamlit app
+    st.title("Optimized Local Language Food Search")
+
+    # Use a container for dynamic updates
+    search_container = st.empty()
+
+    # Create a text input for search
+    search_query = search_container.text_input(
+        "Enter a food name in your local language",
+    )
+    if "idx" not in _sess_state:
+        _sess_state.idx = -1
+
+    # Perform search as user types
+    st.write("Top matches for the search query:")
+    if search_query:
+        nodes = retrieve_top_matches_callback(search_query)
+        node_len = len(nodes)
+        container = st.empty()
+        for i in range(node_len):
+            idx = node_len - i - 1
+            card(
+                title=f"{nodes[idx].text}",
+                text=f"Name: {nodes[idx].metadata['name']}  |   Scientific Name: {nodes[idx].metadata['scientific_name']}   |   Local Language: {nodes[idx].metadata['lang']} | Score: {nodes[idx].score}",
+                key=f"card_{idx}",
+                on_click=lambda: _sess_state.update({"idx": idx}),
+                styles={
+                    "card": {
+                        "width": "100%",
+                        "background-color": f"{_sess_state.color_range[i]}",
+                        "height": "100px",
+                        "border-radius": "15px",
+                        "box-shadow": "0 0 10px rgba(0,0,0,0.5)",
+                        "padding": "0px",
+                        "margin": "0px"
+                    }
+                },
+
+            )
+
+        # TODO: Create a sidebar that displays some information about the selected node
+        # st.write(f"Selected index: {_sess_state.idx}, Selected node: {nodes[_sess_state.idx].text}")
+    # Add some information about the search engine
+    st.sidebar.title("About")
+    st.sidebar.info(
+        "This optimized search engine allows you to find food items by their local language names. "
+        "It searches through various Indian languages and returns the top matches "
+        "for the common name and scientific name of the food item. "
+        "The search updates as you type for a more interactive experience."
+    )
+
+    # # Display some statistics
+    # st.sidebar.title("Statistics")
+    # st.sidebar.write(f"Total number of unique local names: {len(name_dict)}")

foodviz/pages/viewer.py

@@ -0,0 +1,334 @@
+import pandas as pd
+import streamlit as st
+from plotly import express as px, graph_objects as go
+from foodviz.utils import (
+    prepare_indian_geojson,
+    prepare_indian_languages,
+    prepare_unit_data,
+)
+from foodviz.utils.config import (
+    DB_FOOD_CODE_HEADER,
+    DB_FOOD_NAME_HEADER,
+    DB_FOOD_TAGS_HEADER,
+    DB_SCI_NAME_HEADER,
+    DB_TABLE_NAME,
+    PROJECT_ROOT,
+)
+from foodviz.utils.config import load_json
+
+
+def run():
+    css = """
+    <style>
+        [data-testid="stMetricDelta"] svg {
+            display: none;
+        }
+        [data-testid="stMetricDelta"] > div::before {
+            content:"±";
+            font-weight: bold;
+            font-size: 1.3rem;
+        }
+    </style>
+    """
+    st.markdown(css, unsafe_allow_html=True)
+
+    _sess_state = st.session_state
+
+    if "is_fil_row" in _sess_state:
+        del st.session_state["is_fil_row"]
+
+    if "gjson" not in _sess_state:
+        _sess_state["gjson"] = prepare_indian_geojson()
+
+    if "indian_states" not in _sess_state:
+        _sess_state["indian_states"] = prepare_indian_languages()
+
+    if "units_df" not in _sess_state:
+        path = PROJECT_ROOT / "data" / "units_with_e.csv"
+        _sess_state["units_df"] = prepare_unit_data(path)
+
+    if "fg" not in _sess_state:
+        _sess_state["fg"] = load_json()
+
+    if "selected_code" not in _sess_state:
+        _sess_state["selected_code"] = None
+
+    if "disable" not in st.session_state:
+        _sess_state["disabled"] = True
+
+    if "comp_name" not in _sess_state:
+        _sess_state["comp_name"] = None
+
+    @st.cache_data()
+    def fetch_image(file_name: str):
+        # _, _, image = _sess_state['_conn'].download(
+        #     bucket_id="indian_food",
+        #     source_path=file_name
+        # )
+        url = _sess_state["_conn"].get_public_url("indian_food", f"{file_name}.jpg")
+        # res = image.read()
+        return url
+
+    @st.cache_data(ttl=600)
+    def query_with_filter_like(table: str, column: str, value: str, return_columns: str = "*", as_df: bool = True):
+        response = _sess_state["_conn"].table(table).select(return_columns).like(column, f"{value}%25").execute()
+        if as_df:
+            return pd.DataFrame(response.data)
+        return response.data
+
+    @st.cache_data(ttl=600)
+    def query_with_filter_eq(table: str, column: str, value: str, return_columns: str = "*", as_df: bool = True):
+        response = _sess_state["_conn"].table(table).select(return_columns).eq(column, value).execute()
+        if as_df:
+            return pd.DataFrame(response.data)
+        return response.data
+
+    def tab1_box1_callback():
+        _sess_state["comp_name"] = None
+
+    st.header("🚚 IFCT Food Database Overview")
+    st.markdown("Choose the food group and food item from the dropdown to view the basic info of the food item. 👇")
+
+    tab1, tab2 = st.tabs(["🍽 Overview", "🔢 Nutritional Details"])
+    with tab1:
+        with st.container(height=100):
+            return_cols = f"{DB_FOOD_CODE_HEADER}, {DB_FOOD_NAME_HEADER}, {DB_SCI_NAME_HEADER}, {DB_FOOD_TAGS_HEADER}"
+            col1, col2 = st.columns(2, gap="large")
+            grp_name = col1.selectbox(
+                "Choose a food group: ",
+                _sess_state["fg"].keys(),
+                index=None,
+                placeholder="Select a food group",
+                on_change=tab1_box1_callback,
+            )
+            if grp_name:
+                fil_row = query_with_filter_like(
+                    return_columns=return_cols,
+                    table=DB_TABLE_NAME,
+                    column=DB_FOOD_CODE_HEADER,
+                    value=_sess_state["fg"][grp_name],
+                )
+                # fil_row = pd.DataFrame(fil_row.data)
+                sel = col2.selectbox(
+                    "Choose a food item: ",
+                    ["ALL"] + fil_row[DB_FOOD_NAME_HEADER].tolist(),
+                    index=None,
+                    placeholder="Select a food item",
+                )
+                if sel == "ALL":
+                    _sess_state["is_fil_row"] = False
+                    fil_row[DB_FOOD_TAGS_HEADER] = fil_row[DB_FOOD_TAGS_HEADER].str.split(" ")
+                    img_urls = [
+                        _sess_state["_conn"].get_public_url("indian_food", f"{code}.jpg")
+                        for code in fil_row[DB_FOOD_CODE_HEADER]
+                    ]
+                    fil_row["images"] = img_urls
+                elif sel:
+                    sel_name = sel
+                    _sess_state["disabled"] = False
+
+                    _sess_state["is_fil_row"] = True
+                    sel = fil_row.loc[fil_row[DB_FOOD_NAME_HEADER] == sel, DB_FOOD_CODE_HEADER].values[0]
+                    _sess_state["selected_code"] = sel
+            else:
+                _sess_state["selected_code"] = None
+
+        view = st.empty()
+        if "is_fil_row" in _sess_state and not _sess_state["is_fil_row"]:
+            st.data_editor(
+                fil_row,
+                column_config={
+                    "images": st.column_config.ImageColumn("Preview Image", help="Streamlit app preview screenshots"),
+                    "tags": st.column_config.ListColumn(
+                        "Diet Preferences", help="Dietary preferences for the food item"
+                    ),
+                },
+                hide_index=True,
+                use_container_width=True,
+            )
+
+        if "is_fil_row" in _sess_state and _sess_state["is_fil_row"]:
+            with view.container(height=600):
+                img = fetch_image(f"{sel}")
+                col1, col2 = view.columns(2, gap="large")
+                col2.image(img, use_column_width=True, caption=f"Image of {sel_name.upper()}")
+                sel_lang = query_with_filter_eq(
+                    return_columns="lang", table=DB_TABLE_NAME, column=DB_FOOD_CODE_HEADER, value=sel, as_df=False
+                )
+                sel_lang: list[str] = sel_lang[0]["lang"].split(";")
+                try:
+                    _ = sel_lang[0]
+                    sel_lang_code = pd.DataFrame(
+                        [lang.strip().split(" ", maxsplit=1) for lang in sel_lang], columns=["abbr", "name"]
+                    )
+                    df = pd.merge(sel_lang_code, _sess_state["indian_states"], left_on="abbr", right_on="abbr")
+                    all_states = pd.json_normalize(_sess_state["gjson"]["features"])["properties.ST_NM"]
+                    fig = px.choropleth(
+                        all_states,
+                        geojson=_sess_state["gjson"],
+                        locations="properties.ST_NM",
+                        featureidkey="properties.ST_NM",
+                        color_discrete_sequence=["lightgrey"],
+                        labels={"properties.ST_NM": "State"},
+                    )
+                    fig.add_trace(
+                        go.Choropleth(
+                            z=df["id"],
+                            name=sel,
+                            autocolorscale=False,
+                            geojson=_sess_state["gjson"],
+                            featureidkey="properties.ST_NM",
+                            locations=df["state"],
+                            locationmode="geojson-id",
+                            customdata=df[["state", "lang", "name"]],
+                            colorscale=px.colors.sequential.Inferno_r,
+                            uid=f"{sel}",
+                            hovertemplate="<br>".join(
+                                [
+                                    "<b>%{customdata[0]}</b><br>",
+                                    "Language: %{customdata[1]}",
+                                    "Known as: %{customdata[2]}",
+                                ]
+                            ),
+                        )
+                    )
+                    is_nepal = sel_lang_code["abbr"].str.contains("N.")
+                    if is_nepal.any():
+                        fig.add_trace(
+                            go.Choropleth(
+                                z=[1],
+                                customdata=pd.DataFrame(
+                                    {
+                                        "state": ["Nepal"],
+                                        "lang": "Nepali",
+                                        "name": sel_lang_code.loc[is_nepal, "name"].values[0],
+                                    }
+                                )[["state", "lang", "name"]],
+                                autocolorscale=False,
+                                reversescale=True,
+                                showscale=False,
+                                locationmode="ISO-3",
+                                locations=["NPL"],
+                                colorscale="greens",
+                                hovertemplate="<br>".join(
+                                    [
+                                        "<b>%{customdata[0]}</b><br>",
+                                        "Language: %{customdata[1]}",
+                                        "Known as: %{customdata[2]}",
+                                    ]
+                                ),
+                            )
+                        )
+                    fig.data[0]["name"] = "Toggle States"
+                    fig.data[1]["colorbar"]["len"] = 0.6
+                    fig.data[1]["colorbar"]["y"] = 0.5
+                    fig.data[1]["hoverlabel"]["bgcolor"] = "rgba(0, 0, 0, 0.9)"
+                    fig.data[1]["hoverlabel"]["bordercolor"] = "white"
+
+                except AssertionError:
+                    fig = px.choropleth(
+                        locations=["IND"],
+                        locationmode="ISO-3",
+                        color=[1],
+                        scope="asia",
+                        fitbounds="locations",
+                    )
+                    fig.data[0]["name"] = sel
+                    fig.data[0]["hovertemplate"] = f"<b>India</b><br>Language: English/Hindi<br>Known as: {sel_name}"
+                fig.update_geos(fitbounds="locations", visible=False)
+
+                fig.update_layout(
+                    geo=dict(bgcolor="rgba(14, 17, 20, 0.1)"),
+                    margin=dict(l=0, r=0, t=0, b=0),
+                    height=350,
+                    title=dict(
+                        text=f"Regional language distribution of {sel_name}",
+                        xanchor="center",
+                        x=0.5,
+                        xref="paper",
+                        yanchor="bottom",
+                        y=0.1,
+                        font_size=12,
+                        font_color="grey",
+                    ),
+                    legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01, font_size=15),
+                    modebar=dict(
+                        orientation="h",
+                        bgcolor=st._config.get_option("theme.backgroundColor"),
+                        color=st._config.get_option("theme.primaryColor"),
+                    ),
+                )
+
+                fig.update_mapboxes(domain=dict(x=[0, 0.5], y=[0, 1]))
+                col1.plotly_chart(fig, use_container_width=True)
+
+    with tab2:
+        with tab2.container(height=100):
+            st.selectbox(
+                "Choose a food composition category: ",
+                _sess_state["units_df"]["table_name"].dropna().unique(),
+                index=None,
+                key="comp_name",
+                placeholder="Select a food composition category",
+                disabled=_sess_state.disabled,
+            )
+
+        if _sess_state["disabled"]:
+            st.warning("Please select a food item from the Overview tab to view its composition details.")
+
+        if _sess_state["selected_code"]:
+            food_item_df = query_with_filter_eq(
+                return_columns="*", table=DB_TABLE_NAME, column=DB_FOOD_CODE_HEADER, value=_sess_state["selected_code"]
+            )
+            food_item_df = food_item_df.T.reset_index()
+            food_item_df.columns = ["code", "value"]
+            if _sess_state["comp_name"]:
+                cards = pd.merge(
+                    _sess_state["units_df"].loc[_sess_state["units_df"]["table_name"] == _sess_state["comp_name"]],
+                    food_item_df,
+                    left_on="code",
+                    right_on="code",
+                    how="inner",
+                )
+                cards["value"] = cards["value"].astype(float)
+                cards = cards.loc[cards["value"] != 0, :]
+                card_elements = cards.shape[0]
+                if not card_elements:
+                    st.info("No data available for the selected food composition. :red[Please Select different one.]")
+                    st.stop()
+
+                condition = cards["code"].str.endswith("_e")
+                item_indexes = cards.loc[~condition, :].index.tolist()
+                item_index_c, row_size = 0, 4
+                metric_containers = [st.container(height=175) for _ in range((len(item_indexes) - 1) // row_size + 1)]
+                for container in metric_containers:
+                    with container:
+                        columns = st.columns(row_size)
+                        for col in columns:
+                            try:
+                                current_index = item_indexes[item_index_c]
+                                measurement_unit = cards.at[current_index, "unit"]
+                                factor = cards.at[current_index, "factor"]
+                            except IndexError:
+                                break
+
+                            if _sess_state["selected_code"].startswith("T"):
+                                measurement_unit = "%"
+                                factor = 1
+
+                            with col:
+                                try:
+                                    delta_val = cards.at[current_index + 1, "value"] * factor
+                                    delta = f"{delta_val:.5f} {measurement_unit}"
+                                    delta_color = "normal"
+                                except KeyError:
+                                    delta = f"Nil {measurement_unit}"
+                                    delta_color = "off"
+
+                                st.metric(
+                                    label=cards.at[current_index, "name"],
+                                    value=f"{cards.at[current_index, 'value'] * factor:.5f} {measurement_unit}",
+                                    delta=delta,
+                                    delta_color=delta_color,
+                                )
+                                item_index_c += 1

foodviz/utils/__init__.py

@@ -0,0 +1,19 @@
+from dotenv import load_dotenv
+from st_supabase_connection import SupabaseConnection
+
+from .helpers import (
+    prepare_indian_geojson,
+    prepare_indian_languages,
+    prepare_unit_data,
+    load_bubble_data
+)
+
+load_dotenv()
+
+__all__ = [
+    "SupabaseConnection",
+    "prepare_indian_geojson",
+    "prepare_indian_languages",
+    "prepare_unit_data",
+    "load_bubble_data"
+]

foodviz/utils/color_slider.py

@@ -0,0 +1,91 @@
+import colorsys
+
+import streamlit as st
+import streamlit.components.v1 as components
+
+
+def get_color(value, min_value, max_value):
+    # Convert the value to a hue between 0 and 1
+    hue = (value - min_value) / (max_value - min_value)
+    # Convert HSV to RGB
+    rgb = colorsys.hsv_to_rgb(hue, 1, 1)
+    # Convert RGB to hex
+    return '#{:02x}{:02x}{:02x}'.format(int(rgb[0]*255), int(rgb[1]*255), int(rgb[2]*255))
+
+def color_changing_select_slider():
+    st.title("Color-Changing Select Slider")
+
+    options = list(range(0, 101, 10))
+    value = st.select_slider("Select a value", options=options)
+
+    color = get_color(value, min(options), max(options))
+
+    # Custom HTML and JavaScript for the color-changing slider
+    custom_slider = """
+    <div id="custom-slider" style="
+        width: 100%;
+        height: 20px;
+        background: linear-gradient(to right, #ff0000, #00ff00, #0000ff);
+        position: relative;
+        margin-top: 20px;
+    ">
+        <div id="slider-handle" style="
+            width: 20px;
+            height: 30px;
+            background-color: {color};
+            position: absolute;
+            top: -5px;
+            left: {value}%;
+            transform: translateX(-50%);
+            border-radius: 5px;
+            cursor: pointer;
+        "></div>
+    </div>
+    <p id="slider-value" style="text-align: center; margin-top: 10px;">Value: {value}</p>
+
+    <script>
+        const slider = document.getElementById('custom-slider');
+        const handle = document.getElementById('slider-handle');
+        const valueDisplay = document.getElementById('slider-value');
+
+        let isDragging = false;
+
+        handle.addEventListener('mousedown', (e) => {{
+            isDragging = true;
+            updateSlider(e);
+        }});
+
+        document.addEventListener('mousemove', (e) => {{
+            if (isDragging) {{
+                updateSlider(e);
+            }}
+        }});
+
+        document.addEventListener('mouseup', () => {{
+            isDragging = false;
+        }});
+
+        function updateSlider(e) {{
+            const rect = slider.getBoundingClientRect();
+            let x = e.clientX - rect.left;
+            x = Math.max(0, Math.min(x, rect.width));
+
+            const percentage = (x / rect.width) * 100;
+            handle.style.left = `${{percentage}}%`;
+
+            const value = Math.round(percentage / 10) * 10;
+            valueDisplay.textContent = `Value: ${value}`;
+
+            // Update Streamlit
+            Streamlit.setComponentValue(value);
+        }}
+    </script>
+    """.format(color=color, value=value)
+
+    components.html(custom_slider, height=100)
+
+    st.write(f"Selected value: {value}")
+    st.write(f"Color: {color}")
+
+if __name__ == "__main__":
+    color_changing_select_slider()

foodviz/utils/config.py

@@ -0,0 +1,78 @@
+from abc import ABC, abstractmethod
+from collections import OrderedDict
+from enum import Enum
+from json import load
+from pathlib import Path
+
+import streamlit as st
+
+GROUPS = Path(__file__).parent.parent / "data" / "food_groups.json"
+
+def load_json(file_path: str = GROUPS) -> dict:
+    with open(file_path, "r") as f:
+        return OrderedDict(load(f))
+
+class Page(ABC):
+    @abstractmethod
+    def write(self):
+        pass
+
+
+def add_custom_css():
+    st.markdown(
+        """
+        <style>
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+
+
+DB_TABLE_NAME = "food_ifct"
+DB_FOOD_NAME_HEADER = "name"
+DB_FOOD_CODE_HEADER = "code"
+DB_SCI_NAME_HEADER = "scie"
+DB_FOOD_TAGS_HEADER = "tags"
+
+# Path: config.py
+PROJECT_ROOT = Path(__file__).parent.parent
+
+COLOR_MAP = {
+    "CEREALS AND MILLETS": "#440154",
+    "GRAIN LEGUMES": "#471466",
+    "GREEN LEAFY VEGETABLES": "#472575",
+    "OTHER VEGETABLES": "#453681",
+    "FRUITS": "#3f4587",
+    "ROOTS AND TUBERS": "#39558b",
+    "CONDIMENTS AND SPICES": "#32628d",
+    "NUTS AND OIL SEEDS": "#2c708e",
+    "SUGARS": "#277c8e",
+    "MUSHROOMS": "#22898d",
+    "MISCELLANEOUS FOODS": "#1f968b",
+    "MILK AND MILK PRODUCTS": "#1fa386",
+    "EGG AND EGG PRODUCTS": "#29af7f",
+    "POULTRY": "#3dbb74",
+    "ANIMAL MEAT": "#55c666",
+    "MARINE FISH": "#74d054",
+    "MARINE SHELLFISH": "#95d73f",
+    "MARINE MOLLUSKS": "#bade27",
+    "FRESH WATER FISH AND SHELLFISH": "#dce218",
+    "EDIBLE OILS AND FATS": "#fde724",
+}
+
+
+class PPADF(Enum):
+    """Proximate Principles and Dietary Fibre."""
+
+    WATER = "Water"
+    ENERGY = "Energy"
+    PROTEIN = "Protein"
+    FAT = "Fat"
+    CARBOHYDRATES = "Carbohydrates"
+    FIBRE = "Fibre"
+    ASH = "Ash"
+    TOTAL = "Total"
+
+    @classmethod
+    def get_all(cls):
+        return [i.value for i in cls]

foodviz/utils/helpers.py

@@ -0,0 +1,70 @@
+import os
+
+import geopandas as gpd
+import pandas as pd
+import streamlit as st
+from llama_index.core import load_index_from_storage, StorageContext
+from llama_index.core.retrievers import BaseRetriever
+from llama_index.embeddings.voyageai import VoyageEmbedding
+from llama_index.vector_stores.faiss import FaissVectorStore
+
+from .config import PROJECT_ROOT
+
+
+@st.cache_data(show_spinner=":blue[Loading the database..] Please wait...", persist=True)
+def prepare_indian_geojson():
+    url = "https://raw.githubusercontent.com/Subhash9325/GeoJson-Data-of-Indian-States/master/Indian_States"
+    # url = PROJECT_ROOT / "data" / "INDIA_STATES.geojson"
+    gdf = gpd.read_file(url)
+    gdf["geometry"] = gdf.to_crs(gdf.estimate_utm_crs()).simplify(1000).to_crs(gdf.crs)
+    india_states = gdf.rename(columns={"NAME_1": "ST_NM"}).__geo_interface__
+    return india_states
+
+
+@st.cache_data()
+def prepare_indian_languages():
+    path = PROJECT_ROOT / "data" / "languages.csv"
+    df = pd.read_csv(path)
+    return df
+
+@st.cache_data()
+def prepare_unit_data(path: str, drop_col: str = "type") -> pd.DataFrame:
+    df = pd.read_csv(path)
+    if drop_col:
+        df.drop("type", axis=1, inplace=True)
+    return df
+
+def generate_color_range(start_rgb, end_rgb, steps):
+    """
+    Generate a color range between two RGB colors.
+
+    :param start_rgb: Tuple representing the starting RGB color.
+    :param end_rgb: Tuple representing the ending RGB color.
+    :param steps: Number of steps in the color range.
+    :return: List of interpolated RGB colors.
+    """
+    color_range = []
+    for t in range(steps + 1):  # +1 to ensure the end color is included
+        r = int(start_rgb[0] * (1 - t/steps) + end_rgb[0] * (t/steps))
+        g = int(start_rgb[1] * (1 - t/steps) + end_rgb[1] * (t/steps))
+        b = int(start_rgb[2] * (1 - t/steps) + end_rgb[2] * (t/steps))
+        color_range.append(f"rgb({r} {g} {b})")
+    return color_range
+
+@st.cache_resource
+def load_retriever(persist_dir: str, top_k: int = 5) -> BaseRetriever:
+    embed_model = VoyageEmbedding(model_name="voyage-large-2", voyage_api_key=os.environ["VOYAGE_API_KEY"])
+    storage_context = StorageContext.from_defaults(
+        vector_store=FaissVectorStore.from_persist_dir(persist_dir),
+        persist_dir=persist_dir,
+    )
+    loaded_index = load_index_from_storage(storage_context, embed_model=embed_model, show_progress=True)
+    return loaded_index.as_retriever(similarity_top_k=top_k, vector_store_query_mode="semantic_hybrid", vector_store_kwargs={"alpha": 0.1})
+
+@st.cache_data
+def load_bubble_data(df_path: str ):
+    df = pd.read_csv(df_path)
+    query = lambda x: st.session_state["_conn"].storage.from_('indian_food').get_public_url(f'food-classes/{x.capitalize()}.jpg')
+    df["url"] = df["grup"].apply(query)
+    return df
+    

foodviz/utils/state.py

@@ -0,0 +1,100 @@
+from copy import deepcopy
+from typing import Dict, Any
+
+from streamlit.runtime import get_instance
+from streamlit.runtime.legacy_caching.hashing import _CodeHasher
+from streamlit.runtime.scriptrunner import get_script_run_ctx
+
+
+class _SessionState:
+    def __init__(self, session, hash_funcs):
+        """Initialize SessionState instance."""
+        self.__dict__["_state"] = {
+            "data": {},
+            "hash": None,
+            "hasher": _CodeHasher(hash_funcs),
+            "is_rerun": False,
+            "session": session,
+        }
+
+    def __call__(self, **kwargs):
+        """Initialize state data once."""
+        for item, value in kwargs.items():
+            if item not in self._state["data"]:
+                self._state["data"][item] = value
+
+    def __getitem__(self, item):
+        """Return a saved state value, None if item is undefined."""
+        return self._state["data"].get(item, None)
+
+    def __getattr__(self, item):
+        """Return a saved state value, None if item is undefined."""
+        return self._state["data"].get(item, None)
+
+    def __setitem__(self, item, value):
+        """Set state value."""
+        self._state["data"][item] = value
+
+    def __setattr__(self, item, value):
+        """Set state value."""
+        self._state["data"][item] = value
+
+    def clear(self):
+        """Clear session state and request a rerun."""
+        self._state["data"].clear()
+        self._state["session"].request_rerun()
+
+    def sync(self):
+        """Rerun the app with all state values up to date from the beginning to fix rollbacks."""
+
+        # Ensure to rerun only once to avoid infinite loops
+        # caused by a constantly changing state value at each run.
+        #
+        # Example: state.value += 1
+        if self._state["is_rerun"]:
+            self._state["is_rerun"] = False
+
+        elif self._state["hash"] is not None:
+            if self._state["hash"] != self._state["hasher"].to_bytes(
+                self._state["data"], None
+            ):
+                self._state["is_rerun"] = True
+                self._state["session"].request_rerun(None)
+
+        self._state["hash"] = self._state["hasher"].to_bytes(self._state["data"], None)
+
+
+def _get_session():
+    runtime = get_instance()
+    session_id = get_script_run_ctx().session_id
+    session_info = runtime._session_mgr.get_session_info(session_id)
+
+    if session_info is None:
+        raise RuntimeError("Couldn't get your Streamlit Session object.")
+
+    return session_info.session
+
+def get_state(hash_funcs=None):
+    session = _get_session()
+
+    if not hasattr(session, "_custom_session_state"):
+        session._custom_session_state = _SessionState(session, hash_funcs)
+
+    return session._custom_session_state
+
+# Only used for separating namespace, everything can be saved at state variable as well.
+CONFIG_DEFAULTS: Dict[str, Any] = {"slider_value": 0}
+
+def provide_state(hash_funcs=None):
+    def inner(func):
+        def wrapper(*args, **kwargs):
+            state = get_state(hash_funcs=hash_funcs)
+            if state.client_config is None:
+                state.client_config = deepcopy(CONFIG_DEFAULTS)
+
+            return_value = func(state=state, *args, **kwargs)
+            state.sync()
+            return return_value
+
+        return wrapper
+    return inner

pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "ifct-viz"
+version = "0.1.0"
+description = ""
+authors = ["p1utoze <1ds21ai001@dsce.edu.in>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+asyncpg = "^0.29.0"
+python-dotenv = "^1.0.1"
+pydantic-settings = "^2.2.1"
+streamlit = "^1.32.2"
+st-supabase-connection = "^1.2.2"
+plotly = "^5.20.0"
+plotly-geo = "^1.0.0"
+geopandas = "^0.14.3"
+streamlit-antd-components = "^0.3.2"
+matplotlib = "^3.8.3"
+
+
+[tool.poetry.group.dev.dependencies]
+rich = "^13.7.1"
+pdfservices-sdk = "^2.3.1"
+ploomber-cloud = "^0.1.19"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

requirements.dev.txt

@@ -0,0 +1,27 @@
+build==0.9.0 ; python_version >= "3.10" and python_version < "4.0"
+certifi==2022.12.7 ; python_version >= "3.10" and python_version < "4.0"
+cffi==1.15.1 ; python_version >= "3.10" and python_version < "4.0"
+charset-normalizer==2.0.12 ; python_version >= "3.10" and python_version < "4.0"
+colorama==0.4.6 ; python_version >= "3.10" and python_version < "4.0" and os_name == "nt"
+cryptography==3.4.6 ; python_version >= "3.10" and python_version < "4.0"
+idna==3.6 ; python_version >= "3.10" and python_version < "4.0"
+markdown-it-py==3.0.0 ; python_version >= "3.10" and python_version < "4.0"
+mdurl==0.1.2 ; python_version >= "3.10" and python_version < "4.0"
+multipart==0.2.4 ; python_version >= "3.10" and python_version < "4.0"
+packaging==21.3 ; python_version >= "3.10" and python_version < "4.0"
+pdfservices-sdk==2.3.1 ; python_version >= "3.10" and python_version < "4.0"
+pep517==0.13.0 ; python_version >= "3.10" and python_version < "4.0"
+polling2==0.5.0 ; python_version >= "3.10" and python_version < "4.0"
+polling==0.3.2 ; python_version >= "3.10" and python_version < "4.0"
+pycparser==2.21 ; python_version >= "3.10" and python_version < "4.0"
+pygments==2.14.0 ; python_version >= "3.10" and python_version < "4.0"
+pyjwt==2.4.0 ; python_version >= "3.10" and python_version < "4.0"
+pyparsing==3.0.9 ; python_version >= "3.10" and python_version < "4.0"
+pyyaml==6.0 ; python_version >= "3.10" and python_version < "4.0"
+requests-toolbelt==0.10.1 ; python_version >= "3.10" and python_version < "4.0"
+requests==2.27.1 ; python_version >= "3.10" and python_version < "4.0"
+rich==13.7.1 ; python_version >= "3.10" and python_version < "4.0"
+six==1.16.0 ; python_version >= "3.10" and python_version < "4.0"
+toml==0.10.2 ; python_version >= "3.10" and python_version < "4.0"
+tomli==2.0.1 ; python_version >= "3.10" and python_version < "3.11"
+urllib3==1.26.13 ; python_version >= "3.10" and python_version < "4.0"

requirements.txt

@@ -0,0 +1,80 @@
+altair==5.3.0 ; python_version >= "3.10" and python_version < "4.0"
+annotated-types==0.6.0 ; python_version >= "3.10" and python_version < "4.0"
+anyio==4.3.0 ; python_version >= "3.10" and python_version < "4.0"
+async-timeout==4.0.3 ; python_version >= "3.10" and python_version < "3.12.0"
+asyncpg==0.29.0 ; python_version >= "3.10" and python_version < "4.0"
+attrs==23.2.0 ; python_version >= "3.10" and python_version < "4.0"
+blinker==1.7.0 ; python_version >= "3.10" and python_version < "4.0"
+cachetools==5.3.3 ; python_version >= "3.10" and python_version < "4.0"
+certifi==2022.12.7 ; python_version >= "3.10" and python_version < "4.0"
+charset-normalizer==2.0.12 ; python_version >= "3.10" and python_version < "4.0"
+click==8.1.7 ; python_version >= "3.10" and python_version < "4.0"
+click-plugins==1.1.1 ; python_version >= "3.10" and python_version < "4.0"
+cligj==0.7.2 ; python_version >= "3.10" and python_version < "4"
+colorama==0.4.6 ; python_version >= "3.10" and python_version < "4.0" and platform_system == "Windows"
+deprecation==2.1.0 ; python_version >= "3.10" and python_version < "4.0"
+exceptiongroup==1.2.0 ; python_version >= "3.10" and python_version < "3.11"
+fiona==1.9.6 ; python_version >= "3.10" and python_version < "4.0"
+geopandas==0.14.3 ; python_version >= "3.10" and python_version < "4.0"
+gitdb==4.0.11 ; python_version >= "3.10" and python_version < "4.0"
+gitpython==3.1.43 ; python_version >= "3.10" and python_version < "4.0"
+gotrue==2.4.2 ; python_version >= "3.10" and python_version < "4.0"
+h11==0.14.0 ; python_version >= "3.10" and python_version < "4.0"
+httpcore==1.0.5 ; python_version >= "3.10" and python_version < "4.0"
+httpx==0.27.0 ; python_version >= "3.10" and python_version < "4.0"
+idna==3.6 ; python_version >= "3.10" and python_version < "4.0"
+jinja2==3.1.3 ; python_version >= "3.10" and python_version < "4.0"
+jsonschema==4.21.1 ; python_version >= "3.10" and python_version < "4.0"
+jsonschema-specifications==2023.12.1 ; python_version >= "3.10" and python_version < "4.0"
+markdown-it-py==3.0.0 ; python_version >= "3.10" and python_version < "4.0"
+markupsafe==2.1.5 ; python_version >= "3.10" and python_version < "4.0"
+mdurl==0.1.2 ; python_version >= "3.10" and python_version < "4.0"
+numpy==1.26.4 ; python_version >= "3.10" and python_version < "4.0"
+packaging==21.3 ; python_version >= "3.10" and python_version < "4.0"
+pandas==2.2.1 ; python_version >= "3.10" and python_version < "4.0"
+pillow==10.3.0 ; python_version >= "3.10" and python_version < "4.0"
+plotly==5.20.0 ; python_version >= "3.10" and python_version < "4.0"
+plotly-geo==1.0.0 ; python_version >= "3.10" and python_version < "4.0"
+postgrest==0.16.2 ; python_version >= "3.10" and python_version < "4.0"
+protobuf==4.25.3 ; python_version >= "3.10" and python_version < "4.0"
+pyarrow==15.0.2 ; python_version >= "3.10" and python_version < "4.0"
+pydantic==2.6.4 ; python_version >= "3.10" and python_version < "4.0"
+pydantic-core==2.16.3 ; python_version >= "3.10" and python_version < "4.0"
+pydantic-settings==2.2.1 ; python_version >= "3.10" and python_version < "4.0"
+pydeck==0.8.0 ; python_version >= "3.10" and python_version < "4.0"
+pygments==2.14.0 ; python_version >= "3.10" and python_version < "4.0"
+pyparsing==3.0.9 ; python_version >= "3.10" and python_version < "4.0"
+pyproj==3.6.1 ; python_version >= "3.10" and python_version < "4.0"
+python-dateutil==2.9.0.post0 ; python_version >= "3.10" and python_version < "4.0"
+python-dotenv==1.0.1 ; python_version >= "3.10" and python_version < "4.0"
+pytz==2024.1 ; python_version >= "3.10" and python_version < "4.0"
+realtime==1.0.3 ; python_version >= "3.10" and python_version < "4.0"
+referencing==0.34.0 ; python_version >= "3.10" and python_version < "4.0"
+requests==2.32.3 ; python_version >= "3.10" and python_version < "4.0"
+rich==13.7.1 ; python_version >= "3.10" and python_version < "4.0"
+rpds-py==0.18.0 ; python_version >= "3.10" and python_version < "4.0"
+shapely==2.0.3 ; python_version >= "3.10" and python_version < "4.0"
+six==1.16.0 ; python_version >= "3.10" and python_version < "4.0"
+smmap==5.0.1 ; python_version >= "3.10" and python_version < "4.0"
+sniffio==1.3.1 ; python_version >= "3.10" and python_version < "4.0"
+st-supabase-connection==1.2.2 ; python_version >= "3.10" and python_version < "4.0"
+storage3==0.7.4 ; python_version >= "3.10" and python_version < "4.0"
+streamlit==1.32.2 ; python_version >= "3.10" and python_version < "4.0"
+streamlit-antd-components==0.3.2 ; python_version >= "3.10" and python_version < "4.0"
+strenum==0.4.15 ; python_version >= "3.10" and python_version < "4.0"
+supabase==2.4.1 ; python_version >= "3.10" and python_version < "4.0"
+supafunc==0.4.5 ; python_version >= "3.10" and python_version < "4.0"
+tenacity==8.2.3 ; python_version >= "3.10" and python_version < "4.0"
+toml==0.10.2 ; python_version >= "3.10" and python_version < "4.0"
+toolz==0.12.1 ; python_version >= "3.10" and python_version < "4.0"
+tornado==6.4 ; python_version >= "3.10" and python_version < "4.0"
+typing-extensions==4.10.0 ; python_version >= "3.10" and python_version < "4.0"
+tzdata==2024.1 ; python_version >= "3.10" and python_version < "4.0"
+urllib3==1.26.13 ; python_version >= "3.10" and python_version < "4.0"
+watchdog==4.0.0 ; python_version >= "3.10" and python_version < "4.0" and platform_system != "Darwin"
+websockets==12.0 ; python_version >= "3.10" and python_version < "4.0"
+streamlit-card==1.0.2 ; python_version >= "3.10" and python_version < "4.0"
+llama-index==0.10.55 ; python_version >= "3.10" and python_version < "4.0"
+llama-index-embeddings-voyageai==0.1.4 ; python_version >= "3.10" and python_version < "4.0"
+faiss-cpu==1.8.0.post1 ; python_version >= "3.10" and python_version < "4.0"
+llama-index-vector-stores-faiss==0.1.2 ; python_version >= "3.10" and python_version < "4.0"