youtube-to-docs 0.0.18__tar.gz

youtube_to_docs-0.0.18/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 DoIT - Artificial Intelligence
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

youtube_to_docs-0.0.18/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: youtube-to-docs
+Version: 0.0.18
+Summary: Convert YouTube videos into structured docs, summaries, audio, and visual assets for easier discovery
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastexcel>=0.12.0
+Requires-Dist: google-api-python-client>=2.187.0
+Requires-Dist: google-auth-oauthlib
+Requires-Dist: google-genai
+Requires-Dist: isodate>=0.7.2
+Requires-Dist: mcp>=1.25.0
+Requires-Dist: msal>=1.34.0
+Requires-Dist: openai>=1.56.0
+Requires-Dist: polars>=1.36.1
+Requires-Dist: pypandoc>=1.16.2
+Requires-Dist: pypandoc_binary>=1.16.2
+Requires-Dist: requests>=2.32.5
+Requires-Dist: static-ffmpeg>=2.13
+Requires-Dist: xlsxwriter>=3.2.9
+Requires-Dist: youtube-transcript-api>=1.2.3
+Requires-Dist: yt-dlp>=2025.12.8
+Dynamic: license-file
+
+# youtube-to-docs
+[![PyPI version](https://img.shields.io/pypi/v/youtube-to-docs.svg)](https://pypi.org/project/youtube-to-docs/)
+
+Convert YouTube videos into structured docs, summaries, audio, and visual assets for easier discovery.
+
+View all available CLI options:
+
+```bash
+uvx youtube-to-docs --help
+```
+
+Install as a Gemini CLI extension:
+
+```bash
+gemini extensions install https://github.com/DoIT-Artificial-Intelligence/youtube-to-docs.git
+```
+
+*Created with the help of AI. All artifacts have been checked and work as expected.*

youtube_to_docs-0.0.18/README.md

@@ -0,0 +1,18 @@
+# youtube-to-docs
+[![PyPI version](https://img.shields.io/pypi/v/youtube-to-docs.svg)](https://pypi.org/project/youtube-to-docs/)
+
+Convert YouTube videos into structured docs, summaries, audio, and visual assets for easier discovery.
+
+View all available CLI options:
+
+```bash
+uvx youtube-to-docs --help
+```
+
+Install as a Gemini CLI extension:
+
+```bash
+gemini extensions install https://github.com/DoIT-Artificial-Intelligence/youtube-to-docs.git
+```
+
+*Created with the help of AI. All artifacts have been checked and work as expected.*

youtube_to_docs-0.0.18/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[dependency-groups]
+dev = [
+    "mkdocs>=1.6.1",
+    "mkdocs-material>=9.7.1",
+]
+test = [
+    "pytest>=9.0.2",
+    "pytest-mock>=3.15.1",
+]
+
+[project]
+name = "youtube-to-docs"
+version = "0.0.18"
+description = "Convert YouTube videos into structured docs, summaries, audio, and visual assets for easier discovery"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "fastexcel>=0.12.0",
+    "google-api-python-client>=2.187.0",
+    "google-auth-oauthlib",
+    "google-genai",
+    "isodate>=0.7.2",
+    "mcp>=1.25.0",
+    "msal>=1.34.0",
+    "openai>=1.56.0",
+    "polars>=1.36.1",
+    "pypandoc>=1.16.2",
+    "pypandoc_binary>=1.16.2",
+    "requests>=2.32.5",
+    "static-ffmpeg>=2.13",
+    "xlsxwriter>=3.2.9",
+    "youtube-transcript-api>=1.2.3",
+    "yt-dlp>=2025.12.8",
+]
+
+[project.scripts]
+youtube-to-docs = "youtube_to_docs.main:main"
+
+[tool.setuptools.packages.find]
+include = ["youtube_to_docs*"]
+exclude = ["tests*", "docs*", "youtube-to-docs-artifacts*", "summary-files*", "transcript-files*", "audio-files*", "infographic-files*", "speaker-extraction-files*", "qa-files*", "video-files*"]
+
+[tool.ruff]
+# Match the project's Python version requirement
+target-version = "py314"
+line-length = 88
+
+[tool.ruff.lint]
+# Enable Pyflakes (`F`), pycodestyle (`E`, `W`), and isort (`I`)
+select = ["E", "F", "I", "W"]
+ignore = []
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+[tool.ruff.format]
+# Use double quotes for strings.
+quote-style = "double"
+# Indent with spaces, rather than tabs.
+indent-style = "space"
+# Respect magic trailing commas.
+skip-magic-trailing-comma = false
+# Automatically detect the appropriate line ending.
+line-ending = "auto"
+
+[tool.ty.environment]
+# Target Python 3.14 to match project requirements
+python-version = "3.14"
+
+

youtube_to_docs-0.0.18/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

youtube_to_docs-0.0.18/tests/test_infographic.py

@@ -0,0 +1,220 @@
+import os
+import unittest
+from unittest import mock
+from unittest.mock import MagicMock, patch
+
+from youtube_to_docs import infographic
+
+
+class TestInfographic(unittest.TestCase):
+    def setUp(self):
+        # Mock environment variables
+        self.env_patcher = patch.dict(
+            os.environ,
+            {
+                "GEMINI_API_KEY": "fake_gemini_key",
+                "AWS_BEARER_TOKEN_BEDROCK": "fake_bedrock_token",
+                "AZURE_FOUNDRY_ENDPOINT": "fake_endpoint",
+                "AZURE_FOUNDRY_API_KEY": "fake_foundry_key",
+            },
+        )
+        self.env_patcher.start()
+
+    def tearDown(self):
+        self.env_patcher.stop()
+
+    @patch("youtube_to_docs.infographic.genai.Client")
+    def test_generate_infographic_gemini(self, mock_client_cls):
+        mock_client = mock_client_cls.return_value
+
+        # Mocking the stream response for generate_content_stream
+        mock_chunk = MagicMock()
+        mock_part = MagicMock()
+        mock_part.inline_data.data = b"fake_gemini_bytes"
+        mock_chunk.candidates = [MagicMock(content=MagicMock(parts=[mock_part]))]
+        mock_chunk.usage_metadata.prompt_token_count = 10
+        mock_chunk.usage_metadata.candidates_token_count = 20
+
+        mock_client.models.generate_content_stream.return_value = [mock_chunk]
+
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            "gemini-2.5-flash-image", "Summary text", "Video Title"
+        )
+
+        self.assertEqual(image_bytes, b"fake_gemini_bytes")
+        self.assertEqual(in_tok, 10)
+        self.assertEqual(out_tok, 20)
+        mock_client.models.generate_content_stream.assert_called_once()
+
+    @patch("youtube_to_docs.infographic.genai.Client")
+    def test_generate_infographic_imagen(self, mock_client_cls):
+        mock_client = mock_client_cls.return_value
+        mock_resp = MagicMock()
+
+        # Mocking the response structure for generate_images
+        mock_image = MagicMock()
+        mock_image.image.image_bytes = b"fake_imagen_bytes"
+        mock_resp.generated_images = [mock_image]
+
+        mock_client.models.generate_images.return_value = mock_resp
+
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            "imagen-4.0-generate-001", "Summary text", "Video Title"
+        )
+
+        self.assertEqual(image_bytes, b"fake_imagen_bytes")
+        self.assertEqual(in_tok, 0)
+        self.assertEqual(out_tok, 1000)
+        mock_client.models.generate_images.assert_called_once()
+
+    def test_generate_infographic_none_model(self):
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            None, "Summary text", "Video Title"
+        )
+        self.assertIsNone(image_bytes)
+        self.assertEqual(in_tok, 0)
+        self.assertEqual(out_tok, 0)
+
+    def test_generate_infographic_unsupported_model(self):
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            "unsupported-model", "Summary text", "Video Title"
+        )
+        self.assertIsNone(image_bytes)
+        self.assertEqual(in_tok, 0)
+        self.assertEqual(out_tok, 0)
+
+    @patch("youtube_to_docs.infographic.genai.Client")
+    def test_generate_infographic_imagen_no_images(self, mock_client_cls):
+        mock_client = mock_client_cls.return_value
+        mock_resp = MagicMock()
+        mock_resp.generated_images = []
+        mock_client.models.generate_images.return_value = mock_resp
+
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            "imagen-4.0-generate-001", "Summary text", "Video Title"
+        )
+        self.assertIsNone(image_bytes)
+        self.assertEqual(in_tok, 0)
+        self.assertEqual(out_tok, 0)
+
+    @patch("youtube_to_docs.infographic.genai.Client")
+    def test_generate_infographic_gemini_no_data(self, mock_client_cls):
+        mock_client = mock_client_cls.return_value
+
+        # Mocking a stream with no inline data
+        mock_chunk = MagicMock()
+        mock_chunk.candidates = [
+            MagicMock(content=MagicMock(parts=[MagicMock(inline_data=None)]))
+        ]
+        mock_chunk.usage_metadata = None
+
+        mock_client.models.generate_content_stream.return_value = [mock_chunk]
+
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            "gemini-2.5-flash-image", "Summary text", "Video Title"
+        )
+        self.assertIsNone(image_bytes)
+        self.assertEqual(in_tok, 0)
+        self.assertEqual(out_tok, 0)
+
+    @patch("youtube_to_docs.infographic.requests.post")
+    def test_generate_infographic_bedrock(self, mock_post):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        # "fake_bytes" in base64 is "ZmFrZV9ieXRlcw=="
+        mock_resp.json.return_value = {"images": ["ZmFrZV9ieXRlcw=="]}
+        mock_post.return_value = mock_resp
+
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            "bedrock-titan-image-generator-v2", "Summary text", "Video Title"
+        )
+
+        self.assertEqual(image_bytes, b"fake_bytes")
+        self.assertEqual(in_tok, 0)
+        self.assertEqual(out_tok, 1000)
+        mock_post.assert_called_once()
+        # Check if actual_model_id was mapped correctly
+        args, kwargs = mock_post.call_args
+        self.assertIn("amazon.titan-image-generator-v2:0", args[0])
+
+    @patch("youtube_to_docs.infographic.requests.post")
+    def test_generate_infographic_bedrock_nova(self, mock_post):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.json.return_value = {"images": ["ZmFrZV9ieXRlcw=="]}
+        mock_post.return_value = mock_resp
+
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            "bedrock-nova-canvas-v1", "Summary text", "Video Title"
+        )
+
+        self.assertEqual(image_bytes, b"fake_bytes")
+        self.assertEqual(in_tok, 0)
+        self.assertEqual(out_tok, 4000)
+        mock_post.assert_called_once()
+        # Check if actual_model_id was mapped correctly
+        args, kwargs = mock_post.call_args
+        self.assertIn("amazon.nova-canvas-v1:0", args[0])
+
+    @patch("youtube_to_docs.infographic.requests.post")
+    def test_generate_infographic_bedrock_with_suffix(self, mock_post):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.json.return_value = {"images": ["ZmFrZV9ieXRlcw=="]}
+        mock_post.return_value = mock_resp
+
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            "bedrock-nova-canvas-v1:0", "Summary text", "Video Title"
+        )
+
+        self.assertEqual(image_bytes, b"fake_bytes")
+        mock_post.assert_called_once()
+        # Check that it didn't double the :0
+        args, kwargs = mock_post.call_args
+        self.assertIn("amazon.nova-canvas-v1:0", args[0])
+        self.assertNotIn("amazon.nova-canvas-v1:0:0", args[0])
+
+    @patch("youtube_to_docs.infographic.requests.post")
+    def test_generate_infographic_bedrock_skip_long_prompt(self, mock_post):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.json.return_value = {"images": ["ZmFrZV9ieXRlcw=="]}
+        mock_post.return_value = mock_resp
+
+        long_summary = "A" * 2000
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            "amazon.nova-canvas-v1:0", long_summary, "Video Title"
+        )
+
+        self.assertIsNone(image_bytes)
+        self.assertEqual(in_tok, 0)
+        self.assertEqual(out_tok, 0)
+        mock_post.assert_not_called()
+
+    @patch("youtube_to_docs.infographic.OpenAI")
+    def test_generate_infographic_foundry(self, mock_openai_cls):
+        mock_client = mock_openai_cls.return_value
+        mock_resp = MagicMock()
+        mock_image = MagicMock()
+        mock_image.b64_json = "ZmFrZV9ieXRlcw=="
+        mock_resp.data = [mock_image]
+        mock_client.images.generate.return_value = mock_resp
+
+        image_bytes, in_tok, out_tok = infographic.generate_infographic(
+            "foundry-gpt-image-1.5", "Summary text", "Video Title"
+        )
+
+        self.assertEqual(image_bytes, b"fake_bytes")
+        self.assertEqual(in_tok, 0)
+        self.assertEqual(out_tok, 3400)
+        mock_client.images.generate.assert_called_once_with(
+            model="gpt-image-1.5",
+            prompt=mock.ANY,
+            n=1,
+            size="1536x1024",
+            response_format="b64_json",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

youtube_to_docs-0.0.18/tests/test_llms.py

@@ -0,0 +1,218 @@
+import os
+import unittest
+from unittest.mock import MagicMock, patch
+
+from youtube_to_docs import llms
+
+
+class TestLLMs(unittest.TestCase):
+    def setUp(self):
+        # Mock environment variables
+        self.env_patcher = patch.dict(
+            os.environ,
+            {
+                "GEMINI_API_KEY": "fake_gemini_key",
+                "PROJECT_ID": "fake_project_id",
+                "AWS_BEARER_TOKEN_BEDROCK": "fake_bedrock_token",
+                "AZURE_FOUNDRY_ENDPOINT": "https://fake.openai.azure.com/",
+                "AZURE_FOUNDRY_API_KEY": "fake_foundry_key",
+            },
+        )
+        self.env_patcher.start()
+
+    def tearDown(self):
+        self.env_patcher.stop()
+
+    @patch("youtube_to_docs.llms.genai.Client")
+    def test_generate_summary_gemini(self, mock_client_cls):
+        mock_client = mock_client_cls.return_value
+        mock_resp = MagicMock()
+        mock_resp.text = "Gemini Summary"
+        mock_resp.usage_metadata.prompt_token_count = 100
+        mock_resp.usage_metadata.candidates_token_count = 50
+        mock_client.models.generate_content.return_value = mock_resp
+
+        summary, in_tokens, out_tokens = llms.generate_summary(
+            "gemini-pro", "transcript", "Title", "url"
+        )
+        self.assertEqual(summary, "Gemini Summary")
+        self.assertEqual(in_tokens, 100)
+        self.assertEqual(out_tokens, 50)
+
+    @patch("youtube_to_docs.llms.requests.post")
+    @patch("google.auth.default")
+    def test_generate_summary_vertex(self, mock_auth, mock_post):
+        mock_creds = MagicMock()
+        mock_creds.token = "fake_token"
+        mock_creds.expired = False
+        mock_auth.return_value = (mock_creds, "proj")
+
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.json.return_value = {
+            "content": [{"text": "Vertex Summary"}],
+            "usage": {"input_tokens": 100, "output_tokens": 50},
+        }
+        mock_post.return_value = mock_resp
+
+        summary, in_tokens, out_tokens = llms.generate_summary(
+            "vertex-claude-3-5", "transcript", "Title", "url"
+        )
+        self.assertEqual(summary, "Vertex Summary")
+        self.assertEqual(in_tokens, 100)
+        self.assertEqual(out_tokens, 50)
+
+    @patch("youtube_to_docs.llms.requests.post")
+    def test_generate_summary_bedrock(self, mock_post):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.json.return_value = {
+            "output": {"message": {"content": [{"text": "Bedrock Summary"}]}},
+            "usage": {"inputTokens": 100, "outputTokens": 50},
+        }
+        mock_post.return_value = mock_resp
+
+        summary, in_tokens, out_tokens = llms.generate_summary(
+            "bedrock-claude-3-5", "transcript", "Title", "url"
+        )
+        self.assertEqual(summary, "Bedrock Summary")
+        self.assertEqual(in_tokens, 100)
+        self.assertEqual(out_tokens, 50)
+
+    @patch("youtube_to_docs.llms.OpenAI")
+    def test_generate_summary_foundry(self, mock_openai):
+        mock_client = mock_openai.return_value
+        mock_completion = MagicMock()
+        mock_completion.choices[0].message.content = "Foundry Summary"
+        mock_completion.usage.prompt_tokens = 100
+        mock_completion.usage.completion_tokens = 50
+        mock_client.chat.completions.create.return_value = mock_completion
+
+        summary, in_tokens, out_tokens = llms.generate_summary(
+            "foundry-gpt-4", "transcript", "Title", "url"
+        )
+        self.assertEqual(summary, "Foundry Summary")
+        self.assertEqual(in_tokens, 100)
+        self.assertEqual(out_tokens, 50)
+
+    @patch("youtube_to_docs.llms.genai.Client")
+    def test_extract_speakers_gemini(self, mock_client_cls):
+        mock_client = mock_client_cls.return_value
+        mock_resp = MagicMock()
+        mock_resp.text = "Speaker 1 (Expert)\nSpeaker 2 (UNKNOWN)"
+        mock_resp.usage_metadata.prompt_token_count = 120
+        mock_resp.usage_metadata.candidates_token_count = 30
+        mock_client.models.generate_content.return_value = mock_resp
+
+        speakers, in_tokens, out_tokens = llms.extract_speakers(
+            "gemini-pro", "transcript content"
+        )
+        self.assertEqual(speakers, "Speaker 1 (Expert)\nSpeaker 2 (UNKNOWN)")
+        self.assertEqual(in_tokens, 120)
+        self.assertEqual(out_tokens, 30)
+
+    @patch("youtube_to_docs.llms.genai.Client")
+    def test_generate_qa_gemini(self, mock_client_cls):
+        mock_client = mock_client_cls.return_value
+        mock_resp = MagicMock()
+        mock_resp.text = "| Q | A |\n|---|---|\n| Q1 | A1 |"
+        mock_resp.usage_metadata.prompt_token_count = 150
+        mock_resp.usage_metadata.candidates_token_count = 60
+        mock_client.models.generate_content.return_value = mock_resp
+
+        qa, in_tokens, out_tokens = llms.generate_qa(
+            "gemini-pro", "transcript content", "Speaker 1, Speaker 2"
+        )
+        # Expecting the added column
+        expected_qa = "| question number | Q | A |\n|---|---|---|\n| 1 | Q1 | A1 |"
+        self.assertEqual(qa, expected_qa)
+        self.assertEqual(in_tokens, 150)
+        self.assertEqual(out_tokens, 60)
+
+
+class TestPricing(unittest.TestCase):
+    @patch(
+        "youtube_to_docs.llms.PRICES",
+        {"prices": [{"id": "gpt-4", "input": 30.0, "output": 60.0}]},
+    )
+    def test_get_model_pricing_found(self):
+        inp, outp = llms.get_model_pricing("gpt-4")
+        self.assertEqual(inp, 30.0)
+        self.assertEqual(outp, 60.0)
+
+    @patch(
+        "youtube_to_docs.llms.PRICES",
+        {"prices": [{"id": "gpt-4", "input": 30.0, "output": 60.0}]},
+    )
+    def test_get_model_pricing_normalized(self):
+        inp, outp = llms.get_model_pricing("vertex-gpt-4")
+        self.assertEqual(inp, 30.0)
+        self.assertEqual(outp, 60.0)
+
+    @patch(
+        "youtube_to_docs.llms.PRICES",
+        {
+            "prices": [{"id": "claude-4.5-haiku", "input": 1.0, "output": 5.0}],
+            "aliases": {"claude-haiku-4-5": "claude-4.5-haiku"},
+        },
+    )
+    def test_get_model_pricing_aliased(self):
+        """Test that aliases (like claude-haiku-4-5 -> claude-4.5-haiku) work."""
+        # This model name normalizes to 'claude-haiku-4-5'
+        # which should alias to 'claude-4.5-haiku'
+        inp, outp = llms.get_model_pricing("bedrock-claude-haiku-4-5-20251001-v1")
+        self.assertEqual(inp, 1.0)
+        self.assertEqual(outp, 5.0)
+
+    @patch(
+        "youtube_to_docs.llms.PRICES",
+        {
+            "prices": [
+                {"id": "claude-4.5-haiku", "input": 1.0, "output": 5.0},
+                {"id": "gemini-3-flash-preview", "input": 0.5, "output": 3.0},
+                {"id": "gpt-5-mini", "input": 0.25, "output": 2.0},
+                {
+                    "id": "amazon-nova-2-lite",
+                    "input": 0.3,
+                    "output": 2.5,
+                },
+                {
+                    "id": "imagen-4",
+                    "input": 0.0,
+                    "output": 40.0,
+                },
+            ],
+            "aliases": {
+                "claude-haiku-4-5": "claude-4.5-haiku",
+                "nova-2-lite": "amazon-nova-2-lite",
+            },
+        },
+    )
+    def test_get_model_pricing_specific_models(self):
+        """Test getting pricing for specific models requested by user."""
+        models = [
+            "gemini-3-flash-preview",
+            "vertex-claude-haiku-4-5@20251001",
+            "bedrock-claude-haiku-4-5-20251001-v1",
+            "bedrock-nova-2-lite-v1",
+            "foundry-gpt-5-mini",
+            "imagen-4",
+        ]
+
+        for model in models:
+            with self.subTest(model=model):
+                inp, outp = llms.get_model_pricing(model)
+                self.assertIsNotNone(inp, f"Input price for {model} should not be None")
+                self.assertIsNotNone(
+                    outp, f"Output price for {model} should not be None"
+                )
+
+    @patch("youtube_to_docs.llms.PRICES", {"prices": [{"id": "gpt-4"}]})
+    def test_get_model_pricing_not_found(self):
+        inp, outp = llms.get_model_pricing("non-existent-model")
+        self.assertIsNone(inp)
+        self.assertIsNone(outp)
+
+
+if __name__ == "__main__":
+    unittest.main()