kahoot-to-anki 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

kahoot_to_anki/__init__.py

@@ -1 +1 @@
-__version__ = "1.1.0"
+__version__ = "1.2.0"

kahoot_to_anki/cli.py

@@ -5,6 +5,9 @@ import logging
 import os
 import glob
 
+from kahoot_to_anki import __version__
+
+
 # Constants
 DEFAULT_INPUT_DIRECTORY = "./data"
 DEFAULT_OUTPUT_DIRECTORY = "./"
@@ -65,6 +68,12 @@ def get_commandline_arguments() -> CLIArgs:
         f"If not specified, the default deck name '{DEFAULT_DECK_TITLE}' will be used.",
         type=str,
     )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show the version number and exit.",
+    )
     args = parser.parse_args()
 
     return CLIArgs(

kahoot_to_anki/processing.py

@@ -83,14 +83,16 @@ def df_processing(data: pd.DataFrame) -> pd.DataFrame:
     :param data: DataFrame with Kahoot question data
     :return: Processed DataFrame
     """
+    if data.empty:
+        return pd.DataFrame(columns=["Question", "Possible Answers", "Correct Answers"])
+    
     # delete duplicated questions
     data = data.drop_duplicates(subset=["Question Number"])
-
     data = data.fillna("")
 
     data["Possible Answers"] = data[
         ["Answer 1", "Answer 2", "Answer 3", "Answer 4", "Answer 5", "Answer 6"]
-    ].agg("<br>".join, axis=1)
+    ].astype(str).agg("<br>".join, axis=1)
 
     # keep only needed columns
     data = data[["Question", "Possible Answers", "Correct Answers"]]

{kahoot_to_anki-1.1.0.dist-info → kahoot_to_anki-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kahoot-to-anki
-Version: 1.1.0
+Version: 1.2.0
 Summary: CLI tool to convert Kahoot quiz reports into Anki flashcards
 Author: Simon Hardmeier
 License-Expression: MIT
@@ -69,6 +69,7 @@ All valid Excel files in the directory will be processed.
 | `--sheet`            | The Excel Sheet with the raw Kahoot quiz data (default: `RawReportData Data`)  |    
 | `--csv`, `--no-csv`  | Enable or disable CSV export of the questions (default: disabled)              |
 | `-t`, `--title`      | Title of the generated Anki deck (default: `"Kahoot"`)                         |
+| `--version`          | Show the version of the installed kahoot-to-anki package                       |
 
 
 ## Example

kahoot_to_anki-1.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+kahoot_to_anki/__init__.py,sha256=Btl_98iBIXFtvGx47MqpfbaEVYoOMPBQn9bao7UASkQ,21
+kahoot_to_anki/cli.py,sha256=2tRiIcnbcrPXVPQ8mdeUOHXYP3LO9ExNfp3Uy1FSaFk,4484
+kahoot_to_anki/main.py,sha256=oVmOLqXUnzy1Q0Xnn4Dzr65bFf8Jaw4vYRwvDTSd_ro,936
+kahoot_to_anki/processing.py,sha256=Ku8nFhgWpprmYWdLL6f-T8P7J_SmMuQD2NLVCQQErCs,4346
+kahoot_to_anki-1.2.0.dist-info/licenses/LICENSE,sha256=HxPBlT4sSfEgRBrX0jZd8WTfM0c31VFgnLaCEWzGMZc,1122
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_cli.py,sha256=SL1WEJoA59-G7hRdWg5wOUyCPrjzZvsgPJxAZMPXpWg,3195
+tests/test_processing.py,sha256=swLG2gkcwWm1ZG0T5u6izlhV-2AIsaMKdg174jp3za8,10951
+kahoot_to_anki-1.2.0.dist-info/METADATA,sha256=I8iBo7bvvBQMyMticSKPHsILRASFMaB0VRi45EWhv3E,2953
+kahoot_to_anki-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kahoot_to_anki-1.2.0.dist-info/entry_points.txt,sha256=VqCk_PPVpGFgnGCBIlEnz8Y0qUqYV8J2tYNZZa8IRWA,60
+kahoot_to_anki-1.2.0.dist-info/top_level.txt,sha256=aTMCk83rMZjWFZ556EHLIxVOgEawIWsMZzRpR3IPQ1w,21
+kahoot_to_anki-1.2.0.dist-info/RECORD,,

tests/test_cli.py

@@ -0,0 +1,111 @@
+import sys
+from pathlib import Path
+
+import pytest
+
+from kahoot_to_anki.cli import get_commandline_arguments, validation
+
+
+# --- get_commandline_arguments ---
+def test_get_commandline_arguments(monkeypatch):
+    """Test that CLI arguments are correctly parsed."""
+
+    test_args = [
+        "kahoot-to-anki",
+        "-i", "tests/data",
+        "-o", "output_dir",
+        "--csv",
+        "--sheet", "CustomSheet",
+        "--title", "My Deck"
+    ]
+
+    monkeypatch.setattr(sys, "argv", test_args)
+
+    args = get_commandline_arguments()
+
+    assert Path(args.input_path).name == "data"
+    assert Path(args.output_path).name == "output_dir"
+    assert args.export_csv is True
+    assert args.sheet == "CustomSheet"
+    assert args.deck_title == "My Deck"
+  
+    
+def test_get_commandline_arguments_no_csv(monkeypatch):
+    """Test that --no-csv CLI argument is correctly parsed."""
+
+    test_args = [
+        "kahoot-to-anki",
+        "--no-csv",
+    ]
+
+    monkeypatch.setattr(sys, "argv", test_args)
+    args = get_commandline_arguments()
+
+    assert args.export_csv is False
+    
+    
+# --- validation ---
+def test_validation_valid_excel_file(tmp_path):
+    # Create dummy Excel file
+    excel_file = tmp_path / "valid.xlsx"
+    excel_file.write_text("Excel content")
+
+    # Create output directory
+    output_dir = tmp_path / "output"
+    output_dir.mkdir()
+
+    # Should not raise
+    validation(str(excel_file), str(output_dir)) 
+    
+    
+def test_validation_valid_input_directory_with_excel(tmp_path):
+    input_dir = tmp_path / "input"
+    input_dir.mkdir()
+    (input_dir / "file1.xlsx").write_text("Excel content")
+
+    output_dir = tmp_path / "output"
+    output_dir.mkdir()
+
+     # Should not raise
+    validation(str(input_dir), str(output_dir)) 
+    
+    
+def test_validation_input_path_does_not_exist(tmp_path):
+    output_dir = tmp_path / "output"
+    output_dir.mkdir()
+
+    with pytest.raises(FileNotFoundError):
+        validation(str(tmp_path / "missing.xlsx"), str(output_dir))
+        
+        
+def test_validation_input_not_excel_file(tmp_path):
+    file = tmp_path / "file.txt"
+    file.write_text("Not Excel")
+    output_dir = tmp_path / "output"
+    output_dir.mkdir()
+
+    with pytest.raises(ValueError, match="Input file is not an excel file"):
+        validation(str(file), str(output_dir))
+        
+        
+def test_validation_input_directory_no_excel_files(tmp_path):
+    input_dir = tmp_path / "input"
+    input_dir.mkdir()
+    (input_dir / "file.txt").write_text("Just text")
+
+    output_dir = tmp_path / "output"
+    output_dir.mkdir()
+
+    with pytest.raises(FileNotFoundError, match="does not contain any excel files"):
+        validation(str(input_dir), str(output_dir))
+        
+        
+def test_validation_output_not_a_directory(tmp_path):
+    excel_file = tmp_path / "valid.xlsx"
+    excel_file.write_text("Excel content")
+
+    output_path = tmp_path / "output.txt"
+    output_path.write_text("Not a directory")
+
+    with pytest.raises(ValueError, match="Output is not a directory"):
+        validation(str(excel_file), str(output_path))

tests/test_processing.py

@@ -0,0 +1,340 @@
+import logging
+import zipfile
+
+import pandas as pd
+
+from kahoot_to_anki.processing import get_questions, get_excels, get_excel_data, df_processing, make_anki
+
+logging.basicConfig(level=logging.DEBUG)
+
+KAHOOT_SHEET_NAME = "RawReportData Data"
+
+def write_excel(df: pd.DataFrame, tmp_path, filename="sample.xlsx", sheet_name=KAHOOT_SHEET_NAME):
+    path = tmp_path / filename
+    df.to_excel(path, sheet_name=sheet_name, index=False)
+    return path
+
+# --- get_questions ---
+def test_get_questions_single_file(tmp_path):
+    """Test processing a single valid Kahoot Excel file."""
+    
+    df = pd.DataFrame({
+        "Question Number": [1],
+        "Question": ["What is 2+2?"],
+        "Answer 1": ["4"],
+        "Answer 2": ["3"],
+        "Answer 3": [""],
+        "Answer 4": [""],
+        "Answer 5": [""],
+        "Answer 6": [""],
+        "Correct Answers": ["4"]
+    })
+
+    excel_file = write_excel(df, tmp_path)
+    result_df = get_questions(input_directory=str(excel_file), sheet_name=KAHOOT_SHEET_NAME)
+
+    # Assertions
+    assert not result_df.empty
+    assert result_df.shape[0] == 1
+    assert "Question" in result_df.columns
+    assert result_df.iloc[0]["Question"] == "What is 2+2?"
+    expected_columns = ["Question", "Possible Answers", "Correct Answers"]
+    assert list(result_df.columns) == expected_columns
+    
+def test_get_questions_deduplicates_questions(tmp_path):
+    """Test processing a single valid Kahoot Excel file with duplicated questions."""
+    
+    df1 = pd.DataFrame({
+        "Question Number": [1],
+        "Question": ["What is 2+2?"],
+        "Answer 1": ["4"],
+        "Answer 2": ["3"],
+        "Answer 3": [""],
+        "Answer 4": [""],
+        "Answer 5": [""],
+        "Answer 6": [""],
+        "Correct Answers": ["4"]
+    })
+
+    df2 = df1.copy()
+    df = pd.concat([df1, df2], ignore_index=True)
+
+    write_excel(df, tmp_path)
+    result_df = get_questions(input_directory=str(tmp_path), sheet_name=KAHOOT_SHEET_NAME)
+
+    # Assertions
+    assert result_df.shape[0] == 1
+    
+    
+def test_get_questions_handles_numeric_answers(tmp_path):
+    """Test processing a single valid Kahoot Excel file with mixed data types."""
+    
+    df = pd.DataFrame({
+        "Question Number": [1],
+        "Question": ["What is 2+2?"],
+        "Answer 1": ["2"],
+        "Answer 2": [4],
+        "Answer 3": ["6"],
+        "Answer 4": [""],
+        "Answer 5": [""],
+        "Answer 6": [""],
+        "Correct Answers": ["4"]
+    })
+
+    write_excel(df, tmp_path)
+    result_df = get_questions(input_directory=str(tmp_path), sheet_name=KAHOOT_SHEET_NAME)
+
+    assert result_df.shape[0] == 1
+    assert "4" in result_df.iloc[0]["Possible Answers"]
+    
+    
+def test_get_questions_returns_empty_for_empty_file(tmp_path):
+    """Test that an empty Excel file returns an empty DataFrame."""
+    df = pd.DataFrame(columns=[
+        "Question Number", "Question", "Answer 1", "Answer 2", "Answer 3",
+        "Answer 4", "Answer 5", "Answer 6", "Correct Answers"
+    ])
+    write_excel(df, tmp_path)
+    result_df = get_questions(input_directory=str(tmp_path), sheet_name=KAHOOT_SHEET_NAME)
+    assert result_df.empty
+    
+    
+def test_get_questions_merges_multiple_files(tmp_path):
+    df1 = pd.DataFrame({
+        "Question Number": [1],
+        "Question": ["What is 2+2?"],
+        "Answer 1": ["4"],
+        "Answer 2": ["3"],
+        "Answer 3": [""],
+        "Answer 4": [""],
+        "Answer 5": [""],
+        "Answer 6": [""],
+        "Correct Answers": ["4"]
+    })
+
+    df2 = pd.DataFrame({
+        "Question Number": [2],
+        "Question": ["What is the capital of France?"],
+        "Answer 1": ["Berlin"],
+        "Answer 2": ["Paris"],
+        "Answer 3": ["Madrid"],
+        "Answer 4": [""],
+        "Answer 5": [""],
+        "Answer 6": [""],
+        "Correct Answers": ["Paris"]
+    })
+
+    # Write both files into the same temp directory
+    write_excel(df1, tmp_path, filename="quiz1.xlsx")
+    write_excel(df2, tmp_path, filename="quiz2.xlsx")
+
+    result_df = get_questions(input_directory=str(tmp_path), sheet_name=KAHOOT_SHEET_NAME)
+
+    assert result_df.shape[0] == 2
+    assert "What is 2+2?" in result_df["Question"].values
+    assert "What is the capital of France?" in result_df["Question"].values
+    
+    
+def test_get_questions_skips_invalid_sheets(tmp_path):
+    df1 = pd.DataFrame({
+        "Question Number": [1],
+        "Question": ["What is 2+2?"],
+        "Answer 1": ["4"],
+        "Answer 2": ["3"],
+        "Answer 3": [""],
+        "Answer 4": [""],
+        "Answer 5": [""],
+        "Answer 6": [""],
+        "Correct Answers": ["4"]
+    })
+
+    df2 = pd.DataFrame({
+        "Question Number": [2],
+        "Question": ["What is the capital of France?"],
+        "Answer 1": ["Berlin"],
+        "Answer 2": ["Paris"],
+        "Answer 3": ["Madrid"],
+        "Answer 4": [""],
+        "Answer 5": [""],
+        "Answer 6": [""],
+        "Correct Answers": ["Paris"]
+    })
+    
+    df3 = pd.DataFrame({
+        "Question Number": [2],
+        "Question": ["What is the capital of Spain?"],
+        "Answer 1": ["Berlin"],
+        "Answer 2": ["Paris"],
+        "Answer 3": ["Madrid"],
+        "Answer 4": [""],
+        "Answer 5": [""],
+        "Answer 6": [""],
+        "Correct Answers": ["Madrid"]
+    })
+
+    # Write both files into the same temp directory
+    write_excel(df1, tmp_path, filename="quiz1.xlsx")
+    write_excel(df2, tmp_path, filename="quiz2.xlsx")
+    write_excel(df3, tmp_path, filename="quiz3.xlsx", sheet_name="TEST")
+
+    result_df = get_questions(input_directory=str(tmp_path), sheet_name=KAHOOT_SHEET_NAME)
+
+    assert result_df.shape[0] == 2
+    assert "What is 2+2?" in result_df["Question"].values
+    assert "What is the capital of France?" in result_df["Question"].values
+
+
+# --- get_excels ---
+def test_get_excels_single_file(tmp_path):
+    """Test that get_excels yields a single file when given a single .xlsx file path."""
+    file = tmp_path / "single.xlsx"
+    file.write_text("dummy content")
+
+    result = list(get_excels(str(file)))
+    
+    assert len(result) == 1
+    assert result[0].endswith("single.xlsx")
+    
+    
+def test_get_excels_multiple_files_in_directory(tmp_path):
+    """Test that get_excels yields all .xlsx files in a directory."""
+    file1 = tmp_path / "file1.xlsx"
+    file2 = tmp_path / "file2.xlsx"
+    file3 = tmp_path / "file3.csv"  # should be ignored
+
+    for f in [file1, file2]:
+        f.write_text("dummy content")
+    file3.write_text("should be ignored")
+
+    result = list(get_excels(str(tmp_path)))
+
+    assert len(result) == 2
+    assert all(f.endswith(".xlsx") for f in result)
+    assert str(file3) not in result
+    
+    
+# --- get_excel_data ---
+def test_get_excel_data_valid(tmp_path):
+    """Test reading a valid Excel file with correct sheet name."""
+    df = pd.DataFrame({"Question": ["Q1"], "Correct Answers": ["A1"]})
+    path = tmp_path / "valid.xlsx"
+    df.to_excel(path, sheet_name=KAHOOT_SHEET_NAME, index=False)
+
+    result = get_excel_data(str(path), sheet_name=KAHOOT_SHEET_NAME)
+
+    assert isinstance(result, pd.DataFrame)
+    assert not result.empty
+    assert "Question" in result.columns
+
+def test_get_excel_data_missing_sheet(tmp_path, caplog):
+    """Test behavior when the specified sheet name does not exist."""
+    df = pd.DataFrame({"Question": ["Q1"]})
+    path = tmp_path / "missing_sheet.xlsx"
+    df.to_excel(path, sheet_name="WrongSheet", index=False)
+
+    with caplog.at_level(logging.WARNING):
+        result = get_excel_data(str(path), sheet_name=KAHOOT_SHEET_NAME)
+
+    assert result is None
+    assert "Skipping file" in caplog.text
+
+def test_get_excel_data_invalid_file(tmp_path, caplog):
+    """Test behavior when trying to read a corrupted Excel file."""
+    path = tmp_path / "fake.xlsx"
+    path.write_text("This is not a real Excel file.")
+
+    with caplog.at_level(logging.WARNING):
+        result = get_excel_data(str(path), sheet_name=KAHOOT_SHEET_NAME)
+
+    assert result is None
+    assert "Skipping file" in caplog.text
+    
+    
+# --- df_processing ---
+def test_df_processing_empty():
+    df = pd.DataFrame(columns=[
+        "Question Number", "Question", "Answer 1", "Answer 2", "Answer 3",
+        "Answer 4", "Answer 5", "Answer 6", "Correct Answers"
+    ])
+    result = df_processing(df)
+    
+    assert result.empty
+    assert list(result.columns) == ["Question", "Possible Answers", "Correct Answers"]
+
+
+def test_df_processing_normal_case():
+    df = pd.DataFrame({
+        "Question Number": [1],
+        "Question": ["What is 2+2?"],
+        "Answer 1": ["2"],
+        "Answer 2": ["4"],
+        "Answer 3": ["3"],
+        "Answer 4": [""],
+        "Answer 5": [""],
+        "Answer 6": [""],
+        "Correct Answers": ["4"]
+    })
+    result = df_processing(df)
+
+    assert result.shape[0] == 1
+    assert "What is 2+2?" in result["Question"].values
+    assert "4" in result["Possible Answers"].iloc[0]
+
+
+def test_df_processing_duplicate_question_number():
+    df = pd.DataFrame({
+        "Question Number": [1, 1],
+        "Question": ["What is 2+2?", "What is 2+2?"],
+        "Answer 1": ["2", "2"],
+        "Answer 2": ["4", "4"],
+        "Answer 3": ["3", "3"],
+        "Answer 4": ["", ""],
+        "Answer 5": ["", ""],
+        "Answer 6": ["", ""],
+        "Correct Answers": ["4", "4"]
+    })
+    result = df_processing(df)
+
+    assert result.shape[0] == 1
+
+
+def test_df_processing_mixed_types():
+    df = pd.DataFrame({
+        "Question Number": [1],
+        "Question": ["How many continents?"],
+        "Answer 1": ["7"],
+        "Answer 2": [6],  # int type
+        "Answer 3": [""],
+        "Answer 4": [None],
+        "Answer 5": ["Five"],
+        "Answer 6": [""],
+        "Correct Answers": ["7"]
+    })
+    result = df_processing(df)
+
+    assert result.shape[0] == 1
+    assert "6" in result["Possible Answers"].iloc[0]  # check that int was converted
+    assert "None" not in result["Possible Answers"].iloc[0]  # check fillna
+    
+    
+# --- make_anki ---
+def test_make_anki_creates_apkg(tmp_path):
+    """Test that make_anki creates a valid .apkg file."""
+
+    # Prepare test data
+    df = pd.DataFrame({
+        "Question": ["What is 2+2?"],
+        "Possible Answers": ["2<br>3<br>4"],
+        "Correct Answers": ["4"]
+    })
+
+    # Run the function
+    make_anki(df=df, out=str(tmp_path), title="Test Deck")
+
+    # Check output file exists
+    output_file = tmp_path / "anki.apkg"
+    assert output_file.exists()
+    assert output_file.stat().st_size > 0
+
+    # Check that it's a valid ZIP file (as .apkg is zip format internally)
+    assert zipfile.is_zipfile(output_file)

kahoot_to_anki-1.1.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-kahoot_to_anki/__init__.py,sha256=0y91PW-fcytGzZxMWcdcVL1uY8YfJz4Qb4CVpB1hAXg,21
-kahoot_to_anki/cli.py,sha256=MaG5527TI1fp4fVYdYGgg3P4eJiEW6wKZLsAjOPvQJA,4263
-kahoot_to_anki/main.py,sha256=oVmOLqXUnzy1Q0Xnn4Dzr65bFf8Jaw4vYRwvDTSd_ro,936
-kahoot_to_anki/processing.py,sha256=l-EuDOMp0NK-Uxj9M-VaN5_01W-YUmN-HN3ROM9M6yA,4220
-kahoot_to_anki-1.1.0.dist-info/licenses/LICENSE,sha256=HxPBlT4sSfEgRBrX0jZd8WTfM0c31VFgnLaCEWzGMZc,1122
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_project.py,sha256=nGwU_Lys2QKJu3VrAnZiP1NS4ydEdkkqWPKQTCOZl8k,5355
-kahoot_to_anki-1.1.0.dist-info/METADATA,sha256=SUbPtw_U-YWaI0KJ7HnB6ekerE_7nYvNp919DV14U0k,2846
-kahoot_to_anki-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kahoot_to_anki-1.1.0.dist-info/entry_points.txt,sha256=VqCk_PPVpGFgnGCBIlEnz8Y0qUqYV8J2tYNZZa8IRWA,60
-kahoot_to_anki-1.1.0.dist-info/top_level.txt,sha256=aTMCk83rMZjWFZ556EHLIxVOgEawIWsMZzRpR3IPQ1w,21
-kahoot_to_anki-1.1.0.dist-info/RECORD,,

tests/test_project.py

@@ -1,226 +0,0 @@
-# Standard library imports
-import shutil
-import os
-
-# Third-party library imports
-import numpy as np
-import pandas as pd
-import pytest
-
-# Local application/library imports
-import converter
-
-
-def generate_test_data():
-    # Create multiple lists
-    question_number = [
-        "Question 1",
-        "Question 1",
-        "Question 1",
-        "Question 2",
-        "Question 2",
-        "Question 2",
-    ]
-    question = [
-        "How is a code block indicated in Python?",
-        "How is a code block indicated in Python?",
-        "How is a code block indicated in Python?",
-        "Which of the following concepts is not a part of Python?",
-        "Which of the following concepts is not a part of Python?",
-        "Which of the following concepts is not a part of Python?",
-    ]
-    answer_1 = [
-        "Brackets",
-        "Brackets",
-        "Brackets",
-        "Pointers",
-        "Pointers",
-        "Pointers",
-    ]
-    answer_2 = [
-        "Indentation",
-        "Indentation",
-        "Indentation",
-        "Loops",
-        "Loops",
-        "Loops",
-    ]
-    answer_3 = [
-        "Key",
-        "Key",
-        "Key",
-        "Dynamic Typing",
-        "Dynamic Typing",
-        "Dynamic Typing",
-    ]
-    answer_4 = [
-        np.nan,
-        np.nan,
-        np.nan,
-        np.nan,
-        np.nan,
-        np.nan,
-    ]
-    answer_5 = [
-        np.nan,
-        np.nan,
-        np.nan,
-        np.nan,
-        np.nan,
-        np.nan,
-    ]
-    answer_6 = [
-        np.nan,
-        np.nan,
-        np.nan,
-        np.nan,
-        np.nan,
-        np.nan,
-    ]
-    correct_answers = [
-        "Indentation",
-        "Indentation",
-        "Indentation",
-        "Pointers",
-        "Pointers",
-        "Pointers",
-    ]
-    time_to_answer = [
-        "10",
-        "10",
-        "10",
-        "10",
-        "10",
-        "10",
-    ]
-    player = [
-        "Harry",
-        "Hermione ",
-        "Ron",
-        "Harry",
-        "Hermione ",
-        "Ron",
-    ]
-    answer = [
-        "Indentation",
-        "Indentation",
-        "Brackets",
-        "Dynamic Typing",
-        "Pointers",
-        "Dynamic Typing",
-    ]
-    correct_incorrect = [
-        True,
-        True,
-        False,
-        False,
-        True,
-        False,
-    ]
-    columns = [
-        "Question Number",
-        "Question",
-        "Answer 1",
-        "Answer 2",
-        "Answer 3",
-        "Answer 4",
-        "Answer 5",
-        "Answer 6",
-        "Correct Answers",
-        "Time Allotted to Answer (seconds)",
-        "Player",
-        "Answer",
-        "Correct / Incorrect",
-    ]
-
-    # Create DataFrame from multiple lists
-    df = pd.DataFrame(
-        list(
-            zip(
-                question_number,
-                question,
-                answer_1,
-                answer_2,
-                answer_3,
-                answer_4,
-                answer_5,
-                answer_6,
-                correct_answers,
-                time_to_answer,
-                player,
-                answer,
-                correct_incorrect,
-            )
-        ),
-        columns=columns,
-    )
-    return df
-
-
-@pytest.fixture(scope="session", autouse=True)
-def setup_and_teardown():
-    test_data_dir = "test_data"
-    test_data_dir_empty = "test_data_empty"
-    input_file_name = "input.xlsx"
-    empty_file_name = "empty.xlsx"
-
-    input_file_path = os.path.join(test_data_dir, input_file_name)
-    empty_file_path = os.path.join(test_data_dir, empty_file_name)
-
-    df = generate_test_data()
-
-    os.makedirs(test_data_dir, exist_ok=True)
-    df.to_excel(input_file_path, sheet_name="RawReportData Data", index=False)
-
-    os.makedirs(test_data_dir_empty, exist_ok=True)
-
-    # create empty excel
-    df_empty = pd.DataFrame()
-    df_empty.to_excel(empty_file_path)
-
-    # Yield to allow the test to run
-    yield
-
-    # Teardown: Cleanup the created files
-    if os.path.exists(test_data_dir):
-        shutil.rmtree(test_data_dir)
-    if os.path.exists(test_data_dir_empty):
-        shutil.rmtree(test_data_dir_empty)
-
-
-def test_validation_wrong_output():
-    with pytest.raises(ValueError):
-        assert converter.validation("test_data/", "test_data/input.xlsx")
-
-
-def test_validation_wrong_input_file():
-    with pytest.raises(FileNotFoundError):
-        assert converter.validation("test_data/in.txt", "test_data/")
-
-
-def test_validation_empty_input_directory():
-    with pytest.raises(FileNotFoundError):
-        assert converter.validation("test_data_empty/", "./output")
-
-
-def test_validation():
-    assert converter.validation('./test_data/', "./test_data/") is None
-
-
-def test_get_questions_wrong_excel():
-    assert converter.get_questions("test_data/empty.xlsx").shape[0] == 0
-
-
-def test_get_questions_file():
-    assert converter.get_questions("test_data/input.xlsx").shape[0] == 2
-
-
-def test_get_questions_directory():
-    assert converter.get_questions("test_data/").shape[0] == 2
-
-
-def test_make_anki():
-    df = converter.get_questions("test_data/input.xlsx")
-    converter.make_anki(df, "test_data/", "test")
-    # Check if output file exists
-    assert os.path.exists("test_data/anki.apkg") is True