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

janus/llm/models_info.py

@@ -1,15 +1,14 @@
 import json
 import os
-import time
 from pathlib import Path
-from typing import Protocol, TypeVar
+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 ChatOpenAI
+from langchain_openai import AzureChatOpenAI
 
-from janus.llm.model_callbacks import COST_PER_1K_TOKENS, openai_model_reroutes
+from janus.llm.model_callbacks import COST_PER_1K_TOKENS, azure_model_reroutes
 from janus.prompts.prompt import (
     ChatGptPromptEngine,
     ClaudePromptEngine,
@@ -46,7 +45,7 @@ except ImportError:
 
 ModelType = TypeVar(
     "ModelType",
-    ChatOpenAI,
+    AzureChatOpenAI,
     HuggingFaceTextGenInference,
     Bedrock,
     BedrockChat,
@@ -72,7 +71,6 @@ class JanusModel(Runnable, JanusModelProtocol):
 
 load_dotenv()
 
-
 openai_models = [
     "gpt-4o",
     "gpt-4o-mini",
@@ -82,11 +80,17 @@ openai_models = [
     "gpt-3.5-turbo",
     "gpt-3.5-turbo-16k",
 ]
+azure_models = [
+    "gpt-4o",
+    "gpt-4o-mini",
+    "gpt-3.5-turbo-16k",
+]
 claude_models = [
     "bedrock-claude-v2",
     "bedrock-claude-instant-v1",
     "bedrock-claude-haiku",
     "bedrock-claude-sonnet",
+    "bedrock-claude-sonnet-3.5",
 ]
 llama2_models = [
     "bedrock-llama2-70b",
@@ -120,18 +124,21 @@ bedrock_models = [
     *cohere_models,
     *mistral_models,
 ]
-all_models = [*openai_models, *bedrock_models]
+all_models = [*azure_models, *bedrock_models]
 
 MODEL_TYPE_CONSTRUCTORS: dict[str, ModelType] = {
-    "OpenAI": ChatOpenAI,
+    # "OpenAI": ChatOpenAI,
     "HuggingFace": HuggingFaceTextGenInference,
+    "Azure": AzureChatOpenAI,
     "Bedrock": Bedrock,
     "BedrockChat": BedrockChat,
     "HuggingFaceLocal": HuggingFacePipeline,
 }
 
-MODEL_PROMPT_ENGINES: dict[str, type[PromptEngine]] = {
-    **{m: ChatGptPromptEngine for m in openai_models},
+
+MODEL_PROMPT_ENGINES: dict[str, Callable[..., PromptEngine]] = {
+    # **{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},
     **{m: Llama3PromptEngine for m in llama3_models},
@@ -141,11 +148,13 @@ MODEL_PROMPT_ENGINES: dict[str, type[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",
     "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",
@@ -171,8 +180,9 @@ DEFAULT_MODELS = list(MODEL_DEFAULT_ARGUMENTS.keys())
 
 MODEL_CONFIG_DIR = Path.home().expanduser() / ".janus" / "llm"
 
-MODEL_TYPES: dict[str, str] = {
-    **{m: "OpenAI" for m in openai_models},
+MODEL_TYPES: dict[str, PromptEngine] = {
+    # **{m: "OpenAI" for m in openai_models},
+    **{m: "Azure" for m in azure_models},
     **{m: "BedrockChat" for m in bedrock_models},
 }
 
@@ -182,13 +192,17 @@ TOKEN_LIMITS: dict[str, int] = {
     "gpt-4-1106-preview": 128_000,
     "gpt-4-0125-preview": 128_000,
     "gpt-4o-2024-05-13": 128_000,
+    "gpt-4o-2024-08-06": 128_000,
+    "gpt-4o-mini": 128_000,
     "gpt-3.5-turbo-0125": 16_384,
+    "gpt35-turbo-16k": 16_384,
     "text-embedding-ada-002": 8191,
     "gpt4all": 16_384,
     "anthropic.claude-v2": 100_000,
     "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,
@@ -270,11 +284,21 @@ def load_model(model_id) -> JanusModel:
             openai_api_key=str(os.getenv("OPENAI_API_KEY")),
             openai_organization=str(os.getenv("OPENAI_ORG_ID")),
         )
-        log.warning("Do NOT use this model in sensitive environments!")
-        log.warning("If you would like to cancel, please press Ctrl+C.")
-        log.warning("Waiting 10 seconds...")
+        # log.warning("Do NOT use this model in sensitive environments!")
+        # log.warning("If you would like to cancel, please press Ctrl+C.")
+        # log.warning("Waiting 10 seconds...")
         # Give enough time for the user to read the warnings and cancel
-        time.sleep(10)
+        # time.sleep(10)
+        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"),
+            }
+        )
 
     model_type = MODEL_TYPE_CONSTRUCTORS[model_type_name]
     prompt_engine = MODEL_PROMPT_ENGINES[model_id]

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.0.0.dist-info → janus_llm-4.2.0.dist-info}/METADATA

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