janus-llm 3.1.1__tar.gz → 3.2.1__tar.gz

{janus_llm-3.1.1 → janus_llm-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: janus-llm
-Version: 3.1.1
+Version: 3.2.1
 Summary: A transcoding library using LLMs.
 Home-page: https://github.com/janus-llm/janus-llm
 License: Apache 2.0

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/__init__.py

@@ -2,10 +2,10 @@ import warnings
 
 from langchain_core._api.deprecation import LangChainDeprecationWarning
 
-from .converter.translate import Translator
-from .metrics import *  # noqa: F403
+from janus.converter.translate import Translator
+from janus.metrics import *  # noqa: F403
 
-__version__ = "3.1.1"
+__version__ = "3.2.1"
 
 # Ignoring a deprecation warning from langchain_core that I can't seem to hunt down
 warnings.filterwarnings("ignore", category=LangChainDeprecationWarning)

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/_tests/test_cli.py

@@ -4,9 +4,9 @@ from unittest.mock import ANY, patch
 
 from typer.testing import CliRunner
 
-from ..cli import app, translate
-from ..embedding.embedding_models_info import EMBEDDING_MODEL_CONFIG_DIR
-from ..llm.models_info import MODEL_CONFIG_DIR
+from janus.cli import app, translate
+from janus.embedding.embedding_models_info import EMBEDDING_MODEL_CONFIG_DIR
+from janus.llm.models_info import MODEL_CONFIG_DIR
 
 
 class TestCli(unittest.TestCase):

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/cli.py

@@ -32,8 +32,12 @@ from janus.language.treesitter import TreeSitterSplitter
 from janus.llm.model_callbacks import COST_PER_1K_TOKENS
 from janus.llm.models_info import (
     MODEL_CONFIG_DIR,
+    MODEL_ID_TO_LONG_ID,
     MODEL_TYPE_CONSTRUCTORS,
+    MODEL_TYPES,
     TOKEN_LIMITS,
+    bedrock_models,
+    openai_models,
 )
 from janus.metrics.cli import evaluate
 from janus.utils.enums import LANGUAGES
@@ -104,7 +108,7 @@ embedding = typer.Typer(
 
 def version_callback(value: bool) -> None:
     if value:
-        from . import __version__ as version
+        from janus import __version__ as version
 
         print(f"Janus CLI [blue]v{version}[/blue]")
         raise typer.Exit()
@@ -179,7 +183,7 @@ def translate(
             "-L",
             help="The custom name of the model set with 'janus llm add'.",
         ),
-    ] = "gpt-3.5-turbo-0125",
+    ] = "gpt-4o",
     max_prompts: Annotated[
         int,
         typer.Option(
@@ -301,7 +305,7 @@ def document(
             "-L",
             help="The custom name of the model set with 'janus llm add'.",
         ),
-    ] = "gpt-3.5-turbo-0125",
+    ] = "gpt-4o",
     max_prompts: Annotated[
         int,
         typer.Option(
@@ -437,7 +441,7 @@ def diagram(
             "-L",
             help="The custom name of the model set with 'janus llm add'.",
         ),
-    ] = "gpt-3.5-turbo-0125",
+    ] = "gpt-4o",
     max_prompts: Annotated[
         int,
         typer.Option(
@@ -800,16 +804,44 @@ def llm_add(
             "model_cost": {"input": in_cost, "output": out_cost},
         }
     elif model_type == "OpenAI":
-        model_name = typer.prompt("Enter the model name", default="gpt-3.5-turbo-0125")
+        model_id = typer.prompt(
+            "Enter the model ID (list model IDs with `janus llm ls -a`)",
+            default="gpt-4o",
+            type=click.Choice(openai_models),
+            show_choices=False,
+        )
         params = dict(
-            model_name=model_name,
+            # OpenAI uses the "model_name" key for what we're calling "long_model_id"
+            model_name=MODEL_ID_TO_LONG_ID[model_id],
             temperature=0.7,
             n=1,
         )
-        max_tokens = TOKEN_LIMITS[model_name]
-        model_cost = COST_PER_1K_TOKENS[model_name]
+        max_tokens = TOKEN_LIMITS[MODEL_ID_TO_LONG_ID[model_id]]
+        model_cost = COST_PER_1K_TOKENS[MODEL_ID_TO_LONG_ID[model_id]]
+        cfg = {
+            "model_type": model_type,
+            "model_id": model_id,
+            "model_args": params,
+            "token_limit": max_tokens,
+            "model_cost": model_cost,
+        }
+    elif model_type == "BedrockChat" or model_type == "Bedrock":
+        model_id = typer.prompt(
+            "Enter the model ID (list model IDs with `janus llm ls -a`)",
+            default="bedrock-claude-sonnet",
+            type=click.Choice(bedrock_models),
+            show_choices=False,
+        )
+        params = dict(
+            # Bedrock uses the "model_id" key for what we're calling "long_model_id"
+            model_id=MODEL_ID_TO_LONG_ID[model_id],
+            model_kwargs={"temperature": 0.7},
+        )
+        max_tokens = TOKEN_LIMITS[MODEL_ID_TO_LONG_ID[model_id]]
+        model_cost = COST_PER_1K_TOKENS[MODEL_ID_TO_LONG_ID[model_id]]
         cfg = {
             "model_type": model_type,
+            "model_id": model_id,
             "model_args": params,
             "token_limit": max_tokens,
             "model_cost": model_cost,
@@ -821,6 +853,31 @@ def llm_add(
     print(f"Model config written to {model_cfg}")
 
 
+@llm.command("ls", help="List all of the user-configured models")
+def llm_ls(
+    all: Annotated[
+        bool,
+        typer.Option(
+            "--all",
+            "-a",
+            is_flag=True,
+            help="List all models, including the default model IDs.",
+            click_type=click.Choice(sorted(list(MODEL_TYPE_CONSTRUCTORS.keys()))),
+        ),
+    ] = False,
+):
+    print("\n[green]User-configured models[/green]:")
+    for model_cfg in MODEL_CONFIG_DIR.glob("*.json"):
+        with open(model_cfg, "r") as f:
+            cfg = json.load(f)
+        print(f"\t[blue]{model_cfg.stem}[/blue]: [purple]{cfg['model_type']}[/purple]")
+
+    if all:
+        print("\n[green]Available model IDs[/green]:")
+        for model_id, model_type in MODEL_TYPES.items():
+            print(f"\t[blue]{model_id}[/blue]: [purple]{model_type}[/purple]")
+
+
 @embedding.command("add", help="Add an embedding model config to janus")
 def embedding_add(
     model_name: Annotated[

janus_llm-3.2.1/janus/converter/__init__.py

@@ -0,0 +1,6 @@
+from janus.converter.converter import Converter
+from janus.converter.diagram import DiagramGenerator
+from janus.converter.document import Documenter, MadLibsDocumenter, MultiDocumenter
+from janus.converter.evaluate import Evaluator
+from janus.converter.requirements import RequirementsDocumenter
+from janus.converter.translate import Translator

janus_llm-3.2.1/janus/converter/_tests/test_translate.py

@@ -0,0 +1,155 @@
+import unittest
+from pathlib import Path
+from typing import Any, Iterable, List, Optional, Type
+
+import pytest
+from langchain.schema import Document
+from langchain.schema.embeddings import Embeddings
+from langchain.schema.vectorstore import VST, VectorStore
+
+from janus.converter.diagram import DiagramGenerator
+from janus.converter.requirements import RequirementsDocumenter
+from janus.converter.translate import Translator
+from janus.language.block import CodeBlock, TranslatedCodeBlock
+
+
+class MockCollection(VectorStore):
+    """Vector store for testing"""
+
+    def __init__(self):
+        self._add_texts_calls = 0
+
+    def add_texts(
+        self, texts: Iterable[str], metadatas: Optional[List[dict]] = None, **kwargs: Any
+    ) -> List[str]:
+        self._add_texts_calls += 1
+        return ["id"]
+
+    def similarity_search(self, query: str, k: int = 4, **kwargs: Any) -> List[Document]:
+        raise NotImplementedError("similarity_search() not implemented!")
+
+    @classmethod
+    def from_texts(
+        cls: Type[VST],
+        texts: List[str],
+        embedding: Embeddings,
+        metadatas: Optional[List[dict]] = None,
+        **kwargs: Any,
+    ) -> VST:
+        raise NotImplementedError("from_texts() not implemented!")
+
+
+class TestTranslator(unittest.TestCase):
+    """Tests for the Translator class."""
+
+    def setUp(self):
+        """Set up the tests."""
+        self.translator = Translator(
+            model="gpt-4o",
+            source_language="fortran",
+            target_language="python",
+            target_version="3.10",
+        )
+        self.test_file = Path("janus/language/treesitter/_tests/languages/fortran.f90")
+        self.TEST_FILE_EMBEDDING_COUNT = 14
+
+        self.req_translator = RequirementsDocumenter(
+            model="gpt-4o",
+            source_language="fortran",
+            prompt_template="requirements",
+        )
+
+    @pytest.mark.translate
+    def test_translate(self):
+        """Test translate method."""
+        # Delete a file if it's already there
+        python_file = self.test_file.parent / "python" / f"{self.test_file.stem}.py"
+        python_file.unlink(missing_ok=True)
+        python_file.parent.rmdir() if python_file.parent.is_dir() else None
+        self.translator.translate(self.test_file.parent, self.test_file.parent / "python")
+        # Only check the top-most level functionality, since it should be handled by other
+        # unit tests anyway
+        self.assertTrue(python_file.exists())
+
+    def test_invalid_selections(self) -> None:
+        """Tests that settings values for the translator will raise exceptions"""
+        self.assertRaises(
+            ValueError, self.translator.set_target_language, "gobbledy", "goobledy"
+        )
+        self.assertRaises(
+            ValueError, self.translator.set_source_language, "scribbledy-doop"
+        )
+        self.translator.set_prompt("pish posh")
+        self.assertRaises(ValueError, self.translator._load_parameters)
+
+
+class TestDiagramGenerator(unittest.TestCase):
+    """Tests for the DiagramGenerator class."""
+
+    def setUp(self):
+        """Set up the tests."""
+        self.diagram_generator = DiagramGenerator(
+            model="gpt-4o",
+            source_language="fortran",
+            diagram_type="Activity",
+        )
+
+    def test_init(self):
+        """Test __init__ method."""
+        self.assertEqual(self.diagram_generator._model_name, "gpt-4o")
+        self.assertEqual(self.diagram_generator._source_language, "fortran")
+        self.assertEqual(self.diagram_generator._diagram_type, "Activity")
+
+    def test_add_translation(self):
+        """Test _add_translation method."""
+        block = TranslatedCodeBlock(
+            original=CodeBlock(
+                id="test",
+                name="Test Block",
+                node_type="function",
+                language="python",
+                text="print('Hello, World!')",
+                start_point=(0, 0),
+                end_point=(1, 0),
+                start_byte=0,
+                end_byte=1,
+                tokens=5,
+                children=[],
+            ),
+            language="python",
+        )
+        self.diagram_generator._add_translation(block)
+        self.assertTrue(block.translated)
+        self.assertIsNotNone(block.text)
+        self.assertIsNotNone(block.tokens)
+
+
+@pytest.mark.parametrize(
+    "source_language,prompt_template,expected_target_language,expected_target_version,",
+    [
+        ("python", "document_inline", "python", "3.10"),
+        ("fortran", "document", "text", None),
+        ("mumps", "requirements", "text", None),
+        ("python", "simple", "javascript", "es6"),
+    ],
+)
+def test_language_combinations(
+    source_language: str,
+    prompt_template: str,
+    expected_target_language: str,
+    expected_target_version: str,
+):
+    """Tests that translator target language settings are consistent
+    with prompt template expectations.
+    """
+    translator = Translator(model="gpt-4o")
+    translator.set_model("gpt-4o")
+    translator.set_source_language(source_language)
+    translator.set_target_language(expected_target_language, expected_target_version)
+    translator.set_prompt(prompt_template)
+    translator._load_parameters()
+    assert translator._target_language == expected_target_language  # nosec
+    assert translator._target_version == expected_target_version  # nosec
+    assert translator._splitter.language == source_language  # nosec
+    assert translator._splitter.model.model_name == "gpt-4o"  # nosec
+    assert translator._prompt_template_name == prompt_template  # nosec

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/converter/converter.py

@@ -64,7 +64,7 @@ class Converter:
 
     def __init__(
         self,
-        model: str = "gpt-3.5-turbo-0125",
+        model: str = "gpt-4o",
         model_arguments: dict[str, Any] = {},
         source_language: str = "fortran",
         max_prompts: int = 10,
@@ -92,6 +92,7 @@ class Converter:
         self.override_token_limit: bool = max_tokens is not None
 
         self._model_name: str
+        self._model_id: str
         self._custom_model_arguments: dict[str, Any]
 
         self._source_language: str
@@ -265,7 +266,9 @@ class Converter:
         # model_arguments.update(self._custom_model_arguments)
 
         # Load the model
-        self._llm, token_limit, self.model_cost = load_model(self._model_name)
+        self._llm, self._model_id, token_limit, self.model_cost = load_model(
+            self._model_name
+        )
         # Set the max_tokens to less than half the model's limit to allow for enough
         # tokens at output
         # Only modify max_tokens if it is not specified by user
@@ -283,7 +286,7 @@ class Converter:
         If the relevant fields have not been changed since the last time this
         method was called, nothing happens.
         """
-        prompt_engine = MODEL_PROMPT_ENGINES[self._model_name](
+        prompt_engine = MODEL_PROMPT_ENGINES[self._model_id](
             source_language=self._source_language,
             prompt_template=self._prompt_template_name,
         )

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/converter/translate.py

@@ -90,7 +90,7 @@ class Translator(Converter):
                     f"({self._source_language} != {self._target_language})"
                 )
 
-        prompt_engine = MODEL_PROMPT_ENGINES[self._model_name](
+        prompt_engine = MODEL_PROMPT_ENGINES[self._model_id](
             source_language=self._source_language,
             target_language=self._target_language,
             target_version=self._target_version,

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/embedding/_tests/test_collections.py

@@ -4,8 +4,8 @@ from unittest.mock import MagicMock
 
 import pytest
 
-from ...utils.enums import EmbeddingType
-from ..collections import Collections
+from janus.embedding.collections import Collections
+from janus.utils.enums import EmbeddingType
 
 
 class TestCollections(unittest.TestCase):

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/embedding/_tests/test_database.py

@@ -2,7 +2,7 @@ import unittest
 from pathlib import Path
 from unittest.mock import patch
 
-from ..database import ChromaEmbeddingDatabase, uri_to_path
+from janus.embedding.database import ChromaEmbeddingDatabase, uri_to_path
 
 
 class TestDatabase(unittest.TestCase):

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/embedding/_tests/test_vectorize.py

@@ -5,9 +5,9 @@ from unittest.mock import MagicMock
 
 from chromadb.api.client import Client
 
-from ...language.treesitter import TreeSitterSplitter
-from ...utils.enums import EmbeddingType
-from ..vectorize import Vectorizer, VectorizerFactory
+from janus.embedding.vectorize import Vectorizer, VectorizerFactory
+from janus.language.treesitter import TreeSitterSplitter
+from janus.utils.enums import EmbeddingType
 
 
 class MockDBVectorizer(VectorizerFactory):

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/embedding/collections.py

@@ -5,8 +5,8 @@ from typing import Dict, Optional, Sequence
 from chromadb import Client, Collection
 from langchain_community.vectorstores import Chroma
 
-from ..utils.enums import EmbeddingType
-from .embedding_models_info import load_embedding_model
+from janus.embedding.embedding_models_info import load_embedding_model
+from janus.utils.enums import EmbeddingType
 
 # See https://docs.trychroma.com/telemetry#in-chromas-backend-using-environment-variables
 os.environ["ANONYMIZED_TELEMETRY"] = "False"

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/embedding/database.py

@@ -5,7 +5,7 @@ from urllib.request import url2pathname
 
 import chromadb
 
-from ..utils.logger import create_logger
+from janus.utils.logger import create_logger
 
 log = create_logger(__name__)
 

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/embedding/embedding_models_info.py

@@ -8,7 +8,7 @@ from langchain_community.embeddings.huggingface import HuggingFaceInferenceAPIEm
 from langchain_core.embeddings import Embeddings
 from langchain_openai import OpenAIEmbeddings
 
-from ..utils.logger import create_logger
+from janus.utils.logger import create_logger
 
 load_dotenv()
 

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/embedding/vectorize.py

@@ -6,10 +6,10 @@ from typing import Any, Dict, Optional, Sequence
 from chromadb import Client, Collection
 from langchain_community.vectorstores import Chroma
 
-from ..language.block import CodeBlock, TranslatedCodeBlock
-from ..utils.enums import EmbeddingType
-from .collections import Collections
-from .database import ChromaEmbeddingDatabase
+from janus.embedding.collections import Collections
+from janus.embedding.database import ChromaEmbeddingDatabase
+from janus.language.block import CodeBlock, TranslatedCodeBlock
+from janus.utils.enums import EmbeddingType
 
 
 class Vectorizer(object):
@@ -59,7 +59,7 @@ class Vectorizer(object):
         self,
         code_block: CodeBlock,
         collection_name: EmbeddingType | str,
-        filename: str  # perhaps this should be a relative path from the source, but for
+        filename: str,  # perhaps this should be a relative path from the source, but for
         # now we're all in 1 directory
     ) -> None:
         """Calculate `code_block` embedding, returning success & storing in `embedding_id`

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/_tests/test_combine.py

@@ -1,6 +1,6 @@
 import unittest
 
-from ..combine import CodeBlock, Combiner, TranslatedCodeBlock
+from janus.language.combine import CodeBlock, Combiner, TranslatedCodeBlock
 
 
 class TestCombiner(unittest.TestCase):

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/_tests/test_splitter.py

@@ -1,6 +1,6 @@
 import unittest
 
-from ..splitter import Splitter
+from janus.language.splitter import Splitter
 
 
 class TestSplitter(unittest.TestCase):

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/alc/_tests/test_alc.py

@@ -1,9 +1,9 @@
 import unittest
 from pathlib import Path
 
-from ....llm import load_model
-from ...combine import Combiner
-from ..alc import AlcSplitter
+from janus.language.alc import AlcSplitter
+from janus.language.combine import Combiner
+from janus.llm import load_model
 
 
 class TestAlcSplitter(unittest.TestCase):
@@ -11,8 +11,8 @@ class TestAlcSplitter(unittest.TestCase):
 
     def setUp(self):
         """Set up the tests."""
-        model_name = "gpt-3.5-turbo-0125"
-        llm, _, _ = load_model(model_name)
+        model_name = "gpt-4o"
+        llm, _, _, _ = load_model(model_name)
         self.splitter = AlcSplitter(model=llm)
         self.combiner = Combiner(language="ibmhlasm")
         self.test_file = Path("janus/language/alc/_tests/alc.asm")
@@ -20,7 +20,7 @@ class TestAlcSplitter(unittest.TestCase):
     def test_split(self):
         """Test the split method."""
         tree_root = self.splitter.split(self.test_file)
-        self.assertEqual(tree_root.n_descendents, 34)
+        self.assertAlmostEqual(tree_root.n_descendents, 32, delta=5)
         self.assertLessEqual(tree_root.max_tokens, self.splitter.max_tokens)
         self.assertFalse(tree_root.complete)
         self.combiner.combine_children(tree_root)

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/alc/alc.py

@@ -1,10 +1,10 @@
 from langchain.schema.language_model import BaseLanguageModel
 
-from ...utils.logger import create_logger
-from ..block import CodeBlock
-from ..combine import Combiner
-from ..node import NodeType
-from ..treesitter import TreeSitterSplitter
+from janus.language.block import CodeBlock
+from janus.language.combine import Combiner
+from janus.language.node import NodeType
+from janus.language.treesitter import TreeSitterSplitter
+from janus.utils.logger import create_logger
 
 log = create_logger(__name__)
 

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/binary/_tests/test_binary.py

@@ -5,17 +5,17 @@ from unittest.mock import patch
 
 import pytest
 
-from ....llm import load_model
-from ..binary import BinarySplitter
+from janus.language.binary import BinarySplitter
+from janus.llm import load_model
 
 
 class TestBinarySplitter(unittest.TestCase):
     """Tests for the BinarySplitter class."""
 
     def setUp(self):
-        model_name = "gpt-3.5-turbo-0125"
+        model_name = "gpt-4o"
         self.binary_file = Path("janus/language/binary/_tests/hello")
-        self.llm, _, _ = load_model(model_name)
+        self.llm, _, _, _ = load_model(model_name)
         self.splitter = BinarySplitter(model=self.llm)
         os.environ["GHIDRA_INSTALL_PATH"] = "~/programs/ghidra_10.4_PUBLIC"
 

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/binary/binary.py

@@ -7,11 +7,11 @@ from pathlib import Path
 import tree_sitter
 from langchain.schema.language_model import BaseLanguageModel
 
-from ...utils.enums import LANGUAGES
-from ...utils.logger import create_logger
-from ..block import CodeBlock
-from ..combine import Combiner
-from ..treesitter import TreeSitterSplitter
+from janus.language.block import CodeBlock
+from janus.language.combine import Combiner
+from janus.language.treesitter import TreeSitterSplitter
+from janus.utils.enums import LANGUAGES
+from janus.utils.logger import create_logger
 
 log = create_logger(__name__)
 

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/block.py

@@ -1,8 +1,8 @@
 from functools import total_ordering
 from typing import ForwardRef, Hashable, Optional, Tuple
 
-from ..utils.logger import create_logger
-from .node import NodeType
+from janus.language.node import NodeType
+from janus.utils.logger import create_logger
 
 log = create_logger(__name__)
 

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/combine.py

@@ -1,6 +1,6 @@
-from ..utils.logger import create_logger
-from .block import CodeBlock, TranslatedCodeBlock
-from .file import FileManager
+from janus.language.block import CodeBlock, TranslatedCodeBlock
+from janus.language.file import FileManager
+from janus.utils.logger import create_logger
 
 log = create_logger(__name__)
 

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/file.py

@@ -1,5 +1,5 @@
-from ..utils.enums import LANGUAGES
-from ..utils.logger import create_logger
+from janus.utils.enums import LANGUAGES
+from janus.utils.logger import create_logger
 
 log = create_logger(__name__)
 

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/mumps/_tests/test_mumps.py

@@ -1,9 +1,9 @@
 import unittest
 from pathlib import Path
 
-from ....llm import load_model
-from ...combine import Combiner
-from ..mumps import MumpsSplitter
+from janus.language.combine import Combiner
+from janus.language.mumps import MumpsSplitter
+from janus.llm import load_model
 
 
 class TestMumpsSplitter(unittest.TestCase):
@@ -11,8 +11,8 @@ class TestMumpsSplitter(unittest.TestCase):
 
     def setUp(self):
         """Set up the tests."""
-        model_name = "gpt-3.5-turbo-0125"
-        llm, _, _ = load_model(model_name)
+        model_name = "gpt-4o"
+        llm, _, _, _ = load_model(model_name)
         self.splitter = MumpsSplitter(model=llm)
         self.combiner = Combiner(language="mumps")
         self.test_file = Path("janus/language/mumps/_tests/mumps.m")

{janus_llm-3.1.1 → janus_llm-3.2.1}/janus/language/mumps/mumps.py

@@ -2,11 +2,11 @@ import re
 
 from langchain.schema.language_model import BaseLanguageModel
 
-from ...utils.logger import create_logger
-from ..block import CodeBlock
-from ..combine import Combiner
-from ..node import NodeType
-from ..splitter import Splitter
+from janus.language.block import CodeBlock
+from janus.language.combine import Combiner
+from janus.language.node import NodeType
+from janus.language.splitter import Splitter
+from janus.utils.logger import create_logger
 
 log = create_logger(__name__)