janus-llm 4.2.0__py3-none-any.whl → 4.3.1__py3-none-any.whl

janus/__init__.py

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

janus/cli.py

@@ -19,6 +19,7 @@ from janus.converter.aggregator import Aggregator
 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 InlineCommentEvaluator, RequirementEvaluator
 from janus.converter.partition import Partitioner
 from janus.converter.requirements import RequirementsDocumenter
 from janus.converter.translate import Translator
@@ -127,7 +128,7 @@ embedding = typer.Typer(
 
 def version_callback(value: bool) -> None:
     if value:
-        from janus import __version__ as version
+        from . import __version__ as version
 
         print(f"Janus CLI [blue]v{version}[/blue]")
         raise typer.Exit()
@@ -655,6 +656,16 @@ def partition(
             click_type=click.Choice(list(CUSTOM_SPLITTERS.keys())),
         ),
     ] = "file",
+    refiner_types: Annotated[
+        list[str],
+        typer.Option(
+            "-r",
+            "--refiner",
+            help="List of refiner types to use. Add -r for each refiner to use in\
+                refinement chain",
+            click_type=click.Choice(list(REFINERS.keys())),
+        ),
+    ] = ["JanusRefiner"],
     max_tokens: Annotated[
         int,
         typer.Option(
@@ -673,6 +684,7 @@ def partition(
         ),
     ] = 8192,
 ):
+    refiner_types = [REFINERS[r] for r in refiner_types]
     model_arguments = dict(temperature=temperature)
     kwargs = dict(
         model=llm_name,
@@ -681,6 +693,7 @@ def partition(
         max_prompts=max_prompts,
         max_tokens=max_tokens,
         splitter_type=splitter_type,
+        refiner_types=refiner_types,
         partition_token_limit=partition_token_limit,
     )
     partitioner = Partitioner(**kwargs)
@@ -815,6 +828,139 @@ def diagram(
     diagram_generator.translate(input_dir, output_dir, overwrite, collection)
 
 
+@app.command(
+    help="LLM self evaluation",
+    no_args_is_help=True,
+)
+def llm_self_eval(
+    input_dir: Annotated[
+        Path,
+        typer.Option(
+            "--input",
+            "-i",
+            help="The directory containing the source code to be evaluated. "
+            "The files should all be in one flat directory.",
+        ),
+    ],
+    language: Annotated[
+        str,
+        typer.Option(
+            "--language",
+            "-l",
+            help="The language of the source code.",
+            click_type=click.Choice(sorted(LANGUAGES)),
+        ),
+    ],
+    output_dir: Annotated[
+        Path,
+        typer.Option(
+            "--output-dir", "-o", help="The directory to store the evaluations in."
+        ),
+    ],
+    llm_name: Annotated[
+        str,
+        typer.Option(
+            "--llm",
+            "-L",
+            help="The custom name of the model set with 'janus llm add'.",
+        ),
+    ] = "gpt-4o",
+    evaluation_type: Annotated[
+        str,
+        typer.Option(
+            "--evaluation-type",
+            "-e",
+            help="Type of output to evaluate.",
+            click_type=click.Choice(["incose", "comments"]),
+        ),
+    ] = "incose",
+    max_prompts: Annotated[
+        int,
+        typer.Option(
+            "--max-prompts",
+            "-m",
+            help="The maximum number of times to prompt a model on one functional block "
+            "before exiting the application. This is to prevent wasting too much money.",
+        ),
+    ] = 10,
+    overwrite: Annotated[
+        bool,
+        typer.Option(
+            "--overwrite/--preserve",
+            help="Whether to overwrite existing files in the output directory",
+        ),
+    ] = False,
+    temperature: Annotated[
+        float,
+        typer.Option("--temperature", "-t", help="Sampling temperature.", min=0, max=2),
+    ] = 0.7,
+    collection: Annotated[
+        str,
+        typer.Option(
+            "--collection",
+            "-c",
+            help="If set, will put the translated result into a Chroma DB "
+            "collection with the name provided.",
+        ),
+    ] = None,
+    splitter_type: Annotated[
+        str,
+        typer.Option(
+            "-S",
+            "--splitter",
+            help="Name of custom splitter to use",
+            click_type=click.Choice(list(CUSTOM_SPLITTERS.keys())),
+        ),
+    ] = "file",
+    refiner_types: Annotated[
+        list[str],
+        typer.Option(
+            "-r",
+            "--refiner",
+            help="List of refiner types to use. Add -r for each refiner to use in\
+                refinement chain",
+            click_type=click.Choice(list(REFINERS.keys())),
+        ),
+    ] = ["JanusRefiner"],
+    eval_items_per_request: Annotated[
+        int,
+        typer.Option(
+            "--eval-items-per-request",
+            "-rc",
+            help="The maximum number of evaluation items per request",
+        ),
+    ] = None,
+    max_tokens: Annotated[
+        int,
+        typer.Option(
+            "--max-tokens",
+            "-M",
+            help="The maximum number of tokens the model will take in. "
+            "If unspecificed, model's default max will be used.",
+        ),
+    ] = None,
+):
+    model_arguments = dict(temperature=temperature)
+    refiner_types = [REFINERS[r] for r in refiner_types]
+    kwargs = dict(
+        eval_items_per_request=eval_items_per_request,
+        model=llm_name,
+        model_arguments=model_arguments,
+        source_language=language,
+        max_prompts=max_prompts,
+        max_tokens=max_tokens,
+        splitter_type=splitter_type,
+        refiner_types=refiner_types,
+    )
+    # Setting parser type here
+    if evaluation_type == "incose":
+        evaluator = RequirementEvaluator(**kwargs)
+    elif evaluation_type == "comments":
+        evaluator = InlineCommentEvaluator(**kwargs)
+
+    evaluator.translate(input_dir, output_dir, overwrite, collection)
+
+
 @db.command("init", help="Connect to or create a database.")
 def db_init(
     path: Annotated[
@@ -1116,13 +1262,12 @@ def llm_add(
             show_choices=False,
         )
         params = dict(
-            # OpenAI uses the "model_name" key for what we're calling "long_model_id"
-            model_name=MODEL_ID_TO_LONG_ID[model_id],
+            model_name=model_name,
             temperature=0.7,
             n=1,
         )
-        max_tokens = TOKEN_LIMITS[MODEL_ID_TO_LONG_ID[model_id]]
-        model_cost = COST_PER_1K_TOKENS[MODEL_ID_TO_LONG_ID[model_id]]
+        max_tokens = TOKEN_LIMITS[model_name]
+        model_cost = COST_PER_1K_TOKENS[model_name]
         cfg = {
             "model_type": model_type,
             "model_id": model_id,

janus/converter/converter.py

@@ -464,6 +464,7 @@ class Converter:
         for in_path, out_path in in_out_pairs:
             # Translate the file, skip it if there's a rate limit error
             try:
+                log.info(f"Processing {in_path.relative_to(input_directory)}")
                 out_block = self.translate_file(in_path)
                 total_cost += out_block.total_cost
             except RateLimitError:

janus/converter/evaluate.py

@@ -1,15 +1,241 @@
+import json
+import re
+from copy import deepcopy
+
+from langchain_core.runnables import Runnable, RunnableLambda, RunnableParallel
+
 from janus.converter.converter import Converter
+from janus.language.block import TranslatedCodeBlock
 from janus.language.combine import JsonCombiner
-from janus.parsers.eval_parser import EvaluationParser
+from janus.parsers.eval_parsers.incose_parser import IncoseParser
+from janus.parsers.eval_parsers.inline_comment_parser import InlineCommentParser
 from janus.utils.logger import create_logger
 
 log = create_logger(__name__)
 
 
 class Evaluator(Converter):
-    def __init__(self, **kwargs):
+    """Evaluator
+
+    A class that performs an LLM self evaluation"
+    "on an input target, with an associated prompt.
+
+    Current valid evaluation types:
+    ['incose', 'comments']
+
+    """
+
+    def __init__(self, **kwargs) -> None:
+        """Initialize the Evaluator class
+
+        Arguments:
+            model: The LLM to use for translation. If an OpenAI model, the
+                `OPENAI_API_KEY` environment variable must be set and the
+                `OPENAI_ORG_ID` environment variable should be set if needed.
+            model_arguments: Additional arguments to pass to the LLM constructor.
+            max_prompts: The maximum number of prompts to try before giving up.
+        """
+        super().__init__(**kwargs)
+        self._combiner = JsonCombiner()
+        self._load_parameters()
+
+
+class RequirementEvaluator(Evaluator):
+    """INCOSE Requirement Evaluator
+
+    A class that performs an LLM self evaluation on an input target,
+    with an associated prompt.
+
+    The evaluation prompts are for Incose Evaluations
+
+    """
+
+    def __init__(self, eval_items_per_request: int | None = None, **kwargs) -> None:
+        """Initialize the Evaluator class
+
+        Arguments:
+            model: The LLM to use for translation. If an OpenAI model, the
+                `OPENAI_API_KEY` environment variable must be set and the
+                `OPENAI_ORG_ID` environment variable should be set if needed.
+            model_arguments: Additional arguments to pass to the LLM constructor.
+            max_prompts: The maximum number of prompts to try before giving up.
+        """
+        super().__init__(**kwargs)
+        self.eval_items_per_request = eval_items_per_request
+        self._parser = IncoseParser()
+        self.set_prompt("eval_prompts/incose")
+
+    def _input_runnable(self) -> Runnable:
+        def _get_code(json_text: str) -> str:
+            return json.loads(json_text)["code"]
+
+        def _get_reqs(json_text: str) -> str:
+            return json.dumps(json.loads(json_text)["requirements"])
+
+        return RunnableLambda(self._parser.parse_input) | RunnableParallel(
+            SOURCE_CODE=_get_code,
+            REQUIREMENTS=_get_reqs,
+            context=self._retriever,
+        )
+
+    def _add_translation(self, block: TranslatedCodeBlock):
+        if block.translated:
+            return
+
+        if block.original.text is None:
+            block.translated = True
+            return
+
+        if self.eval_items_per_request is None:
+            return super()._add_translation(block)
+
+        input_obj = json.loads(block.original.text)
+        requirements = input_obj.get("requirements", [])
+
+        if not requirements:
+            log.debug(f"[{block.name}] Skipping empty block")
+            block.translated = True
+            block.text = None
+            block.complete = True
+            return
+
+        # For some reason requirements objects are in nested lists?
+        while isinstance(requirements[0], list):
+            requirements = [r for lst in requirements for r in lst]
+
+        if len(requirements) <= self.eval_items_per_request:
+            input_obj["requirements"] = requirements
+            block.original.text = json.dumps(input_obj)
+            return super()._add_translation(block)
+
+        block.processing_time = 0
+        block.cost = 0
+        block.retries = 0
+        obj = {}
+        for i in range(0, len(requirements), self.eval_items_per_request):
+            # Build a new TranslatedBlock using the new working text
+            working_requirements = requirements[i : i + self.eval_items_per_request]
+            working_copy = deepcopy(block.original)
+            working_obj = json.loads(working_copy.text)  # type: ignore
+            working_obj["requirements"] = working_requirements
+            working_copy.text = json.dumps(working_obj)
+            working_block = TranslatedCodeBlock(working_copy, self._target_language)
+
+            # Run the LLM on the working text
+            super()._add_translation(working_block)
+
+            # Update metadata to include for all runs
+            block.retries += working_block.retries
+            block.cost += working_block.cost
+            block.processing_time += working_block.processing_time
+
+            # Update the output text to merge this section's output in
+            obj.update(json.loads(working_block.text))
+
+        block.text = json.dumps(obj)
+        block.tokens = self._llm.get_num_tokens(block.text)
+        block.translated = True
+
+        log.debug(
+            f"[{block.name}] Output code:\n{json.dumps(json.loads(block.text), indent=2)}"
+        )
+
+
+class InlineCommentEvaluator(Evaluator):
+    """Inline Comment Evaluator
+
+    A class that performs an LLM self evaluation on inline comments,
+    with an associated prompt.
+    """
+
+    def __init__(self, eval_items_per_request: int | None = None, **kwargs) -> None:
+        """Initialize the Evaluator class
+
+        Arguments:
+            model: The LLM to use for translation. If an OpenAI model, the
+                `OPENAI_API_KEY` environment variable must be set and the
+                `OPENAI_ORG_ID` environment variable should be set if needed.
+            model_arguments: Additional arguments to pass to the LLM constructor.
+            max_prompts: The maximum number of prompts to try before giving up.
+        """
         super().__init__(**kwargs)
-        self.set_prompt("evaluate")
         self._combiner = JsonCombiner()
-        self._parser = EvaluationParser()
         self._load_parameters()
+        self._parser = InlineCommentParser()
+        self.set_prompt("eval_prompts/inline_comments")
+        self.eval_items_per_request = eval_items_per_request
+
+    def _add_translation(self, block: TranslatedCodeBlock):
+        if block.translated:
+            return
+
+        if block.original.text is None:
+            block.translated = True
+            return
+
+        if self.eval_items_per_request is None:
+            return super()._add_translation(block)
+
+        comment_pattern = r"<(?:INLINE|BLOCK)_COMMENT \w{8}>.*$"
+        comments = list(
+            re.finditer(comment_pattern, block.original.text, flags=re.MULTILINE)
+        )
+
+        if not comments:
+            log.info(f"[{block.name}] Skipping commentless block")
+            block.translated = True
+            block.text = None
+            block.complete = True
+            return
+
+        if len(comments) <= self.eval_items_per_request:
+            return super()._add_translation(block)
+
+        comment_group_indices = list(range(0, len(comments), self.eval_items_per_request))
+        log.debug(
+            f"[{block.name}] Block contains more than {self.eval_items_per_request}"
+            f" comments, splitting {len(comments)} comments into"
+            f" {len(comment_group_indices)} groups"
+        )
+
+        block.processing_time = 0
+        block.cost = 0
+        block.retries = 0
+        obj = {}
+        for i in range(0, len(comments), self.eval_items_per_request):
+            # Split the text into the section containing comments of interest,
+            #  all the text prior to those comments, and all the text after them
+            working_comments = comments[i : i + self.eval_items_per_request]
+            start_idx = working_comments[0].start()
+            end_idx = working_comments[-1].end()
+            prefix = block.original.text[:start_idx]
+            keeper = block.original.text[start_idx:end_idx]
+            suffix = block.original.text[end_idx:]
+
+            # Strip all comment placeholders outside of the section of interest
+            prefix = re.sub(comment_pattern, "", prefix, flags=re.MULTILINE)
+            suffix = re.sub(comment_pattern, "", suffix, flags=re.MULTILINE)
+
+            # Build a new TranslatedBlock using the new working text
+            working_copy = deepcopy(block.original)
+            working_copy.text = prefix + keeper + suffix
+            working_block = TranslatedCodeBlock(working_copy, self._target_language)
+
+            # Run the LLM on the working text
+            super()._add_translation(working_block)
+
+            # Update metadata to include for all runs
+            block.retries += working_block.retries
+            block.cost += working_block.cost
+            block.processing_time += working_block.processing_time
+
+            # Update the output text to merge this section's output in
+            obj.update(json.loads(working_block.text))
+
+        block.text = json.dumps(obj)
+        block.tokens = self._llm.get_num_tokens(block.text)
+        block.translated = True
+
+        log.debug(
+            f"[{block.name}] Output code:\n{json.dumps(json.loads(block.text), indent=2)}"
+        )

janus/language/alc/_tests/test_alc.py

@@ -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.assertAlmostEqual(tree_root.n_descendents, 32, delta=5)
+        self.assertAlmostEqual(tree_root.n_descendents, 16, delta=2)
         self.assertLessEqual(tree_root.max_tokens, self.splitter.max_tokens)
         self.assertFalse(tree_root.complete)
         self.combiner.combine_children(tree_root)

janus/language/alc/alc.py

@@ -79,10 +79,15 @@ class AlcSplitter(TreeSitterSplitter):
             if len(sects) > 1:
                 block.children = []
                 for sect in sects:
-                    if sect[0].node_type in sect_types:
-                        sect_node = self.merge_nodes(sect)
-                        sect_node.children = sect
-                        sect_node.node_type = NodeType(str(sect[0].node_type)[:5])
+                    node_type = sect[0].node_type
+                    if node_type in sect_types:
+                        if len(sect) == 1:
+                            # Don't make a node its own child
+                            sect_node = sect[0]
+                        else:
+                            sect_node = self.merge_nodes(sect)
+                            sect_node.children = sect
+                        sect_node.node_type = NodeType(str(node_type)[:5])
                         block.children.append(sect_node)
                     else:
                         block.children.extend(sect)

janus/language/splitter.py

@@ -275,42 +275,50 @@ class Splitter(FileManager):
 
         groups = [[n] for n in nodes]
         while len(groups) > 1 and min(adj_sums) <= self.max_tokens and any(merge_allowed):
-            # Get the indices of the adjacent nodes that would result in the
-            #  smallest possible merged snippet. Ignore protected nodes.
+            # Get the index of the node that would result in the smallest
+            #  merged snippet when merged with the node that follows it.
+            #  Ignore protected nodes.
             mergeable_indices = compress(range(len(adj_sums)), merge_allowed)
-            i0 = int(min(mergeable_indices, key=adj_sums.__getitem__))
-            i1 = i0 + 1
+            C = int(min(mergeable_indices, key=adj_sums.__getitem__))
+
+            # C: Central index
+            # L: Index to the left
+            # R: Index to the right (to be merged in to C)
+            # N: Next index (to the right of R, the "new R")
+            L, R, N = C - 1, C + 1, C + 2
 
             # Recalculate the length. We can't simply use the adj_sum, because
             #  it is an underestimate due to the adjoining suffix/prefix.
-            central_node = groups[i0][-1]
-            merged_text = "".join([text_chunks[i0], central_node.suffix, text_chunks[i1]])
+            central_node = groups[C][-1]
+            merged_text = "".join([text_chunks[C], central_node.suffix, text_chunks[R]])
             merged_text_length = self._count_tokens(merged_text)
 
             # If the true length of the merged pair is too long, don't merge them
             #  Instead, correct the estimate, since shorter pairs may yet exist
             if merged_text_length > self.max_tokens:
-                adj_sums[i0] = merged_text_length
+                adj_sums[C] = merged_text_length
                 continue
 
             # Update adjacent sum estimates
-            if i0 > 0:
-                adj_sums[i0 - 1] += merged_text_length
-            if i1 < len(adj_sums) - 1:
-                adj_sums[i1 + 1] += merged_text_length
-
-            if i0 > 0 and i1 < len(merge_allowed) - 1:
-                if not (merge_allowed[i0 - 1] and merge_allowed[i1 + 1]):
-                    merge_allowed[i0 - 1] = merge_allowed[i1 + 1] = False
+            if L >= 0:
+                adj_sums[L] = lengths[L] + merged_text_length
+            if N < len(adj_sums):
+                adj_sums[R] = lengths[N] + merged_text_length
 
             # The potential merge length for this pair is removed
-            adj_sums.pop(i0)
-            merge_allowed.pop(i0)
+            adj_sums.pop(C)
+
+            # The merged-in node is removed from the protected list
+            #  The merge_allowed list need not be updated - if the node now to
+            #  its right is protected, the merge_allowed element corresponding
+            #  to the merged neighbor will have been True, and now corresponds
+            #  to the merged node.
+            merge_allowed.pop(C)
 
             # Merge the pair of node groups
-            groups[i0 : i1 + 1] = [groups[i0] + groups[i1]]
-            text_chunks[i0 : i1 + 1] = [merged_text]
-            lengths[i0 : i1 + 1] = [merged_text_length]
+            groups[C:N] = [groups[C] + groups[R]]
+            text_chunks[C:N] = [merged_text]
+            lengths[C:N] = [merged_text_length]
 
         return groups
 
@@ -403,13 +411,13 @@ class Splitter(FileManager):
         self._split_into_lines(node)
 
     def _split_into_lines(self, node: CodeBlock):
-        split_text = re.split(r"(\n+)", node.text)
+        split_text = list(re.split(r"(\n+)", node.text))
 
         # If the string didn't start/end with newlines, make sure to include
         #  empty strings for the prefix/suffixes
-        if split_text[0].strip("\n"):
+        if not re.match(r"^\n+$", split_text[0]):
             split_text = [""] + split_text
-        if split_text[-1].strip("\n"):
+        if not re.match(r"^\n+$", split_text[-1]):
             split_text.append("")
         betweens = split_text[::2]
         lines = split_text[1::2]

janus/language/treesitter/treesitter.py

@@ -154,7 +154,15 @@ class TreeSitterSplitter(Splitter):
             The pointer to the language.
         """
         lib = cdll.LoadLibrary(os.fspath(so_file))
-        language_function = getattr(lib, f"tree_sitter_{self.language}")
+        # Added this try-except block to handle the case where the language is not
+        # supported in lowercase by the creator of the grammar. Ex: COBOL
+        # https://github.com/yutaro-sakamoto/tree-sitter-cobol/blob/main/grammar.js#L13
+        try:
+            language_function = getattr(lib, f"tree_sitter_{self.language}")
+        except AttributeError:
+            language = self.language.upper()
+            language_function = getattr(lib, f"tree_sitter_{language}")
+
         language_function.restype = c_void_p
         pointer = language_function()
         return pointer

janus/llm/models_info.py

@@ -6,9 +6,13 @@ from typing import Callable, Protocol, TypeVar
 from dotenv import load_dotenv
 from langchain_community.llms import HuggingFaceTextGenInference
 from langchain_core.runnables import Runnable
-from langchain_openai import AzureChatOpenAI
+from langchain_openai import AzureChatOpenAI, ChatOpenAI
 
-from janus.llm.model_callbacks import COST_PER_1K_TOKENS, azure_model_reroutes
+from janus.llm.model_callbacks import (
+    COST_PER_1K_TOKENS,
+    azure_model_reroutes,
+    openai_model_reroutes,
+)
 from janus.prompts.prompt import (
     ChatGptPromptEngine,
     ClaudePromptEngine,
@@ -127,7 +131,7 @@ bedrock_models = [
 all_models = [*azure_models, *bedrock_models]
 
 MODEL_TYPE_CONSTRUCTORS: dict[str, ModelType] = {
-    # "OpenAI": ChatOpenAI,
+    "OpenAI": ChatOpenAI,
     "HuggingFace": HuggingFaceTextGenInference,
     "Azure": AzureChatOpenAI,
     "Bedrock": Bedrock,
@@ -137,7 +141,7 @@ MODEL_TYPE_CONSTRUCTORS: dict[str, ModelType] = {
 
 
 MODEL_PROMPT_ENGINES: dict[str, Callable[..., PromptEngine]] = {
-    # **{m: ChatGptPromptEngine for m in openai_models},
+    **{m: ChatGptPromptEngine for m in openai_models},
     **{m: ChatGptPromptEngine for m in azure_models},
     **{m: ClaudePromptEngine for m in claude_models},
     **{m: Llama2PromptEngine for m in llama2_models},
@@ -148,7 +152,7 @@ MODEL_PROMPT_ENGINES: dict[str, Callable[..., PromptEngine]] = {
 }
 
 MODEL_ID_TO_LONG_ID = {
-    # **{m: mr for m, mr in openai_model_reroutes.items()},
+    **{m: mr for m, mr in openai_model_reroutes.items()},
     **{m: mr for m, mr in azure_model_reroutes.items()},
     "bedrock-claude-v2": "anthropic.claude-v2",
     "bedrock-claude-instant-v1": "anthropic.claude-instant-v1",
@@ -181,7 +185,7 @@ DEFAULT_MODELS = list(MODEL_DEFAULT_ARGUMENTS.keys())
 MODEL_CONFIG_DIR = Path.home().expanduser() / ".janus" / "llm"
 
 MODEL_TYPES: dict[str, PromptEngine] = {
-    # **{m: "OpenAI" for m in openai_models},
+    **{m: "OpenAI" for m in openai_models},
     **{m: "Azure" for m in azure_models},
     **{m: "BedrockChat" for m in bedrock_models},
 }
@@ -289,15 +293,16 @@ def load_model(model_id) -> JanusModel:
         # log.warning("Waiting 10 seconds...")
         # Give enough time for the user to read the warnings and cancel
         # time.sleep(10)
-        raise DeprecationWarning("OpenAI models are no longer supported.")
+        # raise DeprecationWarning("OpenAI models are no longer supported.")
 
     elif model_type_name == "Azure":
         model_args.update(
-            {
-                "api_key": os.getenv("AZURE_OPENAI_API_KEY"),
-                "azure_endpoint": os.getenv("AZURE_OPENAI_ENDPOINT"),
-                "api_version": os.getenv("OPENAI_API_VERSION", "2024-02-01"),
-            }
+            api_key=os.getenv("AZURE_OPENAI_API_KEY"),
+            azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
+            api_version=os.getenv("OPENAI_API_VERSION", "2024-02-01"),
+            azure_deployment=model_id,
+            request_timeout=3600,
+            max_tokens=4096,
         )
 
     model_type = MODEL_TYPE_CONSTRUCTORS[model_type_name]

janus/parsers/eval_parsers/incose_parser.py

@@ -0,0 +1,134 @@
+import json
+import random
+import uuid
+from typing import List
+
+from langchain.output_parsers import PydanticOutputParser
+from langchain_core.exceptions import OutputParserException
+from langchain_core.messages import BaseMessage
+from langchain_core.pydantic_v1 import BaseModel, Field, validator
+
+from janus.language.block import CodeBlock
+from janus.parsers.parser import JanusParser
+from janus.utils.logger import create_logger
+
+log = create_logger(__name__)
+RNG = random.Random()
+
+
+class Criteria(BaseModel):
+    reasoning: str = Field(description="A short explanation for the given assessment")
+    score: str = Field("A simple `pass` or `fail`")
+
+    @validator("score")
+    def score_is_valid(cls, v: str):
+        v = v.lower().strip()
+        if v not in {"pass", "fail"}:
+            raise OutputParserException("Score must be either 'pass' or 'fail'")
+        return v
+
+
+class Requirement(BaseModel):
+    requirement_id: str = Field(description="The 8-character comment ID")
+    requirement: str = Field(description="The original requirement being evaluated")
+    C1: Criteria
+    C2: Criteria
+    C3: Criteria
+    C4: Criteria
+    C5: Criteria
+    C6: Criteria
+    C7: Criteria
+    C8: Criteria
+    C9: Criteria
+
+
+class RequirementList(BaseModel):
+    __root__: List[Requirement] = Field(
+        description=(
+            "A list of requirement evaluations. Each element should include"
+            " the requirement's 8-character ID in the `requirement_id` field,"
+            " the original requirement in the 'requirement' field, "
+            " and nine score objects corresponding to each criterion."
+        )
+    )
+
+
+class IncoseParser(JanusParser, PydanticOutputParser):
+    requirements: dict[str, str]
+
+    def __init__(self):
+        PydanticOutputParser.__init__(
+            self,
+            pydantic_object=RequirementList,
+            requirements={},
+        )
+
+    def parse_input(self, block: CodeBlock) -> str:
+        # TODO: Perform comment stripping/placeholding here rather than in script
+        text = super().parse_input(block)
+        RNG.seed(text)
+
+        obj = json.loads(text)
+
+        # For some reason requirements objects are in a double list?
+        reqs = obj["requirements"]
+
+        # Generate a unique ID for each requirement (ensure they are unique)
+        req_ids = set()
+        while len(req_ids) < len(reqs):
+            req_ids.add(str(uuid.UUID(int=RNG.getrandbits(128), version=4))[:8])
+
+        self.requirements = dict(zip(req_ids, reqs))
+        reqs_str = "\n\n".join(
+            f"Requirement {rid} : {req}" for rid, req in self.requirements.items()
+        )
+        obj["requirements"] = reqs_str
+        return json.dumps(obj)
+
+    def parse(self, text: str | BaseMessage) -> str:
+        if isinstance(text, BaseMessage):
+            text = str(text.content)
+
+        # Strip everything outside the JSON object
+        begin, end = text.find("["), text.rfind("]")
+        text = text[begin : end + 1]
+
+        try:
+            out: RequirementList = super().parse(text)
+        except json.JSONDecodeError as e:
+            log.debug(f"Invalid JSON object. Output:\n{text}")
+            raise OutputParserException(f"Got invalid JSON object. Error: {e}")
+
+        evals: dict[str, dict] = {c.requirement_id: c.dict() for c in out.__root__}
+
+        seen_keys = set(evals.keys())
+        expected_keys = set(self.requirements.keys())
+        missing_keys = expected_keys.difference(seen_keys)
+        invalid_keys = seen_keys.difference(expected_keys)
+        if missing_keys:
+            log.debug(f"Missing keys: {missing_keys}")
+            if invalid_keys:
+                log.debug(f"Invalid keys: {invalid_keys}")
+            log.debug(f"Missing keys: {missing_keys}")
+            raise OutputParserException(
+                f"Got invalid return object. Missing the following expected "
+                f"keys: {missing_keys}"
+            )
+
+        for key in invalid_keys:
+            del evals[key]
+
+        for rid in evals.keys():
+            evals[rid]["requirement"] = self.requirements[rid]
+            evals[rid].pop("requirement_id")
+
+        return json.dumps(evals)
+
+    def parse_combined_output(self, text: str) -> str:
+        if not text.strip():
+            return str({})
+        objs = [json.loads(line.strip()) for line in text.split("\n") if line.strip()]
+        output_obj = {}
+        for obj in objs:
+            output_obj.update(obj)
+        return json.dumps(output_obj)

janus/parsers/eval_parsers/inline_comment_parser.py

@@ -0,0 +1,112 @@
+import json
+import re
+from typing import Any
+
+from langchain.output_parsers import PydanticOutputParser
+from langchain_core.exceptions import OutputParserException
+from langchain_core.messages import BaseMessage
+from langchain_core.pydantic_v1 import BaseModel, Field, conint
+
+from janus.language.block import CodeBlock
+from janus.parsers.parser import JanusParser
+from janus.utils.logger import create_logger
+
+log = create_logger(__name__)
+
+
+class Criteria(BaseModel):
+    reasoning: str = Field(description="A short explanation for the given score")
+    # Constrained to an integer between 1 and 4
+    score: conint(ge=1, le=4) = Field(  # type: ignore
+        description="An integer score between 1 and 4 (inclusive), 4 being the best"
+    )
+
+
+class Comment(BaseModel):
+    comment_id: str = Field(description="The 8-character comment ID")
+    completeness: Criteria = Field(description="The completeness of the comment")
+    hallucination: Criteria = Field(description="The factualness of the comment")
+    readability: Criteria = Field(description="The readability of the comment")
+    usefulness: Criteria = Field(description="The usefulness of the comment")
+
+
+class CommentList(BaseModel):
+    __root__: list[Comment] = Field(
+        description=(
+            "A list of inline comment evaluations. Each element should include"
+            " the comment's 8-character ID in the `comment_id` field, and four"
+            " score objects corresponding to each metric (`completeness`,"
+            " `hallucination`, `readability`, and `usefulness`)."
+        )
+    )
+
+
+class InlineCommentParser(JanusParser, PydanticOutputParser):
+    comments: dict[str, str]
+
+    def __init__(self):
+        PydanticOutputParser.__init__(
+            self,
+            pydantic_object=CommentList,
+            comments=[],
+        )
+
+    def parse_input(self, block: CodeBlock) -> str:
+        # TODO: Perform comment stripping/placeholding here rather than in script
+        text = super().parse_input(block)
+        self.comments = dict(
+            re.findall(
+                r"<(?:BLOCK|INLINE)_COMMENT (\w{8})> (.*)$",
+                text,
+                flags=re.MULTILINE,
+            )
+        )
+        return text
+
+    def parse(self, text: str | BaseMessage) -> str:
+        if isinstance(text, BaseMessage):
+            text = str(text.content)
+
+        # Strip everything outside the JSON object
+        begin, end = text.find("["), text.rfind("]")
+        text = text[begin : end + 1]
+
+        try:
+            out: CommentList = super().parse(text)
+        except json.JSONDecodeError as e:
+            log.debug(f"Invalid JSON object. Output:\n{text}")
+            raise OutputParserException(f"Got invalid JSON object. Error: {e}")
+
+        evals: dict[str, Any] = {c.comment_id: c.dict() for c in out.__root__}
+
+        seen_keys = set(evals.keys())
+        expected_keys = set(self.comments.keys())
+        missing_keys = expected_keys.difference(seen_keys)
+        invalid_keys = seen_keys.difference(expected_keys)
+        if missing_keys:
+            log.debug(f"Missing keys: {missing_keys}")
+            if invalid_keys:
+                log.debug(f"Invalid keys: {invalid_keys}")
+            log.debug(f"Missing keys: {missing_keys}")
+            raise OutputParserException(
+                f"Got invalid return object. Missing the following expected "
+                f"keys: {missing_keys}"
+            )
+
+        for key in invalid_keys:
+            del evals[key]
+
+        for cid in evals.keys():
+            evals[cid]["comment"] = self.comments[cid]
+            evals[cid].pop("comment_id")
+
+        return json.dumps(evals)
+
+    def parse_combined_output(self, text: str) -> str:
+        if not text.strip():
+            return str({})
+        objs = [json.loads(line.strip()) for line in text.split("\n") if line.strip()]
+        output_obj = {}
+        for obj in objs:
+            output_obj.update(obj)
+        return json.dumps(output_obj)

janus/parsers/partition_parser.py

@@ -36,6 +36,29 @@ class PartitionList(BaseModel):
     )
 
 
+# The following IDs appear in the prompt example. If the LLM produces them,
+#  they should be ignored
+EXAMPLE_IDS = {
+    "0d2f4f8d",
+    "def2a953",
+    "75315253",
+    "e7f928da",
+    "1781b2a9",
+    "2fe21e27",
+    "9aef6179",
+    "6061bd82",
+    "22bd0c30",
+    "5d85e19e",
+    "06027969",
+    "91b722fb",
+    "4b3f79be",
+    "k57w964a",
+    "51638s96",
+    "065o6q32",
+    "j5q6p852",
+}
+
+
 class PartitionParser(JanusParser, PydanticOutputParser):
     token_limit: int
     model: BaseLanguageModel
@@ -59,7 +82,10 @@ class PartitionParser(JanusParser, PydanticOutputParser):
         # Generate a unique ID for each line (ensure they are unique)
         line_ids = set()
         while len(line_ids) < len(self.lines):
-            line_ids.add(str(uuid.UUID(int=RNG.getrandbits(128), version=4))[:8])
+            line_id = str(uuid.UUID(int=RNG.getrandbits(128), version=4))[:8]
+            if line_id in EXAMPLE_IDS:
+                continue
+            line_ids.add(line_id)
 
         # Prepend each line with the corresponding ID, save the mapping
         self.line_id_to_index = {lid: i for i, lid in enumerate(line_ids)}
@@ -72,18 +98,24 @@ class PartitionParser(JanusParser, PydanticOutputParser):
         if isinstance(text, BaseMessage):
             text = str(text.content)
 
+        # Strip everything outside the JSON object
+        begin, end = text.find("["), text.rfind("]")
+        text = text[begin : end + 1]
+
         try:
             out: PartitionList = super().parse(text)
         except (OutputParserException, json.JSONDecodeError):
             log.debug(f"Invalid JSON object. Output:\n{text}")
             raise
 
+        # Get partition locations, discard reasoning
+        partition_locations = {partition.location for partition in out.__root__}
+
+        # Ignore IDs from the example input
+        partition_locations.difference_update(EXAMPLE_IDS)
+
         # Locate any invalid line IDs, raise exception if any found
-        invalid_splits = [
-            partition.location
-            for partition in out.__root__
-            if partition.location not in self.line_id_to_index
-        ]
+        invalid_splits = partition_locations.difference(self.line_id_to_index)
         if invalid_splits:
             err_msg = (
                 f"{len(invalid_splits)} line ID(s) not found in input: "
@@ -95,9 +127,9 @@ class PartitionParser(JanusParser, PydanticOutputParser):
         # Map line IDs to indices (so they can be sorted and lines indexed)
         index_to_line_id = {0: "START", None: "END"}
         split_points = {0}
-        for partition in out.__root__:
-            index = self.line_id_to_index[partition.location]
-            index_to_line_id[index] = partition.location
+        for partition in partition_locations:
+            index = self.line_id_to_index[partition]
+            index_to_line_id[index] = partition
             split_points.add(index)
 
         # Get partition start/ends, chunks, chunk lengths

janus/refiners/refiner.py

@@ -2,6 +2,7 @@ import re
 from typing import Any
 
 from langchain.output_parsers import RetryWithErrorOutputParser
+from langchain_core.exceptions import OutputParserException
 from langchain_core.output_parsers import StrOutputParser
 from langchain_core.prompt_values import PromptValue
 from langchain_core.runnables import RunnableSerializable
@@ -26,6 +27,35 @@ class JanusRefiner(JanusParser):
         raise NotImplementedError
 
 
+class SimpleRetry(JanusRefiner):
+    max_retries: int
+    retry_chain: RunnableSerializable
+
+    def __init__(
+        self,
+        llm: JanusModel,
+        parser: JanusParser,
+        max_retries: int,
+    ):
+        retry_chain = llm | StrOutputParser()
+        super().__init__(
+            retry_chain=retry_chain,
+            parser=parser,
+            max_retries=max_retries,
+        )
+
+    def parse_completion(
+        self, completion: str, prompt_value: PromptValue, **kwargs
+    ) -> Any:
+        for retry_number in range(self.max_retries):
+            try:
+                return self.parser.parse(completion)
+            except OutputParserException:
+                completion = self.retry_chain.invoke(prompt_value)
+
+        return self.parser.parse(completion)
+
+
 class FixParserExceptions(JanusRefiner, RetryWithErrorOutputParser):
     def __init__(self, llm: JanusModel, parser: JanusParser, max_retries: int):
         retry_prompt = MODEL_PROMPT_ENGINES[llm.short_model_id](

janus/utils/enums.py

@@ -89,6 +89,20 @@ LANGUAGES: Dict[str, Dict[str, Any]] = {
         "url": "https://github.com/stsewd/tree-sitter-comment",
         "example": "# This is a comment\n",
     },
+    "cobol": {
+        "comment": "*",
+        "suffix": "cbl",
+        "url": "https://github.com/yutaro-sakamoto/tree-sitter-cobol",
+        "example": (
+            "       IDENTIFICATION DIVISION.\n"
+            "       PROGRAM-ID. HelloWorld.\n"
+            "       ENVIRONMENT DIVISION.\n"
+            "       DATA DIVISION.\n"
+            "       PROCEDURE DIVISION.\n"
+            '           DISPLAY "Hello, World!".\n'
+            "           STOP RUN.\n"
+        ),
+    },
     "commonlisp": {
         "comment": ";;",
         "suffix": "lisp",

{janus_llm-4.2.0.dist-info → janus_llm-4.3.1.dist-info}/METADATA

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

{janus_llm-4.2.0.dist-info → janus_llm-4.3.1.dist-info}/RECORD

@@ -1,17 +1,17 @@
-janus/__init__.py,sha256=8ZZh7ctoYQaClu_ak9pFc5eYVEcaSju33Ru0vZBp_iM,361
+janus/__init__.py,sha256=hbiNcSyVowLc5sEqV1GU1B22molrn1w3rOxtKlgrl2E,361
 janus/__main__.py,sha256=lEkpNtLVPtFo8ySDZeXJ_NXDHb0GVdZFPWB4gD4RPS8,64
 janus/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 janus/_tests/conftest.py,sha256=V7uW-oq3YbFiRPvrq15YoVVrA1n_83pjgiyTZ-IUGW8,963
 janus/_tests/test_cli.py,sha256=6ef7h11bg4i7Q6L1-r0ZdcY7YrH4n472kvDiA03T4c8,4275
-janus/cli.py,sha256=eGmzu8aei1QNN_WaWeMYltgIHdKr1MPwG2Er0AEBIuo,42563
+janus/cli.py,sha256=zo8EEp0Y33jPCzMUGGRXxjr629ZPMIrVGk3FxinpyDQ,46851
 janus/converter/__init__.py,sha256=Jnp3TsJ4M1LWDAzXFSyxzMpygbYOxkR-qYxU-G6Gi1k,395
 janus/converter/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 janus/converter/_tests/test_translate.py,sha256=T5CzNrwHqJWfb39Izq84R9WvM3toSlJq31SeA_U7d_4,5641
 janus/converter/aggregator.py,sha256=MuAXMKmq6PuUo_w6ljyiuDn81Gk2dN-Ci7FVeLc6vhs,1966
-janus/converter/converter.py,sha256=1WFGy8LozO8pVjbPcYJa9-TTZqgNxwUs7oDca86TcvE,26174
+janus/converter/converter.py,sha256=citSpcCsI1bDfckK38smGNafDHsc8DC9quSoXD2J-Kc,26253
 janus/converter/diagram.py,sha256=-wktVBPrSBgNIQfHIfa2bJNg6L9CYJQgrr9-xU8DFPw,1646
 janus/converter/document.py,sha256=qNt2UncMheUBadXCFHGq74tqCrvZub5DCgZpd3Qa54o,4564
-janus/converter/evaluate.py,sha256=APWQUY3gjAXqkJkPzvj0UA4wPK3Cv9QSJLM-YK9t-ng,476
+janus/converter/evaluate.py,sha256=Bdue1ESQfMVFFRK4l0CvqwLyzt5bqOKy1LB9a8Hqub0,9150
 janus/converter/partition.py,sha256=ASvv4hAue44qHobO4kqr_tKr-eJsXCPPdD3NtNd9V-E,993
 janus/converter/requirements.py,sha256=9tvQ40FZJtG8niIFn45gPQCgKKHVPPoFLinBv6RAqO4,2027
 janus/converter/translate.py,sha256=S1DPZdmX9Vrn_sJPcobvXmhmS8U53yl5cRXjsmXPtas,4246
@@ -30,8 +30,8 @@ janus/language/_tests/test_combine.py,sha256=sjVVPUg4LYkAmazXGUw_S1xPrzWm67_0tCx
 janus/language/_tests/test_splitter.py,sha256=Hqexa39LLEXlK3ZUw7Zot4PUIACvye2vkq0Jaox0T10,373
 janus/language/alc/__init__.py,sha256=j7vOMGhT1Vri6p8dsjSaY-fkO5uFn0sJ0nrNGGvcizM,42
 janus/language/alc/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-janus/language/alc/_tests/test_alc.py,sha256=jrvZCsz3uvbq6pqTKmymWNDgb20HHs69tj9TRbx69aM,1018
-janus/language/alc/alc.py,sha256=fKZDtbeLXiJ2e8t-eWSjeAW6WCMCTn2Fw7_jxvMPdNc,6863
+janus/language/alc/_tests/test_alc.py,sha256=8LKidOPJDlMonRBX9w8AVOKHhyR-O2srW4ntzw5rEEs,1018
+janus/language/alc/alc.py,sha256=YteDO6DR5hnQULjI3j8Je-w05MH50ZARtXB66FqkZi4,7088
 janus/language/binary/__init__.py,sha256=AlNAe12ZA366kcGSrQ1FJyOdbwxFqGBFkYR2K6yL818,51
 janus/language/binary/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 janus/language/binary/_tests/test_binary.py,sha256=cIKIxjj6kIY3rcxLwqUPESP9bxWrHqMHx9TNuICgfeQ,1724
@@ -52,14 +52,14 @@ janus/language/naive/registry.py,sha256=8YQX1q0IdAm7t69-oC_00I-vfkdRnHuX-OD3KEjE
 janus/language/naive/simple_ast.py,sha256=YzeUJomVsnttJc8tI9eDROb2Hx9Vm9XKmOnLEp3TkzI,3112
 janus/language/naive/tag_splitter.py,sha256=IXWMn9tBVUGAtzvQi89GhoZ6g7fPXk5MzO0kMCr2mb0,2045
 janus/language/node.py,sha256=baoYFtapwBQqBtUN6EvHFYRkbR-EcEw1b3fQvH9zIAM,204
-janus/language/splitter.py,sha256=pYvDhGAYDDP7E4CZeNn76I6zVnHMNj6gTFUegKXyRPk,17005
+janus/language/splitter.py,sha256=ZpNIzv0ijbcH7EMnY8DIxAf0ji7-ym1iYJXS9ei_F78,17389
 janus/language/treesitter/__init__.py,sha256=mUliw7ZJLZ8NkJKyUQMSoUV82hYXE0HvLHrEdGPJF4Q,43
 janus/language/treesitter/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 janus/language/treesitter/_tests/test_treesitter.py,sha256=fmr_mFSja7vaCVu0TVyLDua3A94jMjY4AqSC5NqnOdQ,2179
-janus/language/treesitter/treesitter.py,sha256=q7fqfFxt7QsqM6tE39uqutRMsOfEgBd3omv7zVZSEOc,7517
+janus/language/treesitter/treesitter.py,sha256=FdsBO8CEo6l9D77aHXns5jRSoZzkvrRGZFCW3oNw15c,7928
 janus/llm/__init__.py,sha256=TKLYvnsWKWfxMucy-lCLQ-4bkN9ENotJZDywDEQmrKg,45
 janus/llm/model_callbacks.py,sha256=cHRZBpYgAwiYbA2k0GQ7DBwBFQZJpEGMUBV3Q_5GTpU,7940
-janus/llm/models_info.py,sha256=6ImXTgCeNkMPtW-9swdaWXISixb-UUqq6OCUl8kPxCs,10612
+janus/llm/models_info.py,sha256=tHH5Hf7zWBpD5zSuhxx_Tp1fQMPTKPr9EuevacDiUTU,10711
 janus/metrics/__init__.py,sha256=AsxtZJUzZiXJPr2ehPPltuYP-ddechjg6X85WZUO7mA,241
 janus/metrics/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 janus/metrics/_tests/reference.py,sha256=hiaJPP9CXkvFBV_wL-gOe_BzELTw0nvB6uCxhxtIiE8,13
@@ -89,25 +89,27 @@ janus/parsers/_tests/test_code_parser.py,sha256=3ay5QpUPcynX_EJ-YLl3PR28poutUkT7
 janus/parsers/code_parser.py,sha256=3l0HfzgrvJuiwk779s9ZsgUl3xbp1nE1qZxh8aDYRBI,873
 janus/parsers/doc_parser.py,sha256=0pUsNZ9hKQLjIi8L8BgkOBHQZ_EGoFLHrBQ4hoDkjSw,5862
 janus/parsers/eval_parser.py,sha256=Gjh6aTZgpYd2ASJUEPMo4LpCL00cBmbOqc4KM3hy8x8,2922
+janus/parsers/eval_parsers/incose_parser.py,sha256=udyK-24ocfrB1SzmggcERm73dBynrCj4MFSBV8k7YDM,4478
+janus/parsers/eval_parsers/inline_comment_parser.py,sha256=QzKgzeWPhyIEkLxJBpeutSocSJjjXEcWRRS635bXEO8,3973
 janus/parsers/parser.py,sha256=y6VV64bgVidf-oEFla3I--_28tnJsPBc6QUD_SkbfSE,1614
-janus/parsers/partition_parser.py,sha256=z9EoqttHacegZzhkoGa-j4vxuzaleDuq32FonzaXsW8,4974
+janus/parsers/partition_parser.py,sha256=IW5_aNYL4g-PzB_qJ0g0NlwLiaAGGewR5iUYF19PVL4,5738
 janus/parsers/reqs_parser.py,sha256=uRQC41Iqp22GjIvakb5UKv70UWHkcOTbOVl_RDnipYw,2438
 janus/parsers/uml.py,sha256=SwaoG9QrHKQP8rSxlf3qu_rp7OMQqYSmLgDYBapOa9M,3379
 janus/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 janus/prompts/prompt.py,sha256=3796YXIzzIec9b0iUzd8VZlq-AdQbzq8qUGXLy4KH-0,10586
-janus/refiners/refiner.py,sha256=f2YDLnG2TF3Kws40chVOBQ91DD6zf2B1wcoP6WeQcIk,3829
+janus/refiners/refiner.py,sha256=ZHP0hUIv8eLpHJSd2SP1Sex6q6SdJgH7HIPgXPBw_gI,4672
 janus/refiners/uml.py,sha256=ZFvFLxOdbolYuOmZh_8K6kiHCWKuudqP71sr_TammxM,866
 janus/retrievers/retriever.py,sha256=n6MzoNZs0GJCH4eqQPS3gFlVHZ3eETr7FuHYbyPzTuo,3506
 janus/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 janus/utils/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 janus/utils/_tests/test_logger.py,sha256=jkkvrCTKwsFCsZtmyuvc-WJ0rC7LJi2Z91sIe4IiKzA,2209
 janus/utils/_tests/test_progress.py,sha256=Rs_u5PiGjP-L-o6C1fhwfE1ig8jYu9Xo9s4p8yPysl8,491
-janus/utils/enums.py,sha256=AoilbdiYyMvY2Mp0AM4xlbLSELfut2XMwhIM1S_msP4,27610
+janus/utils/enums.py,sha256=gmvX3MYnHAwu4ZypidENIZ27M5NI_YegY3PpCDJS34Q,28094
 janus/utils/logger.py,sha256=KZeuaMAnlSZCsj4yL0P6N-JzZwpxXygzACWfdZFeuek,2337
 janus/utils/pdf_docs_reader.py,sha256=beMKHdYrFwg0m_i7n0OTJrut3sf4rEWFd7P_80A76WY,5140
 janus/utils/progress.py,sha256=PIpcQec7SrhsfqB25LHj2CDDkfm9umZx90d9LZnAx6k,1469
-janus_llm-4.2.0.dist-info/LICENSE,sha256=_j0st0a-HB6MRbP3_BW3PUqpS16v54luyy-1zVyl8NU,10789
-janus_llm-4.2.0.dist-info/METADATA,sha256=5iwBiBTpucpwF3UxClv2P25y9QOpaWsaEGFFyF7mmTU,4574
-janus_llm-4.2.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-janus_llm-4.2.0.dist-info/entry_points.txt,sha256=OGhQwzj6pvXp79B0SaBD5apGekCu7Dwe9fZZT_TZ544,39
-janus_llm-4.2.0.dist-info/RECORD,,
+janus_llm-4.3.1.dist-info/LICENSE,sha256=_j0st0a-HB6MRbP3_BW3PUqpS16v54luyy-1zVyl8NU,10789
+janus_llm-4.3.1.dist-info/METADATA,sha256=ZeUGDDKbJjHSk2Wkzf-4zXLIwaYZqua-5_HVFbzV2yg,4574
+janus_llm-4.3.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+janus_llm-4.3.1.dist-info/entry_points.txt,sha256=OGhQwzj6pvXp79B0SaBD5apGekCu7Dwe9fZZT_TZ544,39
+janus_llm-4.3.1.dist-info/RECORD,,