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

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

@@ -0,0 +1,168 @@
+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."
+        )
+    )
+
+
+# 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
+    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_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)}
+        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)
+
+        # 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_locations.difference(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 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
+        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,6 +1,8 @@
+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
@@ -25,9 +27,38 @@ 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.model_id](
+        retry_prompt = MODEL_PROMPT_ENGINES[llm.short_model_id](
             source_language="text",
             prompt_template="refinement/fix_exceptions",
         ).prompt
@@ -46,6 +77,7 @@ class ReflectionRefiner(JanusRefiner):
     max_retries: int
     reflection_chain: RunnableSerializable
     revision_chain: RunnableSerializable
+    reflection_prompt_name: str
 
     def __init__(
         self,
@@ -54,11 +86,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 +98,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 +108,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 +116,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 +139,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/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/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.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: janus-llm
-Version: 4.1.0
+Version: 4.3.1
 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