mito-ai 0.1.33__py3-none-any.whl → 0.1.49__py3-none-any.whl

mito_ai/tests/streamlit_conversion/test_apply_search_replace.py

@@ -0,0 +1,240 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from mito_ai.utils.error_classes import StreamlitConversionError
+import pytest
+from mito_ai.streamlit_conversion.search_replace_utils import apply_search_replace
+
+
+@pytest.mark.parametrize("original_text,search_replace_pairs,expected_result", [
+    # Test case 1: Simple title change
+    (
+        """import streamlit as st
+
+st.markdown(\"\"\"
+    <style>
+        #MainMenu {visibility: hidden;}
+        .stAppDeployButton {display:none;}
+        footer {visibility: hidden;}
+        .stMainBlockContainer {padding: 2rem 1rem 2rem 1rem;}
+    </style>
+\"\"\", unsafe_allow_html=True)
+
+st.title("Simple Calculation")
+
+x = 5
+y = 10
+result = x + y
+
+st.write(f"x = {x}")
+st.write(f"y = {y}")
+st.write(f"x + y = {result}")""",
+        [("st.title(\"Simple Calculation\")", "st.title(\"Math Examples\")")],
+        """import streamlit as st
+
+st.markdown(\"\"\"
+    <style>
+        #MainMenu {visibility: hidden;}
+        .stAppDeployButton {display:none;}
+        footer {visibility: hidden;}
+        .stMainBlockContainer {padding: 2rem 1rem 2rem 1rem;}
+    </style>
+\"\"\", unsafe_allow_html=True)
+
+st.title("Math Examples")
+
+x = 5
+y = 10
+result = x + y
+
+st.write(f"x = {x}")
+st.write(f"y = {y}")
+st.write(f"x + y = {result}")"""
+    ),
+    
+    # Test case 2: Add new content
+    (
+        """import streamlit as st
+
+st.title("My App")""",
+        [("st.title(\"My App\")", """st.title("My App")
+st.header("Welcome")
+st.write("This is a test app")""")],
+        """import streamlit as st
+
+st.title("My App")
+st.header("Welcome")
+st.write("This is a test app")"""
+    ),
+    
+    # Test case 3: Remove lines
+    (
+        """import streamlit as st
+
+st.header("Welcome")
+st.title("My App")
+st.write("This is a test app")""",
+        [("""st.header("Welcome")
+st.title("My App")
+st.write("This is a test app")""", "st.title(\"My App\")")],
+        """import streamlit as st
+
+st.title("My App")"""
+    ),
+    
+    # Test case 4: Multiple replacements
+    (
+        """import streamlit as st
+
+st.title("Old Title")
+x = 5
+y = 10
+st.write("Old message")""",
+        [
+            ("st.title(\"Old Title\")", "st.title(\"New Title\")"),
+            ("st.write(\"Old message\")", "st.write(\"New message\")")
+        ],
+        """import streamlit as st
+
+st.title("New Title")
+x = 5
+y = 10
+st.write("New message")"""
+    ),
+    
+    # Test case 5: Empty search/replace pairs
+    (
+        """import streamlit as st
+
+st.title("My App")""",
+        [],
+        """import streamlit as st
+
+st.title("My App")"""
+    ),
+    
+    # Test case 6: Complex replacement with context
+    (
+        """import streamlit as st
+
+# This is a comment
+st.title("Old Title")
+# Another comment
+x = 5
+y = 10
+# Final comment""",
+        [("""# This is a comment
+st.title("Old Title")
+# Another comment""", """# This is a comment
+st.title("New Title")
+# Another comment""")],
+        """import streamlit as st
+
+# This is a comment
+st.title("New Title")
+# Another comment
+x = 5
+y = 10
+# Final comment"""
+    ),
+    
+    # Test case 7: Replace multiple consecutive lines
+    (
+        """import streamlit as st
+
+st.title("My App")
+st.write("Line 1")
+st.write("Line 2")
+st.write("Line 3")
+
+x = 5""",
+        [("""st.write("Line 1")
+st.write("Line 2")
+st.write("Line 3")""", "st.write(\"New content\")")],
+        """import streamlit as st
+
+st.title("My App")
+st.write("New content")
+
+x = 5"""
+    ),
+    
+    # Test case 8: Add lines at the beginning
+    (
+        """import streamlit as st
+
+st.title("My App")""",
+        [("import streamlit as st", """import pandas as pd
+import streamlit as st""")],
+        """import pandas as pd
+import streamlit as st
+
+st.title("My App")"""
+    ),
+    
+    # Test case 9: Add lines at the end
+    (
+        """import streamlit as st
+
+st.title("My App")""",
+        [("st.title(\"My App\")", """st.title("My App")
+
+st.write("Footer content")
+st.write("More footer")""")],
+        """import streamlit as st
+
+st.title("My App")
+
+st.write("Footer content")
+st.write("More footer")"""
+    ),
+    
+    # Test case 10: Add emoji to streamlit app title
+    (
+        """import streamlit as st
+
+st.title("My App")
+st.write("Welcome to my application")""",
+        [("st.title(\"My App\")", "st.title(\"🚀 My App\")")],
+        """import streamlit as st
+
+st.title("🚀 My App")
+st.write("Welcome to my application")"""
+    ),
+    
+    # Test case 11: Only replace first occurrence when search text exists multiple times
+    (
+        """import streamlit as st
+
+st.write("Hello World")
+st.title("My App")
+st.write("Hello World")
+st.write("Another message")""",
+        [("st.write(\"Hello World\")", "st.write(\"Hi There\")")],
+        """import streamlit as st
+
+st.write("Hi There")
+st.title("My App")
+st.write("Hello World")
+st.write("Another message")"""
+    )
+])
+def test_apply_search_replace(original_text, search_replace_pairs, expected_result):
+    """Test the apply_search_replace function with various search/replace scenarios."""
+    result = apply_search_replace(original_text, search_replace_pairs)
+    
+    print(f"Original text: {repr(original_text)}")
+    print(f"Search/replace pairs: {search_replace_pairs}")
+    print(f"Expected result: {repr(expected_result)}")
+    print(f"Result: {repr(result)}")
+    
+    assert result == expected_result
+
+
+def test_apply_search_replace_search_not_found():
+    """Test that ValueError is raised when search text is not found."""
+    with pytest.raises(StreamlitConversionError, match="Search text not found"):
+        apply_search_replace("st.title(\"My App\")", [("st.title(\"Not Found\")", "st.title(\"New Title\")")])
+
+
+

mito_ai/tests/streamlit_conversion/test_streamlit_agent_handler.py

@@ -0,0 +1,246 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from typing import List
+from anthropic.types import MessageParam
+import pytest
+import os
+from unittest.mock import patch, AsyncMock, MagicMock
+from mito_ai.streamlit_conversion.streamlit_agent_handler import (
+    get_response_from_agent,
+    generate_new_streamlit_code,
+    correct_error_in_generation,
+    streamlit_handler
+)
+from mito_ai.path_utils import AbsoluteNotebookPath, AppFileName, get_absolute_app_path, get_absolute_notebook_dir_path, get_absolute_notebook_path
+
+# Add this line to enable async support
+pytest_plugins = ('pytest_asyncio',)
+
+
+class TestGetResponseFromAgent:
+    """Test cases for get_response_from_agent function"""
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.agent_utils.stream_anthropic_completion_from_mito_server')
+    async def test_get_response_from_agent_success(self, mock_stream):
+        """Test get_response_from_agent with successful response"""
+        # Mock the async generator
+        async def mock_async_gen():
+            yield "Here's your code:\n```python\nimport streamlit\nst.title('Test')\n```"
+
+        mock_stream.return_value = mock_async_gen()
+        
+        messages: List[MessageParam] = [{"role": "user", "content": [{"type": "text", "text": "test"}]}]
+        response = await get_response_from_agent(messages)
+        
+        assert response is not None
+        assert len(response) > 0
+        assert "import streamlit" in response
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.agent_utils.stream_anthropic_completion_from_mito_server')
+    @pytest.mark.parametrize("mock_items,expected_result", [
+        (["Hello", " World", "!"], "Hello World!"),
+        ([], ""),
+        (["Here's your code: import streamlit"], "Here's your code: import streamlit")
+    ])
+    async def test_get_response_from_agent_parametrized(self, mock_stream, mock_items, expected_result):
+        """Test response from agent with different scenarios"""
+        # Mock the async generator
+        async def mock_async_gen():
+            for item in mock_items:
+                yield item
+
+        mock_stream.return_value = mock_async_gen()
+        
+        messages: List[MessageParam] = [{"role": "user", "content": [{"type": "text", "text": "test"}]}]
+        result = await get_response_from_agent(messages)
+        
+        assert result == expected_result
+        mock_stream.assert_called_once()
+        
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.agent_utils.stream_anthropic_completion_from_mito_server')
+    async def test_get_response_from_agent_exception(self, mock_stream):
+        """Test exception handling in get_response_from_agent"""
+        mock_stream.side_effect = Exception("API Error")
+        
+        messages: List[MessageParam] = [{"role": "user", "content": [{"type": "text", "text": "test"}]}]
+        
+        with pytest.raises(Exception, match="API Error"):
+            await get_response_from_agent(messages)
+
+
+class TestGenerateStreamlitCode:
+    """Test cases for generate_new_streamlit_code function"""
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.agent_utils.stream_anthropic_completion_from_mito_server')
+    async def test_generate_new_streamlit_code_success(self, mock_stream):
+        """Test successful streamlit code generation"""
+        mock_response = "Here's your code:\n```python\nimport streamlit\nst.title('Hello')\n```"
+
+        async def mock_async_gen():
+            for item in [mock_response]:
+                yield item
+
+        mock_stream.return_value = mock_async_gen()
+        
+        notebook_data: List[dict] = [{"cells": []}]
+        result = await generate_new_streamlit_code(notebook_data)
+        
+        expected_code = "import streamlit\nst.title('Hello')\n"
+        assert result == expected_code
+
+
+class TestCorrectErrorInGeneration:
+    """Test cases for correct_error_in_generation function"""
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.agent_utils.stream_anthropic_completion_from_mito_server')
+    async def test_correct_error_in_generation_success(self, mock_stream):
+        """Test successful error correction"""
+        mock_response = """```search_replace
+>>>>>>> SEARCH
+st.title('Test')
+=======
+st.title('Fixed')
+<<<<<<< REPLACE
+```"""
+        async def mock_async_gen():
+            for item in [mock_response]:
+                yield item
+
+        mock_stream.return_value = mock_async_gen()
+
+        result = await correct_error_in_generation("ImportError: No module named 'pandas'", "import streamlit\nst.title('Test')\n")
+        
+        expected_code = "import streamlit\nst.title('Fixed')\n"
+        assert result == expected_code
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.agent_utils.stream_anthropic_completion_from_mito_server')
+    async def test_correct_error_in_generation_exception(self, mock_stream):
+        """Test exception handling in error correction"""
+        mock_stream.side_effect = Exception("API Error")
+        
+        with pytest.raises(Exception, match="API Error"):
+            await correct_error_in_generation("Some error", "import streamlit\nst.title('Test')")
+
+
+class TestStreamlitHandler:
+    """Test cases for streamlit_handler function"""
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.parse_jupyter_notebook_to_extract_required_content')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.generate_new_streamlit_code')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.validate_app')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.create_app_file')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.log_streamlit_app_conversion_success')
+    async def test_streamlit_handler_success(self, mock_log_success, mock_create_file, mock_validator, mock_generate_code, mock_parse):
+        """Test successful streamlit handler execution"""
+        # Mock notebook parsing
+        mock_notebook_data: List[dict] = [{"cells": [{"cell_type": "code", "source": ["import pandas"]}]}]
+        mock_parse.return_value = mock_notebook_data
+        
+        # Mock code generation
+        mock_generate_code.return_value = "import streamlit\nst.title('Test')"
+        
+        # Mock validation (no errors)
+        mock_validator.return_value = []
+        
+        # Use a relative path that will work cross-platform
+        notebook_path = AbsoluteNotebookPath("absolute/path/to/notebook.ipynb")
+        app_file_name = AppFileName('test-app-file-name.py')
+        
+        # Construct the expected app path using the same method as the production code
+        app_directory = get_absolute_notebook_dir_path(notebook_path)
+        expected_app_path = get_absolute_app_path(app_directory, app_file_name)
+        await streamlit_handler(notebook_path, app_file_name)
+        
+        # Verify calls
+        mock_parse.assert_called_once_with(notebook_path)
+        mock_generate_code.assert_called_once_with(mock_notebook_data)
+        mock_validator.assert_called_once_with("import streamlit\nst.title('Test')", notebook_path)
+        mock_create_file.assert_called_once_with(expected_app_path, "import streamlit\nst.title('Test')")
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.parse_jupyter_notebook_to_extract_required_content')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.generate_new_streamlit_code')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.correct_error_in_generation')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.validate_app')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.log_streamlit_app_validation_retry')
+    async def test_streamlit_handler_max_retries_exceeded(self, mock_log_retry, mock_validator, mock_correct_error, mock_generate_code, mock_parse):
+        """Test streamlit handler when max retries are exceeded"""
+        # Mock notebook parsing
+        mock_notebook_data: List[dict] = [{"cells": []}]
+        mock_parse.return_value = mock_notebook_data
+    
+        # Mock code generation
+        mock_generate_code.return_value = "import streamlit\nst.title('Test')"
+        mock_correct_error.return_value = "import streamlit\nst.title('Fixed')"
+    
+        # Mock validation (always errors) - validate_app returns List[str]
+        mock_validator.return_value = ["Persistent error"]
+    
+        # Now it should raise an exception instead of returning a tuple
+        with pytest.raises(Exception):
+            await streamlit_handler(AbsoluteNotebookPath("notebook.ipynb"), AppFileName('test-app-file-name.py'))
+        
+        # Verify that error correction was called 5 times (once per error, 5 retries)
+        # Each retry processes 1 error, so 5 retries = 5 calls
+        assert mock_correct_error.call_count == 5
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.parse_jupyter_notebook_to_extract_required_content')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.generate_new_streamlit_code')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.validate_app')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.create_app_file')
+    async def test_streamlit_handler_file_creation_failure(self, mock_create_file, mock_validator, mock_generate_code, mock_parse):
+        """Test streamlit handler when file creation fails"""
+        # Mock notebook parsing
+        mock_notebook_data: List[dict] = [{"cells": []}]
+        mock_parse.return_value = mock_notebook_data
+        
+        # Mock code generation
+        mock_generate_code.return_value = "import streamlit\nst.title('Test')"
+        
+        # Mock validation (no errors) - validate_app returns List[str]
+        mock_validator.return_value = []
+        
+        # Mock file creation failure - now it should raise an exception
+        mock_create_file.side_effect = Exception("Permission denied")
+        
+        # Now it should raise an exception instead of returning a tuple
+        with pytest.raises(Exception):
+            await streamlit_handler(AbsoluteNotebookPath("notebook.ipynb"), AppFileName('test-app-file-name.py'))
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.parse_jupyter_notebook_to_extract_required_content')
+    async def test_streamlit_handler_parse_notebook_exception(self, mock_parse):
+        """Test streamlit handler when notebook parsing fails"""
+        
+        mock_parse.side_effect = FileNotFoundError("Notebook not found")
+        
+        with pytest.raises(FileNotFoundError, match="Notebook not found"):
+            await streamlit_handler(AbsoluteNotebookPath("notebook.ipynb"), AppFileName('test-app-file-name.py'))
+
+    @pytest.mark.asyncio
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.parse_jupyter_notebook_to_extract_required_content')
+    @patch('mito_ai.streamlit_conversion.streamlit_agent_handler.generate_new_streamlit_code')
+    async def test_streamlit_handler_generation_exception(self, mock_generate_code, mock_parse):
+        """Test streamlit handler when code generation fails"""
+        # Mock notebook parsing
+        mock_notebook_data: List[dict] = [{"cells": []}]
+        mock_parse.return_value = mock_notebook_data
+        
+        # Mock code generation failure
+        mock_generate_code.side_effect = Exception("Generation failed")
+        
+        with pytest.raises(Exception, match="Generation failed"):
+            await streamlit_handler(AbsoluteNotebookPath("notebook.ipynb"), AppFileName('test-app-file-name.py'))
+
+
+

mito_ai/tests/streamlit_conversion/test_streamlit_utils.py

@@ -0,0 +1,193 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+import pytest
+import json
+import tempfile
+import os
+from unittest.mock import patch, mock_open
+from mito_ai.streamlit_conversion.streamlit_utils import (
+    extract_code_blocks,
+    create_app_file,
+    parse_jupyter_notebook_to_extract_required_content
+)
+from mito_ai.path_utils import AbsoluteAppPath, AbsoluteNotebookDirPath, AbsoluteNotebookPath, get_absolute_notebook_path
+from typing import Dict, Any
+
+class TestExtractCodeBlocks:
+    """Test cases for extract_code_blocks function"""
+
+    def test_extract_code_blocks_with_python_blocks(self):
+        """Test extracting code from message with python code blocks"""
+        message = "Here's some code:\n```python\nimport streamlit\nst.title('Hello')\n```\nThat's it!"
+        result = extract_code_blocks(message)
+        expected = "import streamlit\nst.title('Hello')\n"
+        assert result == expected
+
+    def test_extract_code_blocks_without_python_blocks(self):
+        """Test when message doesn't contain python code blocks"""
+        message = "This is just regular text without code blocks"
+        result = extract_code_blocks(message)
+        assert result == message
+
+    def test_extract_code_blocks_empty_message(self):
+        """Test with empty message"""
+        message = ""
+        result = extract_code_blocks(message)
+        assert result == message
+
+    def test_extract_code_blocks_multiple_blocks(self):
+        """Test extracting from first python block when multiple exist"""
+        message = "```python\ncode1\n```\n```python\ncode2\n```"
+        result = extract_code_blocks(message)
+        expected = "code1\n\ncode2\n"
+        assert result == expected
+
+
+class TestCreateAppFile:
+    """Test cases for create_app_file function"""
+
+    def test_create_app_file_success(self, tmp_path):
+        """Test successful file creation"""
+        app_path = os.path.join(str(tmp_path), "app.py")
+        code = "import streamlit\nst.title('Test')"
+        
+        create_app_file(AbsoluteAppPath(app_path), code)
+        
+        assert app_path is not None
+        assert os.path.exists(app_path)
+        
+        # Verify file was created with correct content
+        with open(app_path, 'r') as f:
+            content = f.read()
+        assert content == code
+
+    def test_create_app_file_io_error(self):
+        """Test file creation with IO error"""
+        file_path = AbsoluteAppPath("/nonexistent/path/that/should/fail")
+        code = "import streamlit"
+        
+        with pytest.raises(Exception):
+            create_app_file(file_path, code)
+
+    @patch('builtins.open', side_effect=Exception("Unexpected error"))
+    def test_create_app_file_unexpected_error(self, mock_open):
+        """Test file creation with unexpected error"""
+        app_path = AbsoluteAppPath("/tmp/test")
+        code = "import streamlit"
+        
+        with pytest.raises(Exception, match="Unexpected error"):
+            create_app_file(app_path, code)
+
+    def test_create_app_file_empty_code(self, tmp_path):
+        """Test creating file with empty code"""
+        app_path = AbsoluteAppPath(os.path.join(str(tmp_path), "app.py"))
+        code = ""
+        
+        create_app_file(app_path, code)
+        
+        assert app_path is not None
+        assert os.path.exists(app_path)
+        
+        with open(app_path, 'r') as f:
+            content = f.read()
+        assert content == ""
+
+
+class TestParseJupyterNotebookToExtractRequiredContent:
+    """Test cases for parse_jupyter_notebook_to_extract_required_content function"""
+
+    def test_parse_valid_notebook(self, tmp_path):
+        """Test parsing a valid notebook with cells"""
+        notebook_data: Dict[str, Any] = {
+            "cells": [
+                {
+                    "cell_type": "code",
+                    "source": ["import pandas as pd\n", "df = pd.DataFrame()\n"],
+                    "metadata": {"some": "metadata"},
+                    "execution_count": 1
+                },
+                {
+                    "cell_type": "markdown",
+                    "source": ["# Title\n", "Some text\n"],
+                    "metadata": {"another": "metadata"}
+                }
+            ],
+            "metadata": {"notebook_metadata": "value"},
+            "nbformat": 4
+        }
+        
+        notebook_path = tmp_path / "test.ipynb"
+        with open(notebook_path, 'w') as f:
+            json.dump(notebook_data, f)
+        
+        absolute_path = get_absolute_notebook_path(str(notebook_path))
+        result = parse_jupyter_notebook_to_extract_required_content(absolute_path)
+        
+        # Check that only cell_type and source are preserved
+        assert len(result) == 2
+        assert result[0]['cell_type'] == 'code'
+        assert result[0]['source'] == ["import pandas as pd\n", "df = pd.DataFrame()\n"]
+        assert 'metadata' not in result[0]
+        assert 'execution_count' not in result[0]
+        
+        assert result[1]['cell_type'] == 'markdown'
+        assert result[1]['source'] == ["# Title\n", "Some text\n"]
+        assert 'metadata' not in result[1]
+
+    def test_parse_notebook_file_not_found(self):
+        """Test parsing non-existent notebook file"""
+        from mito_ai.utils.error_classes import StreamlitConversionError
+        with pytest.raises(StreamlitConversionError, match="Notebook file not found"):
+            parse_jupyter_notebook_to_extract_required_content(AbsoluteNotebookPath("/nonexistent/path/notebook.ipynb"))
+
+    def test_parse_notebook_with_missing_cell_fields(self, tmp_path):
+        """Test parsing notebook where cells are missing cell_type or source"""
+        notebook_data: Dict[str, Any] = {
+            "cells": [
+                {
+                    "cell_type": "code"
+                    # Missing source field
+                },
+                {
+                    "source": ["some text"]
+                    # Missing cell_type field
+                },
+                {
+                    "cell_type": "markdown",
+                    "source": ["# Title"]
+                }
+            ]
+        }
+        
+        notebook_path = tmp_path / "test.ipynb"
+        with open(notebook_path, 'w') as f:
+            json.dump(notebook_data, f)
+        
+        absolute_path = get_absolute_notebook_path(str(notebook_path))
+        result = parse_jupyter_notebook_to_extract_required_content(absolute_path)
+        
+        assert len(result) == 3
+        assert result[0]['cell_type'] == 'code'
+        assert result[0]['source'] == []  # Default empty list
+        
+        assert result[1]['cell_type'] == ''  # Default empty string
+        assert result[1]['source'] == ["some text"]
+        
+        assert result[2]['cell_type'] == 'markdown'
+        assert result[2]['source'] == ["# Title"]
+
+    def test_parse_empty_notebook(self, tmp_path):
+        """Test parsing notebook with empty cells list"""
+        notebook_data: Dict[str, Any] = {
+            "cells": []
+        }
+        
+        notebook_path = tmp_path / "test.ipynb"
+        with open(notebook_path, 'w') as f:
+            json.dump(notebook_data, f)
+        
+        absolute_path = get_absolute_notebook_path(str(notebook_path))
+        result = parse_jupyter_notebook_to_extract_required_content(absolute_path)
+        
+        assert result == []