slidemovie 0.1.0__tar.gz → 0.2.0__tar.gz

{slidemovie-0.1.0/slidemovie.egg-info → slidemovie-0.2.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: slidemovie
-Version: 0.1.0
+Version: 0.2.0
 Summary: Markdown and PowerPoint to narration video generator
 Author: Katsutoshi Seki
 License-Expression: MIT
 Project-URL: Homepage, https://sekika.github.io/slidemovie/
 Project-URL: Source, https://github.com/sekika/slidemovie
 Keywords: powerpoint,markdown,video,tts,presentation,automation
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Operating System :: OS Independent
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
 Classifier: Topic :: Office/Business :: Office Suites

{slidemovie-0.1.0 → slidemovie-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slidemovie"
-version = "0.1.0"
+version = "0.2.0"
 description = "Markdown and PowerPoint to narration video generator"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -14,7 +14,7 @@ authors = [
 ]
 keywords = ["powerpoint", "markdown", "video", "tts", "presentation", "automation"]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "Intended Audience :: Education",
     "Operating System :: OS Independent",
@@ -24,6 +24,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Multimedia :: Video",
     "Topic :: Multimedia :: Sound/Audio :: Speech",
     "Topic :: Office/Business :: Office Suites",

{slidemovie-0.1.0 → slidemovie-0.2.0}/slidemovie/cli.py

@@ -79,7 +79,8 @@ def main():
     parser.add_argument("--tts-provider", help="TTS Provider (e.g., google, openai)")
     parser.add_argument("--tts-model", help="TTS Model name")
     parser.add_argument("--tts-voice", help="TTS Voice/Speaker setting")
-    parser.add_argument("--prompt", help="Override TTS system prompt")
+    parser.add_argument("--prompt", help="Override TTS system prompt (automatically enables prompt usage)")
+    parser.add_argument("--no-prompt", action="store_true", help="Disable TTS system prompt")
 
     # --- Other Options ---
     parser.add_argument(
@@ -114,6 +115,9 @@ def main():
         movie.tts_voice = args.tts_voice
     if args.prompt:
         movie.prompt = args.prompt
+        movie.tts_use_prompt = True
+    if args.no_prompt:
+        movie.tts_use_prompt = False
     
     if args.debug:
         movie.ffmpeg_loglevel = 'info'

{slidemovie-0.1.0 → slidemovie-0.2.0}/slidemovie/core.py

@@ -180,6 +180,7 @@ class Movie():
         for key, value in config.items():
             setattr(self, key, value)
 
+
     def configure_project_paths(self, project_name, source_dir, output_root_dir=None, output_filename=None):
         """
         Configures paths for a standard (flat) project structure.
@@ -193,18 +194,35 @@ class Movie():
                                              Defaults to `project_name`.
         """
         # Determine output root directory
+        target_root = None
+        is_automatic_path = False
+
         if output_root_dir:
             target_root = output_root_dir
         elif self.output_root:
             target_root = self.output_root
         else:
             target_root = f'{source_dir}/movie'
+            is_automatic_path = True
         
-        # Expand path and check existence
+        # Expand path
         target_root = os.path.expanduser(target_root)
-        if not os.path.isdir(target_root):
-            logger.error(f'Directory {target_root} does not exist.')
-            sys.exit(1)
+
+        # Handle directory existence
+        if is_automatic_path:
+            # If the path is automatically determined, create it if it doesn't exist
+            if not os.path.isdir(target_root):
+                try:
+                    os.makedirs(target_root, exist_ok=True)
+                    logger.info(f'Created output directory: {target_root}')
+                except OSError as e:
+                    logger.error(f'Failed to create directory {target_root}: {e}')
+                    sys.exit(1)
+        else:
+            # If the path is explicitly specified (CLI or Config), strict check is applied
+            if not os.path.isdir(target_root):
+                logger.error(f'Directory {target_root} does not exist.')
+                sys.exit(1)
 
         # Set member variables
         self.source_dir = source_dir
@@ -226,7 +244,6 @@ class Movie():
         self.slide_file = f'{self.source_dir}/{project_name}.pptx'
         self.video_file = f'{self.movie_dir}/{output_filename}.mp4'
 
-
     def configure_subproject_paths(self, parent_project_name, subproject_name, source_parent_dir, output_root_dir=None, output_filename=None):
         """
         Configures paths for a nested project structure (Parent Folder -> Child Folder).
@@ -239,18 +256,35 @@ class Movie():
             output_filename (str, optional): Filename for the output video (without extension).
         """
         # Determine output root directory
+        target_root = None
+        is_automatic_path = False
+
         if output_root_dir:
             target_root = output_root_dir
         elif self.output_root:
             target_root = self.output_root
         else:
             target_root = f'{source_parent_dir}/movie'
+            is_automatic_path = True
         
-        # Expand path and check existence
+        # Expand path
         target_root = os.path.expanduser(target_root)
-        if not os.path.isdir(target_root):
-            logger.error(f'Directory {target_root} does not exist.')
-            sys.exit(1)
+
+        # Handle directory existence
+        if is_automatic_path:
+            # If the path is automatically determined, create it if it doesn't exist
+            if not os.path.isdir(target_root):
+                try:
+                    os.makedirs(target_root, exist_ok=True)
+                    logger.info(f'Created output directory: {target_root}')
+                except OSError as e:
+                    logger.error(f'Failed to create directory {target_root}: {e}')
+                    sys.exit(1)
+        else:
+            # If the path is explicitly specified (CLI or Config), strict check is applied
+            if not os.path.isdir(target_root):
+                logger.error(f'Directory {target_root} does not exist.')
+                sys.exit(1)
 
         # Source directory is "Parent/Child"
         self.source_dir = f'{source_parent_dir}/{subproject_name}'

{slidemovie-0.1.0 → slidemovie-0.2.0/slidemovie.egg-info}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: slidemovie
-Version: 0.1.0
+Version: 0.2.0
 Summary: Markdown and PowerPoint to narration video generator
 Author: Katsutoshi Seki
 License-Expression: MIT
 Project-URL: Homepage, https://sekika.github.io/slidemovie/
 Project-URL: Source, https://github.com/sekika/slidemovie
 Keywords: powerpoint,markdown,video,tts,presentation,automation
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Operating System :: OS Independent
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
 Classifier: Topic :: Office/Business :: Office Suites

{slidemovie-0.1.0 → slidemovie-0.2.0}/slidemovie.egg-info/SOURCES.txt

@@ -10,4 +10,6 @@ slidemovie.egg-info/SOURCES.txt
 slidemovie.egg-info/dependency_links.txt
 slidemovie.egg-info/entry_points.txt
 slidemovie.egg-info/requires.txt
-slidemovie.egg-info/top_level.txt
+slidemovie.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_core.py

slidemovie-0.2.0/tests/test_cli.py

@@ -0,0 +1,116 @@
+import pytest
+import sys
+from unittest.mock import MagicMock, patch
+import os
+
+# Add parent directory to sys.path to ensure slidemovie module is found
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+import slidemovie.cli as cli
+
+@pytest.fixture
+def mock_movie_class(mocker):
+    """Mock the slidemovie.Movie class."""
+    return mocker.patch('slidemovie.Movie')
+
+def test_cli_help(capsys):
+    """Test that help is displayed and system exits if no args provided."""
+    with patch.object(sys, 'argv', ['slidemovie']):
+        with pytest.raises(SystemExit):
+            cli.main()
+        
+        captured = capsys.readouterr()
+        # Verify usage/help text is printed
+        assert "usage:" in captured.err or "usage:" in captured.out
+
+def test_cli_pptx_mode(mock_movie_class):
+    """Test the --pptx option."""
+    test_args = ['slidemovie', 'MyProject', '--pptx']
+    
+    # Get the mock instance
+    mock_instance = mock_movie_class.return_value
+    
+    with patch.object(sys, 'argv', test_args):
+        cli.main()
+        
+    # Check if Movie was instantiated
+    mock_movie_class.assert_called_once()
+    
+    # Check if default path configuration was called (Flat mode)
+    mock_instance.configure_project_paths.assert_called_with(
+        project_name='MyProject',
+        source_dir='.',
+        output_root_dir=None,
+        output_filename=None
+    )
+    
+    # Check if correct build method was called
+    mock_instance.build_slide_pptx.assert_called_once()
+    # build_all should not be called in this mode
+    mock_instance.build_all.assert_not_called()
+
+def test_cli_video_mode_subproject(mock_movie_class):
+    """Test --video option with --sub (Subproject mode) and debug flag."""
+    test_args = ['slidemovie', 'ParentProj', '--sub', 'ChildProj', '--video', '--debug']
+    
+    mock_instance = mock_movie_class.return_value
+    
+    with patch.object(sys, 'argv', test_args):
+        cli.main()
+        
+    # Verify debug settings applied
+    assert mock_instance.ffmpeg_loglevel == 'info'
+    assert mock_instance.show_skip is True
+    
+    # Verify subproject path configuration
+    mock_instance.configure_subproject_paths.assert_called_with(
+        parent_project_name='ParentProj',
+        subproject_name='ChildProj',
+        source_parent_dir='.',
+        output_root_dir=None,
+        output_filename=None
+    )
+    
+    # Verify build_all was called
+    mock_instance.build_all.assert_called_once()
+
+def test_cli_override_tts_options(mock_movie_class):
+    """Test if CLI arguments override TTS configuration."""
+    test_args = [
+        'slidemovie', 'Proj', '--video',
+        '--tts-provider', 'openai',
+        '--tts-model', 'gpt-4',
+        '--tts-voice', 'alloy',
+        '--prompt', 'New System Prompt'
+    ]
+    
+    mock_instance = mock_movie_class.return_value
+    
+    with patch.object(sys, 'argv', test_args):
+        cli.main()
+        
+    assert mock_instance.tts_provider == 'openai'
+    assert mock_instance.tts_model == 'gpt-4'
+    assert mock_instance.tts_voice == 'alloy'
+    assert mock_instance.prompt == 'New System Prompt'
+
+def test_cli_prompt_logic(mock_movie_class):
+    """Test behavior of --prompt and --no-prompt flags."""
+    mock_instance = mock_movie_class.return_value
+
+    # Case 1: --prompt should enable usage and set text
+    args_case1 = ['slidemovie', 'Proj', '--video', '--prompt', 'Custom Prompt']
+    with patch.object(sys, 'argv', args_case1):
+        cli.main()
+    
+    assert mock_instance.prompt == 'Custom Prompt'
+    assert mock_instance.tts_use_prompt is True
+
+    # Case 2: --no-prompt should disable usage
+    # Reset mock for next call
+    mock_movie_class.reset_mock()
+    
+    args_case2 = ['slidemovie', 'Proj', '--video', '--no-prompt']
+    with patch.object(sys, 'argv', args_case2):
+        cli.main()
+        
+    assert mock_instance.tts_use_prompt is False

slidemovie-0.2.0/tests/test_core.py

@@ -0,0 +1,174 @@
+import os
+import json
+import pytest
+import sys
+from unittest.mock import MagicMock, patch
+
+# Add parent directory to sys.path to import slidemovie module
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Mock external libraries before importing core
+sys.modules['multiai_tts'] = MagicMock()
+sys.modules['pptxtoimages'] = MagicMock()
+sys.modules['pptxtoimages.tools'] = MagicMock()
+
+from slidemovie.core import Movie
+
+@pytest.fixture
+def mock_tools(mocker):
+    """
+    Mock shutil.which to bypass external tool checks (ffmpeg, pandoc)
+    during initialization.
+    """
+    mocker.patch('shutil.which', return_value='/usr/bin/mocked_tool')
+
+@pytest.fixture
+def movie(mock_tools):
+    """Fixture to create a Movie instance."""
+    m = Movie()
+    # Reset output_root to None to ensure tests rely on the source_dir structure
+    # and ignore any user-defined 'output_root' in local config.json.
+    m.output_root = None
+    return m
+
+class TestMovieConfig:
+    def test_default_settings(self, movie):
+        """Test if settings are loaded (checking key existence)."""
+        # We check existence because actual values might be overridden by local config
+        assert hasattr(movie, 'tts_provider')
+        assert hasattr(movie, 'screen_size')
+
+    def test_load_settings_override(self, mock_tools, tmp_path):
+        """Test overriding settings via config.json logic."""
+        # Note: Since _load_settings is called in __init__, testing exact loading
+        # behavior without mocking open() globally is complex. 
+        # Here we just verify the instance attributes can be set.
+        pass 
+
+class TestPathConfiguration:
+    def test_configure_project_paths_flat(self, movie, tmp_path):
+        """Test path configuration for standard (flat) mode."""
+        # Ensure output_root is None so it falls back to source_dir/movie
+        movie.output_root = None
+        
+        source_dir = tmp_path / "src"
+        source_dir.mkdir()
+        
+        movie.configure_project_paths(
+            project_name="test_proj",
+            source_dir=str(source_dir)
+        )
+        
+        assert movie.project_id == "test_proj"
+        assert movie.md_file == str(source_dir / "test_proj.md")
+        
+        # Default output: source_dir/movie/project_name
+        expected_movie_dir = source_dir / "movie" / "test_proj"
+        assert movie.movie_dir == str(expected_movie_dir)
+        assert os.path.exists(movie.movie_dir)
+
+    def test_configure_subproject_paths(self, movie, tmp_path):
+        """Test path configuration for subproject (Parent/Child) mode."""
+        movie.output_root = None
+        
+        parent_dir = tmp_path / "parent"
+        parent_dir.mkdir()
+        
+        movie.configure_subproject_paths(
+            parent_project_name="parent_proj",
+            subproject_name="child_sub",
+            source_parent_dir=str(parent_dir)
+        )
+        
+        assert movie.project_id == "parent_proj-child_sub"
+        assert movie.source_dir == str(parent_dir / "child_sub")
+        
+        # Output: parent/movie/parent_proj/child_sub
+        expected_movie_dir = parent_dir / "movie" / "parent_proj" / "child_sub"
+        assert movie.movie_dir == str(expected_movie_dir)
+
+class TestMarkdownProcessing:
+    def test_ensure_slide_ids(self, movie, tmp_path):
+        """Test if slide-ids are automatically injected into Markdown."""
+        md_content = """# Slide 1
+::: notes
+Note 1
+:::
+
+# Slide 2
+::: notes
+Note 2
+:::
+"""
+        md_file = tmp_path / "test.md"
+        md_file.write_text(md_content, encoding='utf-8')
+        
+        movie.md_file = str(md_file)
+        movie.project_id = "TEST"
+        
+        movie._ensure_slide_ids()
+        
+        updated_content = md_file.read_text(encoding='utf-8')
+        assert "<!-- slide-id: TEST-01 -->" in updated_content
+        assert "<!-- slide-id: TEST-02 -->" in updated_content
+
+    def test_extract_slides_list(self, movie, tmp_path):
+        """Test extracting slide information from Markdown."""
+        md_content = """<!-- slide-id: s-01 -->
+# Title A
+::: notes
+Note A
+:::
+
+<!-- slide-id: s-02 -->
+<!-- video-file: demo.mp4 -->
+# Title B
+"""
+        md_file = tmp_path / "extract.md"
+        md_file.write_text(md_content, encoding='utf-8')
+        movie.md_file = str(md_file)
+        
+        slides = movie._extract_slides_list()
+        
+        assert len(slides) == 2
+        assert slides[0]['id'] == 's-01'
+        assert slides[0]['title'] == 'Title A'
+        
+        assert slides[1]['id'] == 's-02'
+        assert slides[1]['video_file'] == 'demo.mp4'
+
+class TestBuildLogic:
+    def test_build_slide_pptx(self, movie, tmp_path, mocker):
+        """Test if the pandoc command is constructed and called correctly."""
+        # Setup files
+        md_file = tmp_path / "test.md"
+        md_file.touch()
+        movie.md_file = str(md_file)
+        movie.slide_file = str(tmp_path / "test.pptx")
+        movie.source_dir = str(tmp_path)
+        
+        # [Fix] Manually set project_id as it is required by _init_audio_state
+        movie.project_id = "test_project"
+        
+        # Mock status file
+        movie.status_file = str(tmp_path / "status.json")
+        
+        # Mock subprocess
+        mock_run = mocker.patch('subprocess.check_call')
+        
+        movie.build_slide_pptx()
+        
+        # Verify call
+        mock_run.assert_called_once()
+        args, _ = mock_run.call_args
+        command_str = args[0]
+        assert "pandoc" in command_str
+        assert str(md_file) in command_str
+
+    def test_check_external_tools_missing(self, mocker):
+        """Test if program exits when tools are missing."""
+        mocker.patch('shutil.which', return_value=None)
+        
+        with pytest.raises(SystemExit) as e:
+            Movie()
+        assert e.value.code == 1