janus-llm 4.1.0__py3-none-any.whl → 4.2.0__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.1.0"
+__version__ = "4.2.0"
 
 # Ignoring a deprecation warning from langchain_core that I can't seem to hunt down
 warnings.filterwarnings("ignore", category=LangChainDeprecationWarning)

janus/cli.py

@@ -13,10 +13,13 @@ from rich.console import Console
 from rich.prompt import Confirm
 from typing_extensions import Annotated
 
+import janus.refiners.refiner
+import janus.refiners.uml
 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.partition import Partitioner
 from janus.converter.requirements import RequirementsDocumenter
 from janus.converter.translate import Translator
 from janus.embedding.collections import Collections
@@ -44,7 +47,6 @@ from janus.llm.models_info import (
     openai_models,
 )
 from janus.metrics.cli import evaluate
-from janus.refiners.refiner import REFINERS
 from janus.utils.enums import LANGUAGES
 from janus.utils.logger import create_logger
 
@@ -69,6 +71,18 @@ with open(db_file, "r") as f:
 collections_config_file = Path(db_loc) / "collections.json"
 
 
+def get_subclasses(cls):
+    return set(cls.__subclasses__()).union(
+        set(s for c in cls.__subclasses__() for s in get_subclasses(c))
+    )
+
+
+REFINER_TYPES = get_subclasses(janus.refiners.refiner.JanusRefiner).union(
+    {janus.refiners.refiner.JanusRefiner}
+)
+REFINERS = {r.__name__: r for r in REFINER_TYPES}
+
+
 def get_collections_config():
     if collections_config_file.exists():
         with open(collections_config_file, "r") as f:
@@ -244,22 +258,23 @@ def translate(
             click_type=click.Choice(list(CUSTOM_SPLITTERS.keys())),
         ),
     ] = "file",
-    refiner_type: Annotated[
-        str,
+    refiner_types: Annotated[
+        list[str],
         typer.Option(
             "-r",
             "--refiner",
-            help="Name of custom refiner to use",
+            help="List of refiner types to use. Add -r for each refiner to use in\
+                refinement chain",
             click_type=click.Choice(list(REFINERS.keys())),
         ),
-    ] = "none",
+    ] = ["JanusRefiner"],
     retriever_type: Annotated[
         str,
         typer.Option(
             "-R",
             "--retriever",
             help="Name of custom retriever to use",
-            click_type=click.Choice(["active_usings"]),
+            click_type=click.Choice(["active_usings", "language_docs"]),
         ),
     ] = None,
     max_tokens: Annotated[
@@ -272,6 +287,7 @@ def translate(
         ),
     ] = None,
 ):
+    refiner_types = [REFINERS[r] for r in refiner_types]
     try:
         target_language, target_version = target_lang.split("-")
     except ValueError:
@@ -296,7 +312,7 @@ def translate(
         db_path=db_loc,
         db_config=collections_config,
         splitter_type=splitter_type,
-        refiner_type=refiner_type,
+        refiner_types=refiner_types,
         retriever_type=retriever_type,
     )
     translator.translate(input_dir, output_dir, overwrite, collection)
@@ -402,22 +418,23 @@ def document(
             click_type=click.Choice(list(CUSTOM_SPLITTERS.keys())),
         ),
     ] = "file",
-    refiner_type: Annotated[
-        str,
+    refiner_types: Annotated[
+        list[str],
         typer.Option(
             "-r",
             "--refiner",
-            help="Name of custom refiner to use",
+            help="List of refiner types to use. Add -r for each refiner to use in\
+                refinement chain",
             click_type=click.Choice(list(REFINERS.keys())),
         ),
-    ] = "none",
+    ] = ["JanusRefiner"],
     retriever_type: Annotated[
         str,
         typer.Option(
             "-R",
             "--retriever",
             help="Name of custom retriever to use",
-            click_type=click.Choice(["active_usings"]),
+            click_type=click.Choice(["active_usings", "language_docs"]),
         ),
     ] = None,
     max_tokens: Annotated[
@@ -430,6 +447,7 @@ def document(
         ),
     ] = None,
 ):
+    refiner_types = [REFINERS[r] for r in refiner_types]
     model_arguments = dict(temperature=temperature)
     collections_config = get_collections_config()
     kwargs = dict(
@@ -441,7 +459,7 @@ def document(
         db_path=db_loc,
         db_config=collections_config,
         splitter_type=splitter_type,
-        refiner_type=refiner_type,
+        refiner_types=refiner_types,
         retriever_type=retriever_type,
     )
     if doc_mode == "madlibs":
@@ -458,12 +476,6 @@ def document(
     documenter.translate(input_dir, output_dir, overwrite, collection)
 
 
-def get_subclasses(cls):
-    return set(cls.__subclasses__()).union(
-        set(s for c in cls.__subclasses__() for s in get_subclasses(c))
-    )
-
-
 @app.command()
 def aggregate(
     input_dir: Annotated[
@@ -578,6 +590,103 @@ def aggregate(
     aggregator.translate(input_dir, output_dir, overwrite, collection)
 
 
+@app.command(
+    help="Partition input code using an LLM.",
+    no_args_is_help=True,
+)
+def partition(
+    input_dir: Annotated[
+        Path,
+        typer.Option(
+            "--input",
+            "-i",
+            help="The directory containing the source code to be partitioned. ",
+        ),
+    ],
+    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 partitioned code in."
+        ),
+    ],
+    llm_name: Annotated[
+        str,
+        typer.Option(
+            "--llm",
+            "-L",
+            help="The custom name of the model set with 'janus llm add'.",
+        ),
+    ] = "gpt-4o",
+    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,
+    splitter_type: Annotated[
+        str,
+        typer.Option(
+            "-S",
+            "--splitter",
+            help="Name of custom splitter to use",
+            click_type=click.Choice(list(CUSTOM_SPLITTERS.keys())),
+        ),
+    ] = "file",
+    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,
+    partition_token_limit: Annotated[
+        int,
+        typer.Option(
+            "--partition-tokens",
+            "-pt",
+            help="The limit on the number of tokens per partition.",
+        ),
+    ] = 8192,
+):
+    model_arguments = dict(temperature=temperature)
+    kwargs = dict(
+        model=llm_name,
+        model_arguments=model_arguments,
+        source_language=language,
+        max_prompts=max_prompts,
+        max_tokens=max_tokens,
+        splitter_type=splitter_type,
+        partition_token_limit=partition_token_limit,
+    )
+    partitioner = Partitioner(**kwargs)
+    partitioner.translate(input_dir, output_dir, overwrite)
+
+
 @app.command(
     help="Diagram input code using an LLM.",
     no_args_is_help=True,
@@ -667,25 +776,27 @@ def diagram(
             click_type=click.Choice(list(CUSTOM_SPLITTERS.keys())),
         ),
     ] = "file",
-    refiner_type: Annotated[
-        str,
+    refiner_types: Annotated[
+        list[str],
         typer.Option(
             "-r",
             "--refiner",
-            help="Name of custom refiner to use",
+            help="List of refiner types to use. Add -r for each refiner to use in\
+                refinement chain",
             click_type=click.Choice(list(REFINERS.keys())),
         ),
-    ] = "none",
+    ] = ["JanusRefiner"],
     retriever_type: Annotated[
         str,
         typer.Option(
             "-R",
             "--retriever",
             help="Name of custom retriever to use",
-            click_type=click.Choice(["active_usings"]),
+            click_type=click.Choice(["active_usings", "language_docs"]),
         ),
     ] = None,
 ):
+    refiner_types = [REFINERS[r] for r in refiner_types]
     model_arguments = dict(temperature=temperature)
     collections_config = get_collections_config()
     diagram_generator = DiagramGenerator(
@@ -696,7 +807,7 @@ def diagram(
         db_path=db_loc,
         db_config=collections_config,
         splitter_type=splitter_type,
-        refiner_type=refiner_type,
+        refiner_types=refiner_types,
         retriever_type=retriever_type,
         diagram_type=diagram_type,
         add_documentation=add_documentation,

janus/converter/__init__.py

@@ -2,5 +2,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.partition import Partitioner
 from janus.converter.requirements import RequirementsDocumenter
 from janus.converter.translate import Translator

janus/converter/converter.py

@@ -6,7 +6,12 @@ from typing import Any
 
 from langchain_core.exceptions import OutputParserException
 from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables import Runnable, RunnableParallel, RunnablePassthrough
+from langchain_core.runnables import (
+    Runnable,
+    RunnableLambda,
+    RunnableParallel,
+    RunnablePassthrough,
+)
 from openai import BadRequestError, RateLimitError
 from pydantic import ValidationError
 
@@ -23,15 +28,14 @@ from janus.language.splitter import (
 from janus.llm.model_callbacks import get_model_callback
 from janus.llm.models_info import MODEL_PROMPT_ENGINES, JanusModel, load_model
 from janus.parsers.parser import GenericParser, JanusParser
-from janus.refiners.refiner import (
-    FixParserExceptions,
-    HallucinationRefiner,
-    JanusRefiner,
-    ReflectionRefiner,
-)
+from janus.refiners.refiner import JanusRefiner
 
 # from janus.refiners.refiner import BasicRefiner, Refiner
-from janus.retrievers.retriever import ActiveUsingsRetriever, JanusRetriever
+from janus.retrievers.retriever import (
+    ActiveUsingsRetriever,
+    JanusRetriever,
+    LanguageDocsRetriever,
+)
 from janus.utils.enums import LANGUAGES
 from janus.utils.logger import create_logger
 
@@ -78,7 +82,7 @@ class Converter:
         protected_node_types: tuple[str, ...] = (),
         prune_node_types: tuple[str, ...] = (),
         splitter_type: str = "file",
-        refiner_type: str | None = None,
+        refiner_types: list[type[JanusRefiner]] = [JanusRefiner],
         retriever_type: str | None = None,
     ) -> None:
         """Initialize a Converter instance.
@@ -105,6 +109,7 @@ class Converter:
                 - None
             retriever_type: The type of retriever to use. Valid values:
                 - "active_usings"
+                - "language_docs"
                 - None
         """
         self._changed_attrs: set = set()
@@ -133,10 +138,11 @@ class Converter:
         self._prompt: ChatPromptTemplate
 
         self._parser: JanusParser = GenericParser()
+        self._base_parser: JanusParser = GenericParser()
         self._combiner: Combiner = Combiner()
 
         self._splitter_type: str
-        self._refiner_type: str | None
+        self._refiner_types: list[type[JanusRefiner]]
         self._retriever_type: str | None
 
         self._splitter: Splitter
@@ -144,7 +150,7 @@ class Converter:
         self._retriever: JanusRetriever
 
         self.set_splitter(splitter_type=splitter_type)
-        self.set_refiner(refiner_type=refiner_type)
+        self.set_refiner_types(refiner_types=refiner_types)
         self.set_retriever(retriever_type=retriever_type)
         self.set_model(model_name=model, **model_arguments)
         self.set_prompt(prompt_template=prompt_template)
@@ -170,7 +176,7 @@ class Converter:
         self._load_model()
         self._load_prompt()
         self._load_retriever()
-        self._load_refiner()
+        self._load_refiner_chain()
         self._load_splitter()
         self._load_vectorizer()
         self._load_chain()
@@ -210,13 +216,13 @@ class Converter:
 
         self._splitter_type = splitter_type
 
-    def set_refiner(self, refiner_type: str | None) -> None:
+    def set_refiner_types(self, refiner_types: list[type[JanusRefiner]]) -> None:
         """Validate and set the refiner type
 
         Arguments:
             refiner_type: the type of refiner to use
         """
-        self._refiner_type = refiner_type
+        self._refiner_types = refiner_types
 
     def set_retriever(self, retriever_type: str | None) -> None:
         """Validate and set the retriever type
@@ -355,48 +361,40 @@ class Converter:
     def _load_retriever(self):
         if self._retriever_type == "active_usings":
             self._retriever = ActiveUsingsRetriever()
+        elif self._retriever_type == "language_docs":
+            self._retriever = LanguageDocsRetriever(self._llm, self._source_language)
         else:
             self._retriever = JanusRetriever()
 
-    @run_if_changed("_refiner_type", "_model_name", "max_prompts", "_parser", "_llm")
-    def _load_refiner(self) -> None:
-        """Load the refiner according to this instance's attributes.
-
-        If the relevant fields have not been changed since the last time this method was
-        called, nothing happens.
-        """
-        if self._refiner_type == "parser":
-            self._refiner = FixParserExceptions(
-                llm=self._llm,
-                parser=self._parser,
-                max_retries=self.max_prompts,
-            )
-        elif self._refiner_type == "reflection":
-            self._refiner = ReflectionRefiner(
-                llm=self._llm,
-                parser=self._parser,
-                max_retries=self.max_prompts,
+    @run_if_changed("_refiner_types", "_model_name", "max_prompts", "_parser")
+    def _load_refiner_chain(self) -> None:
+        self._refiner_chain = RunnableParallel(
+            completion=self._llm,
+            prompt_value=RunnablePassthrough(),
+        )
+        for refiner_type in self._refiner_types[:-1]:
+            # NOTE: Do NOT remove refiner_type=refiner_type from lambda.
+            # Due to lambda capture, must be present or chain will not
+            # be correctly constructed.
+            self._refiner_chain = self._refiner_chain | RunnableParallel(
+                completion=lambda x, refiner_type=refiner_type: refiner_type(
+                    llm=self._llm,
+                    parser=self._base_parser,
+                    max_retries=self.max_prompts,
+                ).parse_completion(**x),
+                prompt_value=lambda x: x["prompt_value"],
             )
-        elif self._refiner_type == "hallucination":
-            self._refiner = HallucinationRefiner(
+        self._refiner_chain = self._refiner_chain | RunnableLambda(
+            lambda x: self._refiner_types[-1](
                 llm=self._llm,
                 parser=self._parser,
                 max_retries=self.max_prompts,
-            )
-        else:
-            self._refiner = JanusRefiner(parser=self._parser)
+            ).parse_completion(**x)
+        )
 
-    @run_if_changed("_parser", "_retriever", "_prompt", "_llm", "_refiner")
+    @run_if_changed("_parser", "_retriever", "_prompt", "_llm", "_refiner_chain")
     def _load_chain(self):
-        self.chain = (
-            self._input_runnable()
-            | self._prompt
-            | RunnableParallel(
-                completion=self._llm,
-                prompt_value=RunnablePassthrough(),
-            )
-            | self._refiner.parse_runnable
-        )
+        self.chain = self._input_runnable() | self._prompt | self._refiner_chain
 
     def _input_runnable(self) -> Runnable:
         return RunnableParallel(

janus/converter/partition.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+
+from janus.converter.converter import Converter
+from janus.language.block import TranslatedCodeBlock
+from janus.parsers.partition_parser import PartitionParser
+from janus.utils.logger import create_logger
+
+log = create_logger(__name__)
+
+
+class Partitioner(Converter):
+    def __init__(self, partition_token_limit: int, **kwargs):
+        super().__init__(**kwargs)
+        self.set_prompt("partition")
+        self._load_model()
+        self._parser = PartitionParser(
+            token_limit=partition_token_limit,
+            model=self._llm,
+        )
+        self._target_language = self._source_language
+        self._target_suffix = self._source_suffix
+        self._load_parameters()
+
+    def _save_to_file(self, block: TranslatedCodeBlock, out_path: Path) -> None:
+        output_str = self._parser.parse_combined_output(block.complete_text)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(output_str, encoding="utf-8")

janus/language/combine.py

@@ -1,3 +1,5 @@
+import re
+
 from janus.language.block import CodeBlock, TranslatedCodeBlock
 from janus.language.file import FileManager
 from janus.utils.logger import create_logger
@@ -90,3 +92,23 @@ class ChunkCombiner(Combiner):
             root: The functional code block to combine with its children.
         """
         return root
+
+
+class PartitionCombiner(Combiner):
+    @staticmethod
+    def combine(root: CodeBlock) -> None:
+        """A combiner which inserts partition tags between code blocks"""
+        queue = [root]
+        while queue:
+            block = queue.pop(0)
+            if block.children:
+                queue.extend(block.children)
+            else:
+                block.affixes = (block.prefix, block.suffix + "\n<JANUS_PARTITION>\n")
+
+        super(PartitionCombiner, PartitionCombiner).combine(root)
+        root.text = re.sub(r"(?:\n<JANUS_PARTITION>\n)+$", "", root.text)
+        root.affixes = (
+            root.prefix,
+            re.sub(r"(?:\n<JANUS_PARTITION>\n)+$", "", root.suffix),
+        )

janus/llm/models_info.py

@@ -90,6 +90,7 @@ claude_models = [
     "bedrock-claude-instant-v1",
     "bedrock-claude-haiku",
     "bedrock-claude-sonnet",
+    "bedrock-claude-sonnet-3.5",
 ]
 llama2_models = [
     "bedrock-llama2-70b",
@@ -153,6 +154,7 @@ MODEL_ID_TO_LONG_ID = {
     "bedrock-claude-instant-v1": "anthropic.claude-instant-v1",
     "bedrock-claude-haiku": "anthropic.claude-3-haiku-20240307-v1:0",
     "bedrock-claude-sonnet": "anthropic.claude-3-sonnet-20240229-v1:0",
+    "bedrock-claude-sonnet-3.5": "anthropic.claude-3-5-sonnet-20240620-v1:0",
     "bedrock-llama2-70b": "meta.llama2-70b-v1",
     "bedrock-llama2-70b-chat": "meta.llama2-70b-chat-v1",
     "bedrock-llama2-13b": "meta.llama2-13b-chat-v1",
@@ -200,6 +202,7 @@ TOKEN_LIMITS: dict[str, int] = {
     "anthropic.claude-instant-v1": 100_000,
     "anthropic.claude-3-haiku-20240307-v1:0": 248_000,
     "anthropic.claude-3-sonnet-20240229-v1:0": 248_000,
+    "anthropic.claude-3-5-sonnet-20240620-v1:0": 200_000,
     "meta.llama2-70b-v1": 4096,
     "meta.llama2-70b-chat-v1": 4096,
     "meta.llama2-13b-chat-v1": 4096,

janus/parsers/partition_parser.py

@@ -0,0 +1,136 @@
+import json
+import random
+import uuid
+
+from langchain.output_parsers import PydanticOutputParser
+from langchain_core.exceptions import OutputParserException
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.messages import BaseMessage
+from langchain_core.pydantic_v1 import BaseModel, Field
+
+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 PartitionObject(BaseModel):
+    reasoning: str = Field(
+        description="An explanation for why the code should be split at this point"
+    )
+    location: str = Field(
+        description="The 8-character line label which should start a new chunk"
+    )
+
+
+class PartitionList(BaseModel):
+    __root__: list[PartitionObject] = Field(
+        description=(
+            "A list of appropriate split points, each with a `reasoning` field "
+            "that explains a justification for splitting the code at that point, "
+            "and a `location` field which is simply the 8-character line ID. "
+            "The `reasoning` field should always be included first."
+        )
+    )
+
+
+class PartitionParser(JanusParser, PydanticOutputParser):
+    token_limit: int
+    model: BaseLanguageModel
+    lines: list[str] = []
+    line_id_to_index: dict[str, int] = {}
+
+    def __init__(self, token_limit: int, model: BaseLanguageModel):
+        PydanticOutputParser.__init__(
+            self,
+            pydantic_object=PartitionList,
+            model=model,
+            token_limit=token_limit,
+        )
+
+    def parse_input(self, block: CodeBlock) -> str:
+        code = str(block.text)
+        RNG.seed(code)
+
+        self.lines = code.split("\n")
+
+        # 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])
+
+        # Prepend each line with the corresponding ID, save the mapping
+        self.line_id_to_index = {lid: i for i, lid in enumerate(line_ids)}
+        processed = "\n".join(
+            f"{line_id}\t{self.lines[i]}" for line_id, i in self.line_id_to_index.items()
+        )
+        return processed
+
+    def parse(self, text: str | BaseMessage) -> str:
+        if isinstance(text, BaseMessage):
+            text = str(text.content)
+
+        try:
+            out: PartitionList = super().parse(text)
+        except (OutputParserException, json.JSONDecodeError):
+            log.debug(f"Invalid JSON object. Output:\n{text}")
+            raise
+
+        # 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
+        ]
+        if invalid_splits:
+            err_msg = (
+                f"{len(invalid_splits)} line ID(s) not found in input: "
+                + ", ".join(invalid_splits)
+            )
+            log.warning(err_msg)
+            raise OutputParserException(err_msg)
+
+        # 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
+            split_points.add(index)
+
+        # Get partition start/ends, chunks, chunk lengths
+        split_points = sorted(split_points) + [None]
+        partition_indices = list(zip(split_points, split_points[1:]))
+        partition_points = [
+            (index_to_line_id[i0], index_to_line_id[i1]) for i0, i1 in partition_indices
+        ]
+        chunks = ["\n".join(self.lines[i0:i1]) for i0, i1 in partition_indices]
+        chunk_tokens = list(map(self.model.get_num_tokens, chunks))
+
+        # Collect any chunks that exceed token limit
+        oversized_indices: list[int] = [
+            i for i, n in enumerate(chunk_tokens) if n > self.token_limit
+        ]
+        if oversized_indices:
+            data = list(zip(partition_points, chunks, chunk_tokens))
+            data = [data[i] for i in oversized_indices]
+
+            problem_points = "\n".join(
+                [
+                    f"{i0} to {i1} ({t / self.token_limit:.1f}x maximum length)"
+                    for (i0, i1), _, t in data
+                ]
+            )
+            log.warning(f"Found {len(data)} oversized chunks:\n{problem_points}")
+            log.debug(
+                "Oversized chunks:\n"
+                + "\n#############\n".join(chunk for _, chunk, _ in data)
+            )
+            raise OutputParserException(
+                f"The following segments are too long and must be "
+                f"further subdivided:\n{problem_points}"
+            )
+
+        return "\n<JANUS_PARTITION>\n".join(chunks)

janus/refiners/refiner.py

@@ -1,3 +1,4 @@
+import re
 from typing import Any
 
 from langchain.output_parsers import RetryWithErrorOutputParser
@@ -27,7 +28,7 @@ class JanusRefiner(JanusParser):
 
 class FixParserExceptions(JanusRefiner, RetryWithErrorOutputParser):
     def __init__(self, llm: JanusModel, parser: JanusParser, max_retries: int):
-        retry_prompt = MODEL_PROMPT_ENGINES[llm.model_id](
+        retry_prompt = MODEL_PROMPT_ENGINES[llm.short_model_id](
             source_language="text",
             prompt_template="refinement/fix_exceptions",
         ).prompt
@@ -46,6 +47,7 @@ class ReflectionRefiner(JanusRefiner):
     max_retries: int
     reflection_chain: RunnableSerializable
     revision_chain: RunnableSerializable
+    reflection_prompt_name: str
 
     def __init__(
         self,
@@ -54,11 +56,11 @@ class ReflectionRefiner(JanusRefiner):
         max_retries: int,
         prompt_template_name: str = "refinement/reflection",
     ):
-        reflection_prompt = MODEL_PROMPT_ENGINES[llm.model_id](
+        reflection_prompt = MODEL_PROMPT_ENGINES[llm.short_model_id](
             source_language="text",
             prompt_template=prompt_template_name,
         ).prompt
-        revision_prompt = MODEL_PROMPT_ENGINES[llm.model_id](
+        revision_prompt = MODEL_PROMPT_ENGINES[llm.short_model_id](
             source_language="text",
             prompt_template="refinement/revision",
         ).prompt
@@ -66,6 +68,7 @@ class ReflectionRefiner(JanusRefiner):
         reflection_chain = reflection_prompt | llm | StrOutputParser()
         revision_chain = revision_prompt | llm | StrOutputParser()
         super().__init__(
+            reflection_prompt_name=prompt_template_name,
             reflection_chain=reflection_chain,
             revision_chain=revision_chain,
             parser=parser,
@@ -75,6 +78,7 @@ class ReflectionRefiner(JanusRefiner):
     def parse_completion(
         self, completion: str, prompt_value: PromptValue, **kwargs
     ) -> Any:
+        log.info(f"Reflection Prompt: {self.reflection_prompt_name}")
         for retry_number in range(self.max_retries):
             reflection = self.reflection_chain.invoke(
                 dict(
@@ -82,7 +86,7 @@ class ReflectionRefiner(JanusRefiner):
                     completion=completion,
                 )
             )
-            if reflection.strip() == "LGTM":
+            if re.search(r"\bLGTM\b", reflection) is not None:
                 return self.parser.parse(completion)
             if not retry_number:
                 log.info(f"Completion:\n{completion}")
@@ -105,11 +109,3 @@ class HallucinationRefiner(ReflectionRefiner):
             prompt_template_name="refinement/hallucination",
             **kwargs,
         )
-
-
-REFINERS = dict(
-    none=JanusRefiner,
-    parser=FixParserExceptions,
-    reflection=ReflectionRefiner,
-    hallucination=HallucinationRefiner,
-)

janus/refiners/uml.py

@@ -0,0 +1,33 @@
+from janus.llm.models_info import JanusModel
+from janus.parsers.parser import JanusParser
+from janus.refiners.refiner import ReflectionRefiner
+
+
+class ALCFixUMLVariablesRefiner(ReflectionRefiner):
+    def __init__(
+        self,
+        llm: JanusModel,
+        parser: JanusParser,
+        max_retries: int,
+    ):
+        super().__init__(
+            llm=llm,
+            parser=parser,
+            max_retries=max_retries,
+            prompt_template_name="refinement/uml/alc_fix_variables",
+        )
+
+
+class FixUMLConnectionsRefiner(ReflectionRefiner):
+    def __init__(
+        self,
+        llm: JanusModel,
+        parser: JanusParser,
+        max_retries: int,
+    ):
+        super().__init__(
+            llm=llm,
+            parser=parser,
+            max_retries=max_retries,
+            prompt_template_name="refinement/uml/fix_connections",
+        )

janus/retrievers/retriever.py

@@ -1,7 +1,16 @@
+from typing import List
+
+from langchain_core.documents import Document
+from langchain_core.output_parsers import StrOutputParser
 from langchain_core.retrievers import BaseRetriever
 from langchain_core.runnables import Runnable, RunnableConfig
 
 from janus.language.block import CodeBlock
+from janus.llm.models_info import MODEL_PROMPT_ENGINES, JanusModel
+from janus.utils.logger import create_logger
+from janus.utils.pdf_docs_reader import PDFDocsReader
+
+log = create_logger(__name__)
 
 
 class JanusRetriever(Runnable):
@@ -40,3 +49,54 @@ class TextSearchRetriever(JanusRetriever):
         docs = self.retriever.invoke(code_block.text)
         context = "\n\n".join(doc.page_content for doc in docs)
         return f"You may use the following additional context: {context}"
+
+
+class LanguageDocsRetriever(JanusRetriever):
+    def __init__(
+        self,
+        llm: JanusModel,
+        language_name: str,
+        prompt_template_name: str = "retrieval/language_docs",
+    ):
+        super().__init__()
+        self.llm: JanusModel = llm
+        self.language: str = language_name
+
+        self.PDF_reader = PDFDocsReader(
+            language=self.language,
+        )
+
+        language_docs_prompt = MODEL_PROMPT_ENGINES[self.llm.short_model_id](
+            source_language=self.language,
+            prompt_template=prompt_template_name,
+        ).prompt
+
+        parser: StrOutputParser = StrOutputParser()
+        self.chain = language_docs_prompt | self.llm | parser
+
+    def get_context(self, code_block: CodeBlock) -> str:
+        functionality_to_reference: str = self.chain.invoke(
+            dict({"SOURCE_CODE": code_block.text, "SOURCE_LANGUAGE": self.language})
+        )
+        if functionality_to_reference == "NODOCS":
+            log.debug("No Opcodes requested from language docs retriever.")
+            return ""
+        else:
+            functionality_to_reference: List = functionality_to_reference.split(", ")
+            log.debug(
+                f"List of opcodes requested by language docs retriever"
+                f"to search the {self.language} "
+                f"docs for: {functionality_to_reference}"
+            )
+
+            docs: List[Document] = self.PDF_reader.search_language_reference(
+                functionality_to_reference
+            )
+            context = "\n\n".join(doc.page_content for doc in docs)
+            if context:
+                return (
+                    f"You may reference the following excerpts from the {self.language} "
+                    f"language documentation: {context}"
+                )
+            else:
+                return ""

janus/utils/pdf_docs_reader.py

@@ -0,0 +1,134 @@
+import os
+import time
+from pathlib import Path
+from typing import List, Optional
+
+import joblib
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_core.documents import Document
+from langchain_unstructured import UnstructuredLoader
+from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+from janus.utils.logger import create_logger
+
+log = create_logger(__name__)
+
+
+class PDFDocsReader:
+    def __init__(
+        self,
+        language: str,
+        chunk_size: int = 1000,
+        chunk_overlap: int = 100,
+        start_page: Optional[int] = None,
+        end_page: Optional[int] = None,
+        vectorizer: CountVectorizer = TfidfVectorizer(),
+    ):
+        self.retrieval_docs_dir: Path = Path(
+            os.getenv("RETRIEVAL_DOCS_DIR", "retrieval_docs")
+        )
+        self.language = language
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+        self.start_page = start_page
+        self.end_page = end_page
+        self.vectorizer = vectorizer
+        self.documents = self.load_and_chunk_pdf()
+        self.doc_vectors = self.vectorize_documents()
+
+    def load_and_chunk_pdf(self) -> List[str]:
+        pdf_path = self.retrieval_docs_dir / f"{self.language}.pdf"
+        pickled_documents_path = (
+            self.retrieval_docs_dir / f"{self.language}_documents.pkl"
+        )
+
+        if pickled_documents_path.exists():
+            log.debug(
+                f"Loading pre-chunked PDF from {pickled_documents_path}. "
+                f"If you want to regenerate retrieval docs for {self.language}, "
+                f"delete the file at {pickled_documents_path}, "
+                f"then add a new {self.language}.pdf."
+            )
+            documents = joblib.load(pickled_documents_path)
+        else:
+            if not pdf_path.exists():
+                raise FileNotFoundError(
+                    f"Language docs retrieval is enabled, but no PDF for language "
+                    f"'{self.language}' was found. Move a "
+                    f"{self.language} reference manual to "
+                    f"{pdf_path.absolute()} "
+                    f"(the path to the directory of PDF docs can be "
+                    f"set with the env variable 'RETRIEVAL_DOCS_DIR')."
+                )
+            log.info(
+                f"Chunking reference PDF for {self.language} using unstructured - "
+                f"if your PDF has many pages, this could take a while..."
+            )
+            start_time = time.time()
+            loader = UnstructuredLoader(
+                pdf_path,
+                chunking_strategy="basic",
+                max_characters=1000000,
+                include_orig_elements=False,
+                start_page=self.start_page,
+                end_page=self.end_page,
+            )
+            docs = loader.load()
+            text = "\n\n".join([doc.page_content for doc in docs])
+            text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=self.chunk_size, chunk_overlap=self.chunk_overlap
+            )
+            documents = text_splitter.split_text(text)
+            log.info(f"Document store created for language: {self.language}")
+            end_time = time.time()
+            log.info(
+                f"Processing time for {self.language} PDF: "
+                f"{end_time - start_time} seconds"
+            )
+
+            joblib.dump(documents, pickled_documents_path)
+            log.debug(f"Documents saved to {pickled_documents_path}")
+
+        return documents
+
+    def vectorize_documents(self) -> (TfidfVectorizer, any):
+        doc_vectors = self.vectorizer.fit_transform(self.documents)
+        return doc_vectors
+
+    def search_language_reference(
+        self,
+        query: List[str],
+        top_k: int = 1,
+        min_similarity: float = 0.1,
+    ) -> List[Document]:
+        """Searches through the vectorized PDF for the query using
+        tf-idf and returns a list of langchain Documents."""
+
+        docs: List[Document] = []
+
+        for item in query:
+            # Transform the query using the TF-IDF vectorizer
+            query_vector = self.vectorizer.transform([item])
+
+            # Calculate cosine similarities between the query and document vectors
+            similarities = cosine_similarity(query_vector, self.doc_vectors).flatten()
+
+            # Get the indices of documents with similarity above the threshold
+            valid_indices = [
+                i for i, sim in enumerate(similarities) if sim >= min_similarity
+            ]
+
+            # Sort the valid indices by similarity score in descending order
+            sorted_indices = sorted(
+                valid_indices, key=lambda i: similarities[i], reverse=True
+            )
+
+            # Limit to top-k results
+            top_indices = sorted_indices[:top_k]
+
+            # Retrieve the top-k most relevant documents
+            docs += [Document(page_content=self.documents[i]) for i in top_indices]
+            log.debug(f"Langauge documentation search result: {docs}")
+
+        return docs

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: janus-llm
-Version: 4.1.0
+Version: 4.2.0
 Summary: A transcoding library using LLMs.
 Home-page: https://github.com/janus-llm/janus-llm
 License: Apache 2.0
@@ -23,20 +23,28 @@ Requires-Dist: langchain-anthropic (>=0.1.15,<0.2.0)
 Requires-Dist: langchain-community (>=0.2.0,<0.3.0)
 Requires-Dist: langchain-core (>=0.2.0,<0.3.0)
 Requires-Dist: langchain-openai (>=0.1.8,<0.2.0)
+Requires-Dist: langchain-unstructured (>=0.1.2,<0.2.0)
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numpy (>=1.24.3,<2.0.0)
 Requires-Dist: openai (>=1.14.0,<2.0.0)
+Requires-Dist: pi-heif (>=0.20.0,<0.21.0)
 Requires-Dist: py-readability-metrics (>=1.4.5,<2.0.0)
 Requires-Dist: py-rouge (>=1.1,<2.0)
+Requires-Dist: pytesseract (>=0.3.13,<0.4.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: rich (>=13.7.1,<14.0.0)
 Requires-Dist: sacrebleu (>=2.4.1,<3.0.0)
+Requires-Dist: scikit-learn (>=1.5.2,<2.0.0)
 Requires-Dist: sentence-transformers (>=2.6.1,<3.0.0) ; extra == "hf-local" or extra == "all"
+Requires-Dist: tesseract (>=0.1.3,<0.2.0)
 Requires-Dist: text-generation (>=0.6.0,<0.7.0)
 Requires-Dist: tiktoken (>=0.7.0,<0.8.0)
 Requires-Dist: transformers (>=4.31.0,<5.0.0)
 Requires-Dist: tree-sitter (>=0.21.0,<0.22.0)
 Requires-Dist: typer (>=0.9.0,<0.10.0)
+Requires-Dist: unstructured (>=0.15.9,<0.16.0)
+Requires-Dist: unstructured-inference (>=0.7.36,<0.8.0)
+Requires-Dist: unstructured-pytesseract (>=0.3.13,<0.4.0)
 Project-URL: Documentation, https://janus-llm.github.io/janus-llm
 Project-URL: Repository, https://github.com/janus-llm/janus-llm
 Description-Content-Type: text/markdown

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

@@ -1,17 +1,18 @@
-janus/__init__.py,sha256=DBaGeUwOFIZW4QsQV06WFYM6RAz6pNdOZxJjTj3Uf7I,361
+janus/__init__.py,sha256=8ZZh7ctoYQaClu_ak9pFc5eYVEcaSju33Ru0vZBp_iM,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=MkeV0FiYXmEcMnERne6pSrLSyc5xhny2bORLY-19A6o,39091
-janus/converter/__init__.py,sha256=U2EOMcCykiC0ZqhorNefOP_04hOF18qhYoPKrVp1Vrk,345
+janus/cli.py,sha256=eGmzu8aei1QNN_WaWeMYltgIHdKr1MPwG2Er0AEBIuo,42563
+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=HWw-a4j-Qq0AWDyyk6cMVOwYjJeXxa3bvs9OOlKo_KI,25965
+janus/converter/converter.py,sha256=1WFGy8LozO8pVjbPcYJa9-TTZqgNxwUs7oDca86TcvE,26174
 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/partition.py,sha256=ASvv4hAue44qHobO4kqr_tKr-eJsXCPPdD3NtNd9V-E,993
 janus/converter/requirements.py,sha256=9tvQ40FZJtG8niIFn45gPQCgKKHVPPoFLinBv6RAqO4,2027
 janus/converter/translate.py,sha256=S1DPZdmX9Vrn_sJPcobvXmhmS8U53yl5cRXjsmXPtas,4246
 janus/embedding/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -37,7 +38,7 @@ janus/language/binary/_tests/test_binary.py,sha256=cIKIxjj6kIY3rcxLwqUPESP9bxWrH
 janus/language/binary/binary.py,sha256=PHsVa8jcM7sW9aTboGRWXj6ewQznz0kVPNWtP4B9YPU,6555
 janus/language/binary/reveng/decompile_script.py,sha256=veW51oJzuO-4UD3Er062jXZ_FYtTFo9OCkl82Z2xr6A,2182
 janus/language/block.py,sha256=2rjAYUosHFfWRgLnzf50uAgTMST4Md9Kx6JrlUfEfX4,9398
-janus/language/combine.py,sha256=Wtve06fa-_Wjv_V5RIf1Nfmg0UxcOEtFNj4vVHpSNbo,2940
+janus/language/combine.py,sha256=egZRl1xZXAFXa2ZjjfqnNckc9uxuo6e1MJgkRrCgvd8,3650
 janus/language/file.py,sha256=jy-cReAoI6F97TXR5bbhPyt8XyUZCdFYnVboubDA_y4,571
 janus/language/mumps/__init__.py,sha256=-Ou_wJ-JgHezfp1dub2_qCYNiK9wO-zo2MlqxM9qiwE,48
 janus/language/mumps/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -58,7 +59,7 @@ janus/language/treesitter/_tests/test_treesitter.py,sha256=fmr_mFSja7vaCVu0TVyLD
 janus/language/treesitter/treesitter.py,sha256=q7fqfFxt7QsqM6tE39uqutRMsOfEgBd3omv7zVZSEOc,7517
 janus/llm/__init__.py,sha256=TKLYvnsWKWfxMucy-lCLQ-4bkN9ENotJZDywDEQmrKg,45
 janus/llm/model_callbacks.py,sha256=cHRZBpYgAwiYbA2k0GQ7DBwBFQZJpEGMUBV3Q_5GTpU,7940
-janus/llm/models_info.py,sha256=KWOQiWU1oAJB9nspI6N6Q32vHRH8loO8xM-Ys497fxc,10443
+janus/llm/models_info.py,sha256=6ImXTgCeNkMPtW-9swdaWXISixb-UUqq6OCUl8kPxCs,10612
 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,21 +90,24 @@ janus/parsers/code_parser.py,sha256=3l0HfzgrvJuiwk779s9ZsgUl3xbp1nE1qZxh8aDYRBI,
 janus/parsers/doc_parser.py,sha256=0pUsNZ9hKQLjIi8L8BgkOBHQZ_EGoFLHrBQ4hoDkjSw,5862
 janus/parsers/eval_parser.py,sha256=Gjh6aTZgpYd2ASJUEPMo4LpCL00cBmbOqc4KM3hy8x8,2922
 janus/parsers/parser.py,sha256=y6VV64bgVidf-oEFla3I--_28tnJsPBc6QUD_SkbfSE,1614
+janus/parsers/partition_parser.py,sha256=z9EoqttHacegZzhkoGa-j4vxuzaleDuq32FonzaXsW8,4974
 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=lKAVS9Nszx8aO7hLB0xzdMmUNfhX7K5SaXwcit2QBHs,3774
-janus/retrievers/retriever.py,sha256=WzsYn329GbyJfmJ9KyU9yiYdhLkuS6WPKTKoHx5fBYQ,1339
+janus/refiners/refiner.py,sha256=f2YDLnG2TF3Kws40chVOBQ91DD6zf2B1wcoP6WeQcIk,3829
+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/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.1.0.dist-info/LICENSE,sha256=_j0st0a-HB6MRbP3_BW3PUqpS16v54luyy-1zVyl8NU,10789
-janus_llm-4.1.0.dist-info/METADATA,sha256=RPA9U5cyO_-ulE45F1gBbTOnkRcjdBTOARyJs9XAvgg,4184
-janus_llm-4.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-janus_llm-4.1.0.dist-info/entry_points.txt,sha256=OGhQwzj6pvXp79B0SaBD5apGekCu7Dwe9fZZT_TZ544,39
-janus_llm-4.1.0.dist-info/RECORD,,
+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.1.0.dist-info → janus_llm-4.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any