Refactor code (#15)

Dockerfile

@@ -14,11 +14,11 @@ ENV POETRY_CACHE_DIR=/opt/.cache
 
 WORKDIR /home/
 
-COPY pyproject.toml poetry.lock app.py README.md ./
+COPY pyproject.toml poetry.lock README.md ./
 COPY src ./src/
 
 RUN poetry install --without dev
 
 EXPOSE 7860
 
-ENTRYPOINT ["poetry", "run", "streamlit", "run", "app.py", "--server.port", "7860"]
+ENTRYPOINT ["poetry", "run", "streamlit", "run", "src/maorganizer/ui.py", "--server.port", "7860"]

app.py

@@ -1,79 +0,0 @@
-from pathlib import Path
-import streamlit as st
-
-from maorganizer.datawrangling import Person
-
-from maorganizer.ui import TASKS, render_xlsx_download_button, create_file_uploader, create_task_selector
-
-# all these beautiful emojis from https://emojidb.org/file-emojis
-
-st.title("📅 Meeting Attendance Organizer")
-st.markdown("This app fullfills a simple need: Take a list of names of people attending a meeting and peform one (or multiple) of the following tasks:")
-st.markdown("""* ✂️ Split their names into first name and surname\n* 👀 Compare two lists with each other and see who is new on the second list\n * 🔎 Find people in a list by either searching for their complete names or parts of their name\n * 💾 Write any of the results back out, so you can share it with others""")
-
-st.header("📂 Step 1: Upload your Files")
-st.markdown("Upload the file(s) containing your meeting attendees. The expected format is a single column containing the attendees' full names. If you column name is not Name, you will be able to specify the column name after uploading the data. Additional columns will be ignored.")
-
-
-meetings = {}
-meetings = create_file_uploader()
-
-task = create_task_selector()
-
-st.header("🔥 Step 3: Let's Go!")
-st.subheader(f"You are going to ... {task}")
-if not meetings:
-    st.info("⬆ You need to upload some data first ⬆") 
-
-if meetings:
-    if task == TASKS.SPLIT.value:
-
-        filename = st.selectbox("Choose a file 📄", options=list(meetings.keys()), key=task)
-
-        render_xlsx_download_button({'Full list of Attendees': meetings[filename]},
-                                      filename=f"processed-attendees-{Path(filename).stem}.xlsx",
-                                      key=TASKS.SPLIT.value+'download')
-
-    elif task == TASKS.FIND.value:
-
-        filename = st.selectbox("📄 Choose a file", options=list(meetings.keys()), key=task)
-        attendees = meetings[filename]
-        
-        textinput = st.text_input("🔎 Who are you looking for? If you are looking for more than one, separate them by comma.")
-        st.markdown("⚠️ By default, the algorithm will surface any names that contain your search terms as substrings (e.g. if you search for Jon, it will surface both Jon and Jonathan). Tick the box below in case you want to display only entries where one of the names matches your search string exactly.")
-        st.markdown("⚠️⚠️ Note that either way the search is case-insensitive.")
-        exact_match = st.checkbox("Find Exact Name")
-
-        if textinput.strip():
-            st.header("Search Results")
-            if exact_match:
-                people_to_find = [Person(word.strip()) for word in textinput.split(',')]
-
-                for to_find, found in attendees.find_people(people_to_find).items():
-                    st.subheader(f"**{to_find.name}**")
-                    st.markdown(f"{', '.join([p.name for p in found]) if found else 'Sorry, none found.'}")
-            else:
-                words_to_find = [word.strip() for word in textinput.split(',')]
-
-                for word_to_find, people_found in attendees.find_words(words_to_find).items():
-                    st.subheader(f"**{word_to_find}**")
-                    st.markdown(f"{', '.join([p.name for p in people_found]) if people_found else 'Sorry, none found.'}")
-
-    elif task == TASKS.COMPARE.value:
-        col1, col2 = st.columns(2)
-        with col1:
-            filename_old = st.selectbox("Choose your original file", options=list(meetings.keys()), key=task)
-        with col2:
-            filename_new = st.selectbox("Choose your updated file", options=set(meetings.keys()) - {filename_old})
-
-        # filename_new gets automatically populated if there is more than one file
-        # so if there is none, it's because there is only a single file available and no options left for filename_new
-        if filename_new is None:
-            st.info("⬆ Please upload a second file. ⬆")
-        else:
-            listcomparison = (
-            {'Original List': meetings[filename_old],
-             'Updated List - Full': meetings[filename_new],
-             'Updated List - Only Updates': meetings[filename_old].update(meetings[filename_new])})
-
-            render_xlsx_download_button(listcomparison, filename=f"{Path(filename_old).stem}-updated.xlsx", key=TASKS.COMPARE.value+'download')

src/maorganizer/datawrangling.py

@@ -5,6 +5,9 @@ from typing import List, Set
 
 import pandas as pd
 
+CSV_EXTENSIONS = [".csv", ".txt"]
+EXCEL_EXTENSIONS = [".xls", ".xlsx"]
+
 DATAFOLDER = Path().cwd() / "data"
 
 NAMECOLUMN = "Name"
@@ -46,15 +49,15 @@ class Person:
 class Attendancelist:
     participants: Set[Person]
 
-    def load_from_df(df, cname: str = NAMECOLUMN):
+    def from_df(df, cname: str = NAMECOLUMN):
         return Attendancelist({Person(name) for name in df[cname]})
 
-    def load_from_file(
+    def from_file(
         filename: pathlib.PosixPath, cname: str = NAMECOLUMN, sep: str = None
     ):
-        if filename.suffix in [".xlsx", ".xls"]:
+        if filename.suffix in EXCEL_EXTENSIONS:
             df = pd.read_excel(filename)
-        elif filename.suffix == ".csv":
+        elif filename.suffix in CSV_EXTENSIONS:
             df = pd.read_csv(filename, sep=sep)
         else:
             raise ValueError(
@@ -62,7 +65,7 @@ class Attendancelist:
                 "of the following filetypes: .xlsx, .xls, .csv"
             )
 
-        return Attendancelist.load_from_df(df, cname)
+        return Attendancelist.from_df(df, cname)
 
     @property
     def n_attendees(self):
@@ -99,8 +102,11 @@ class Attendancelist:
     def find_people(self, people: List[Person]):
         return {p: self.find_person(p) for p in people}
 
-    def find_word(self, word: str):
-        return {p for p in self.participants if p.name_contains(word.lower())}
+    def find_by_string(self, word: str, exact=False):
+        if exact:
+            return self.find_person(Person(word))
+        else:
+            return {p for p in self.participants if p.name_contains(word.lower())}
 
-    def find_words(self, words: List[str]):
-        return {word: self.find_word(word) for word in words}
+    def find_by_strings(self, to_be_found: List[str], exact=False):
+        return {tbf: self.find_by_string(tbf, exact=exact) for tbf in to_be_found}

src/maorganizer/ui.py

@@ -1,77 +1,250 @@
 import io
-from enum import Enum
+import types
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, Tuple
+from typing import Dict
 
 import pandas as pd
 import streamlit as st
 
-from maorganizer.datawrangling import NAMECOLUMN, Attendancelist
+from maorganizer.datawrangling import (
+    CSV_EXTENSIONS,
+    EXCEL_EXTENSIONS,
+    NAMECOLUMN,
+    Attendancelist,
+)
 
-CSV_EXTENSIONS = [".csv", ".txt"]
-EXCEL_EXTENSIONS = [".xls", ".xlsx"]
 ACCEPTED_EXTENSIONS = CSV_EXTENSIONS + EXCEL_EXTENSIONS
 
-
 SEPARATORTYPES = {"TAB": "\t", "COMMA": ","}
 
 
-class TASKS(str, Enum):
-    SPLIT = "✂️ ... split attendees into first and last name and download results"
-    COMPARE = " 👀 ... compare two meetings with each other and find updates"
-    FIND = " 🔎 ... find specific attendees"
+@dataclass
+class Task:
+    abbreviation: str
+    short_description: str
+    long_description: str
+    run: types.FunctionType
 
-    def __str__(self) -> str:  # makes enum values duck-type to strings
-        return str.__str__(self)
 
+@dataclass
+class Tasks:
+    tasks: list[Task]
 
-def load_df_from_uploaded_data(filename, data, sep=None) -> pd.DataFrame:
-    if Path(filename).suffix in EXCEL_EXTENSIONS:
-        try:
-            df = pd.read_excel(data)
-        # If engine does not recognize excel as excel, it is likely to be
-        # a text format "disguised" as xls.
-        # (example: PyData Meeting files have .xls extension, but are in fact text files)
-        except ValueError as e:
-            if (
-                str(e)
-                == "Excel file format cannot be determined, you must specify an engine manually."
-            ):
-                st.info(
-                    f"Your {Path(filename).suffix} file does not seem to be an excel file.\\\n\\\n"
-                    "\- Trying to parse it as text file."
-                )
-                df = pd.read_csv(data, sep=sep)
-            else:
-                raise ValueError(e)
-    elif Path(filename).suffix in CSV_EXTENSIONS:
-        df = pd.read_csv(data, sep=sep)
+    def __post_init__(self):
+        assert len(self.abbreviations) == len(set(self.abbreviations))
+        assert len(self.short_descriptions) == len(set(self.abbreviations))
+
+    @property
+    def abbreviations(self):
+        return [task.abbreviation for task in self.tasks]
+
+    @property
+    def short_descriptions(self):
+        return [task.short_description for task in self.tasks]
+
+
+def split_names(meetings: Dict[str, Attendancelist]) -> None:
+    filename = st.selectbox(
+        "Choose a file 📄", options=list(meetings.keys()), key="split_names"
+    )
+
+    render_xlsx_download_button(
+        {"Full list of Attendees": meetings[filename]},
+        filename=f"processed-attendees-{Path(filename).stem}.xlsx",
+    )
+
+
+def find_attendees(meetings: Dict[str, Attendancelist]) -> None:
+    def _render_findings(to_be_found, people_found):
+        st.subheader(f"**{to_be_found}**")
+        st.markdown(
+            f"{', '.join([p.name for p in people_found]) if people_found else 'Sorry, none found.'}"
+        )
+
+    filename = st.selectbox(
+        "📄 Choose a file", options=list(meetings.keys()), key="find_attendees"
+    )
+    attendees = meetings[filename]
+
+    textinput = st.text_input(
+        "🔎 Who are you looking for? If you are looking for more than one, separate them by comma."
+    )
+    if textinput:
+        searchterms = [(word.strip()) for word in textinput.strip().split(",")]
     else:
-        raise ValueError(
-            f"Please choose one of the following extensions: {', '.join(ACCEPTED_EXTENSIONS)}"
+        searchterms = []
+
+    st.markdown(
+        "⚠️ By default, the algorithm will surface any names that contain your search terms"
+        " as substrings (e.g. if you search for Jon, it will surface both Jon and Jonathan)."
+        " Tick the box below in case you want to display only entries where one of the names"
+        " matches your search string exactly."
+    )
+    st.markdown("⚠️⚠️ Note that either way the search is case-insensitive.")
+    exact_match = st.checkbox("Find Exact Name")
+
+    if searchterms:
+        st.header("Search Results")
+
+        for to_be_found, found in attendees.find_by_strings(
+            searchterms, exact=exact_match
+        ).items():
+            _render_findings(to_be_found, found)
+
+
+def compare_meetings(meetings: Dict[str, Attendancelist]) -> None:
+    col1, col2 = st.columns(2)
+    with col1:
+        filename_old = st.selectbox(
+            "Choose your original file", options=list(meetings.keys())
+        )
+    with col2:
+        filename_new = st.selectbox(
+            "Choose your updated file", options=set(meetings.keys()) - {filename_old}
         )
-    return df
+
+    # filename_new gets automatically populated if there is more than one file
+    # so if there is none, it's because there is only a single file available
+    # and no options left for filename_new
+    if filename_new is None:
+        st.info("⬆ Please upload a second file. ⬆")
+    else:
+        listcomparison = {
+            "Original List": meetings[filename_old],
+            "Updated List - Full": meetings[filename_new],
+            "Updated List - Only Updates": meetings[filename_old].update(
+                meetings[filename_new]
+            ),
+        }
+
+        render_xlsx_download_button(
+            listcomparison,
+            filename=f"{Path(filename_old).stem}-updated.xlsx",
+        )
+
+
+def create_tasks() -> Tasks:
+    return Tasks(
+        [
+            Task(
+                abbreviation="SPLIT",
+                short_description=(
+                    "✂️ ... split attendees into first"
+                    "and last name and download results"
+                ),
+                long_description=(
+                    "❔ **Description:** Split a list of names"
+                    " into first and surname."
+                ),
+                run=split_names,
+            ),
+            Task(
+                abbreviation="COMPARE",
+                short_description=" 👀 ... compare two meetings with each other and find updates",
+                long_description=(
+                    "❔ **Description:** Compare two attendee lists"
+                    " with each and find attendees who have recently joined."
+                ),
+                run=compare_meetings,
+            ),
+            Task(
+                abbreviation="FIND",
+                short_description=" 🔎 ... find specific attendees",
+                long_description=(
+                    "❔ **Description:** Find attendees in a list"
+                    " by either first name or surname or by substrings."
+                ),
+                run=find_attendees,
+            ),
+        ]
+    )
+
+
+def render_xlsx_download_button(
+    meetings: Dict[str, Attendancelist], filename: str
+) -> None:
+    with io.BytesIO() as output:
+        with pd.ExcelWriter(output, engine="openpyxl") as writer:
+            for sheetname, attendees in meetings.items():
+                attendees.to_df().to_excel(writer, sheet_name=sheetname, index=False)
+
+        st.download_button(
+            label="💾 Download Results",
+            data=output.getvalue(),
+            file_name=filename,
+            mime="application/vnd.ms-excel",
+        )
+
+
+def select_task(tasks: Tasks) -> Task:
+    selected_task = st.radio("I would like to ...", tasks.short_descriptions)
+
+    for task in tasks.tasks:
+        if task.short_description == selected_task:
+            st.markdown(task.long_description)
+            break
+
+    return task
 
 
-def make_attendance_data_from_file_uploads(
-    uploaded_files, sep=None, cname=NAMECOLUMN
-) -> Dict:
-    return {
-        file.name: Attendancelist.load_from_df(
-            load_df_from_uploaded_data(file.name, file, sep), cname=cname
+def render_file_analysis(meetings: Dict[str, Attendancelist]) -> None:
+    show_processed_list = st.checkbox("Display the processed list of attendees")
+    if show_processed_list:
+        filename = st.selectbox(
+            "Select the file to display", options=list(meetings.keys())
         )
-        for file in uploaded_files
-    }
+        attendees = meetings[filename]
+
+        st.write(attendees.to_df())
 
 
-def load_data(uploaded_files) -> Tuple[Dict, bool]:
+def load_data(uploaded_files) -> Dict[str, Attendancelist]:
     def _files_contain_csv(uploaded_files) -> bool:
         return bool(
             sum([Path(file.name).suffix in CSV_EXTENSIONS for file in uploaded_files])
         )
 
+    def _load_df_from_uploaded_data(filename: str, data, sep=None) -> pd.DataFrame:
+        if Path(filename).suffix in EXCEL_EXTENSIONS:
+            try:
+                df = pd.read_excel(data)
+            # If engine does not recognize excel as excel, it is likely to be
+            # a text format "disguised" as xls.
+            # (example: PyData Meeting files have .xls extension, but are in fact text files)
+            except ValueError as e:
+                if str(e) == (
+                    "Excel file format cannot be determined,"
+                    " you must specify an engine manually."
+                ):
+                    st.info(
+                        f"Your {Path(filename).suffix} file does not seem"
+                        " to be an excel file.\\\n\\\n"
+                        "\- Trying to parse it as text file."
+                    )
+                    df = pd.read_csv(data, sep=sep)
+                else:
+                    raise ValueError(e)
+        elif Path(filename).suffix in CSV_EXTENSIONS:
+            df = pd.read_csv(data, sep=sep)
+        else:
+            raise ValueError(
+                f"Please choose one of the following extensions: {', '.join(ACCEPTED_EXTENSIONS)}"
+            )
+        return df
+
+    def _make_attendance_data_from_file_uploads(
+        uploaded_files, sep=None, cname=NAMECOLUMN
+    ) -> Dict[str, Attendancelist]:
+        return {
+            file.name: Attendancelist.from_df(
+                _load_df_from_uploaded_data(file.name, file, sep), cname=cname
+            )
+            for file in uploaded_files
+        }
+
     try:
-        data = make_attendance_data_from_file_uploads(
+        meetings = _make_attendance_data_from_file_uploads(
             uploaded_files, sep=None, cname=NAMECOLUMN
         )
 
@@ -96,7 +269,7 @@ def load_data(uploaded_files) -> Tuple[Dict, bool]:
         )
 
         try:
-            data = make_attendance_data_from_file_uploads(
+            meetings = _make_attendance_data_from_file_uploads(
                 uploaded_files, sep=separator, cname=columnname
             )
         except KeyError:
@@ -105,69 +278,69 @@ def load_data(uploaded_files) -> Tuple[Dict, bool]:
                 " Please use the options above to specify your column separator (if text/csv file)"
                 " and the column name of the column containing your attendees' names."
             )
-            data = {}
+            meetings = {}
 
-    if data:
+    if meetings:
         st.success(
             "Successfully loaded the following files:\\\n\\\n"
-            + "\\\n".join([f"{k} - {v.n_attendees} attendees" for k, v in data.items()])
-        )
-    return data
-
-
-def render_file_selector(meetings, key):
-    show_processed_list = st.checkbox("Display the processed list of attendees")
-    if show_processed_list:
-        filename = st.selectbox(
-            "Select the file to display", options=list(meetings.keys()), key=key
+            + "\\\n".join(
+                [f"{k} - {v.n_attendees} attendees" for k, v in meetings.items()]
+            )
         )
-        attendees = meetings[filename]
+    return meetings
 
-        st.write(attendees.to_df())
 
+def upload_files() -> Dict[str, Attendancelist]:
+    st.markdown(
+        "Upload the file(s) containing your meeting attendees. The expected format is a single"
+        " column containing the attendees' full names. If you column name is not Name,"
+        " you will be able to specify the column name after uploading the data."
+        " Additional columns will be ignored."
+    )
 
-def create_file_uploader():
     uploaded_files = st.file_uploader(
         label="📄 Upload your files", accept_multiple_files=True
     )
+
+    meetings = {}
     if uploaded_files:
         meetings = load_data(uploaded_files)
-        render_file_selector(meetings, "file_upload")
-        return meetings
-    else:
-        return {}
+        render_file_analysis(meetings)
 
+    return meetings
 
-def create_task_selector():
-    st.header("📝 Step 2: Choose a Task")
-    task = st.radio("I would like to ...", [task.value for task in TASKS])
 
-    if task == TASKS.SPLIT.value:
-        st.markdown("❔ **Description:** Split a list of names into first and surname.")
-    elif task == TASKS.COMPARE.value:
-        st.markdown(
-            "❔ **Description:** Compare two attendee lists with each"
-            " and find attendees who have recently joined."
-        )
-    elif task == TASKS.FIND.value:
-        st.markdown(
-            "❔ **Description:** Find attendees in a list by either first name"
-            " or surname or by substrings."
-        )
-    return task
+def render_intro() -> None:
+    st.title("📅 Meeting Attendance Organizer")
+    st.markdown(
+        "This app fullfills a simple need: Take a list of names of people"
+        " attending a meeting and peform one (or multiple) of the following tasks:"
+    )
+    st.markdown(
+        "* ✂️ Split their names into first name and surname\n"
+        "* 👀 Compare two lists with each other and see who is new on the second list\n"
+        "* 🔎 Find people in a list by either searching for their complete names or parts"
+        " of their name\n"
+        "* 💾 Write any of the results back out, so you can share it with others"
+    )
 
 
-def render_xlsx_download_button(data, filename, key) -> None:
-    with io.BytesIO() as output:
-        with pd.ExcelWriter(output, engine="openpyxl") as writer:
-            for sheetname, attendees in data.items():
-                attendees.to_df().to_excel(writer, sheet_name=sheetname, index=False)
-            writer.save()
+def main():
+    render_intro()
 
-        st.download_button(
-            label="💾 Download Results",
-            data=output.getvalue(),
-            file_name=filename,
-            mime="application/vnd.ms-excel",
-            key=key,
-        )
+    st.header("📂 Step 1: Upload your Files")
+    meetings = upload_files()
+
+    st.header("📝 Step 2: Choose a Task")
+    task = select_task(tasks=create_tasks())
+
+    st.header("🔥 Step 3: Let's Go!")
+    st.subheader(f"You are going to ... {task.short_description}")
+    if not meetings:
+        st.info("⬆ You need to upload some data first ⬆")
+    else:
+        task.run(meetings)
+
+
+if __name__ == "__main__":
+    main()

tests/test_attendancelist.py

@@ -4,7 +4,7 @@ from maorganizer.datawrangling import Attendancelist, Person
 def test_attendancelist_finds_person_by_substring():
     assert Attendancelist(
         {Person("zaphod beeblebrox"), Person("ford prefix")}
-    ).find_word("aph") == {Person("Zaphod Beeblebrox")}
+    ).find_by_string("aph") == {Person("Zaphod Beeblebrox")}
 
 
 def test_attendancelist_finds_person_by_namepart():