janus-llm 4.3.5__py3-none-any.whl → 4.5.4__py3-none-any.whl

janus/converter/requirements.py

@@ -1,8 +1,4 @@
-import json
-from pathlib import Path
-
 from janus.converter.document import Documenter
-from janus.language.block import TranslatedCodeBlock
 from janus.language.combine import ChunkCombiner
 from janus.parsers.reqs_parser import RequirementsParser
 from janus.utils.logger import create_logger
@@ -16,41 +12,12 @@ class RequirementsDocumenter(Documenter):
     A class that translates code from one programming language to its requirements.
     """
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.set_prompt("requirements")
+    def __init__(
+        self, combine_output: bool = False, output_type: str = "requirements", **kwargs
+    ):
+        kwargs.update(output_type=output_type)
+        super().__init__(combine_output=combine_output, **kwargs)
+        self.set_prompts("requirements")
         self._combiner = ChunkCombiner()
         self._parser = RequirementsParser()
-
-    @staticmethod
-    def get_prompt_replacements(block) -> dict[str, str]:
-        prompt_replacements: dict[str, str] = {"SOURCE_CODE": block.original.text}
-        return prompt_replacements
-
-    def _save_to_file(self, block: TranslatedCodeBlock, out_path: Path) -> None:
-        """Save a file to disk.
-
-        Arguments:
-            block: The `CodeBlock` to save to a file.
-        """
-        output_list = list()
-        # For each chunk of code, get generation metadata, the text of the code,
-        # and the LLM generated requirements
-        blocks = [block for block in block.children] if len(block.children) else [block]
-        for block in blocks:
-            code = block.original.text
-            requirements = self._parser.parse_combined_output(block.complete_text)
-            metadata = dict(
-                retries=block.total_retries,
-                cost=block.total_cost,
-                processing_time=block.processing_time,
-            )
-            # Put them all in a top level 'output' key
-            output_list.append(
-                dict(metadata=metadata, code=code, requirements=requirements)
-            )
-        obj = dict(
-            output=output_list,
-        )
-        out_path.parent.mkdir(parents=True, exist_ok=True)
-        out_path.write_text(json.dumps(obj, indent=2), encoding="utf-8")
+        self._load_parameters()

janus/converter/translate.py

@@ -1,8 +1,5 @@
 from janus.converter.converter import Converter, run_if_changed
-from janus.llm.models_info import MODEL_PROMPT_ENGINES
 from janus.parsers.code_parser import CodeParser
-from janus.prompts.prompt import SAME_OUTPUT
-from janus.utils.enums import LANGUAGES
 from janus.utils.logger import create_logger
 
 log = create_logger(__name__)
@@ -29,13 +26,11 @@ class Translator(Converter):
             max_prompts: The maximum number of prompts to try before giving up.
             max_tokens: The maximum number of tokens the model will take in.
                 If unspecificed, model's default max will be used.
-            prompt_template: name of prompt template directory
-                (see janus/prompts/templates) or path to a directory.
+            prompt_templates: name of prompt template directories
+                (see janus/prompts/templates) or paths to directories.
         """
         super().__init__(**kwargs)
 
-        self._target_version: str | None
-
         self.set_target_language(
             target_language=target_language,
             target_version=target_version,
@@ -47,57 +42,6 @@ class Translator(Converter):
         self._load_parser()
         super()._load_parameters()
 
-    def set_target_language(
-        self, target_language: str, target_version: str | None
-    ) -> None:
-        """Validate and set the target language.
-
-        The affected objects will not be updated until translate() is called.
-
-        Arguments:
-            target_language: The target programming language.
-            target_version: The target version of the target programming language.
-        """
-        target_language = target_language.lower()
-        if target_language not in LANGUAGES:
-            raise ValueError(
-                f"Invalid target language: {target_language}. "
-                "Valid target languages are found in `janus.utils.enums.LANGUAGES`."
-            )
-        self._target_language = target_language
-        self._target_version = target_version
-        # Taking the first suffix as the default for output files
-        self._target_suffix = f".{LANGUAGES[target_language]['suffixes'][0]}"
-
-    @run_if_changed(
-        "_prompt_template_name",
-        "_source_language",
-        "_target_language",
-        "_target_version",
-        "_model_name",
-    )
-    def _load_prompt(self) -> None:
-        """Load the prompt 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._prompt_template_name in SAME_OUTPUT:
-            if self._target_language != self._source_language:
-                raise ValueError(
-                    f"Prompt template ({self._prompt_template_name}) suggests "
-                    f"source and target languages should match, but do not "
-                    f"({self._source_language} != {self._target_language})"
-                )
-
-        prompt_engine = MODEL_PROMPT_ENGINES[self._llm.short_model_id](
-            source_language=self._source_language,
-            target_language=self._target_language,
-            target_version=self._target_version,
-            prompt_template=self._prompt_template_name,
-        )
-        self._prompt = prompt_engine.prompt
-
     @run_if_changed("_target_language")
     def _load_parser(self) -> None:
         """Load the parser according to this instance's attributes.

janus/language/_tests/test_combine.py

@@ -36,6 +36,7 @@ class TestCombiner(unittest.TestCase):
         self.translated_block = TranslatedCodeBlock(
             self.block,
             language="python",
+            converter=None,
         )
 
     def test_combine(self):

janus/language/block.py

@@ -1,9 +1,12 @@
 from functools import total_ordering
-from typing import ForwardRef, Hashable, Optional, Tuple
+from typing import TYPE_CHECKING, ForwardRef, Hashable, Optional, Tuple
 
 from janus.language.node import NodeType
 from janus.utils.logger import create_logger
 
+if TYPE_CHECKING:
+    from janus.converter.converter import Converter
+
 log = create_logger(__name__)
 
 
@@ -46,6 +49,9 @@ class CodeBlock:
         embedding_id: Optional[str] = None,
         affixes: Tuple[str, str] = ("", ""),
         context_tags: dict[str, str] = {},
+        previous_generations: list["TranslatedCodeBlock"] = [],
+        block_type: str | None = None,
+        block_label: str | None = None,
     ) -> None:
         self.id: Hashable = id
         self.name: Optional[str] = name
@@ -65,6 +71,9 @@ class CodeBlock:
         self.complete = True
         self.omit_prefix = True
         self.omit_suffix = False
+        self.previous_generations = previous_generations
+        self.block_type = block_type
+        self.block_label = block_label
 
         if self.children:
             self.children[0].omit_prefix = False
@@ -184,12 +193,23 @@ class TranslatedCodeBlock(CodeBlock):
         translated: Whether this block has been successfully translated
     """
 
-    def __init__(self, original: CodeBlock, language: str) -> None:
+    def __init__(
+        self,
+        original: CodeBlock,
+        language: str,
+        converter: ForwardRef("Converter"),
+        block_type: str | None = None,
+        block_label: str | None = None,
+    ) -> None:
         """Create an "empty" `TranslatedCodeBlock` from the given original
 
         Arguments:
             original: The original code block
             language: The language to translate to
+            converter: the converter used to translate
+            block_type: type of the block
+            block_label: label for block
+            (for mapping outputs to inputs through ConverterChain)
 
         Returns:
             A `TranslatedCodeBlock` with the same attributes as the original, except
@@ -207,18 +227,24 @@ class TranslatedCodeBlock(CodeBlock):
             end_byte=None,
             tokens=0,
             children=[
-                TranslatedCodeBlock(child, language) for child in original.children
+                TranslatedCodeBlock(child, language, block_type, block_label)
+                for child in original.children
             ],
             affixes=original.affixes,
+            previous_generations=original.previous_generations,
+            block_type=block_type,
+            block_label=block_label,
         )
+
         self.original = original
+        self.converter = converter
 
         self.complete = original.complete
         self.translated = False
-        self.cost = 0.0
+        self.cost = 0
         self.num_requests = 0
         self.tokens = 0
-        self.processing_time = 0.0
+        self.processing_time = 0
 
         self.request_input_tokens = 0
         self.request_output_tokens = 0
@@ -276,6 +302,11 @@ class TranslatedCodeBlock(CodeBlock):
         children_sum = sum(c.total_num_requests for c in self.children)
         return children_sum + self.num_requests
 
+    @property
+    def total_processing_time(self) -> float:
+        children_sum = sum(c.total_processing_time for c in self.children)
+        return children_sum + self.processing_time
+
     @property
     def translation_completed(self) -> bool:
         """Whether or not the code block was successfully translated
@@ -297,3 +328,82 @@ class TranslatedCodeBlock(CodeBlock):
             if self.original.total_tokens
             else 0
         )
+
+    def to_codeblock(self) -> CodeBlock:
+        return CodeBlock(
+            id=self.id,
+            name=self.name,
+            node_type=self.node_type,
+            language=self.language,
+            text=self.text,
+            start_point=self.start_point,
+            end_point=self.end_point,
+            start_byte=self.start_byte,
+            end_byte=self.end_byte,
+            embedding_id=self.embedding_id,
+            tokens=self.tokens,
+            children=[child.to_codeblock() for child in self.children],
+            affixes=self.affixes,
+            previous_generations=self.previous_generations + [self],
+            block_type=self.block_type,
+            block_label=self.block_label,
+        )
+
+    def __iadd__(self, other):
+        self.cost += other.cost
+        self.num_requests += other.num_requests
+        self.processing_time += other.processing_time
+        self.request_input_tokens += other.request_input_tokens
+        self.request_output_tokens += other.request_output_tokens
+        return self
+
+
+class BlockCollection:
+    def __init__(
+        self,
+        blocks: list[CodeBlock],
+        previous_generations: list[ForwardRef("BlockCollection")] = [],
+    ):
+        self.blocks = blocks
+        self.previous_generations = previous_generations
+
+    def to_codeblock(self) -> ForwardRef("BlockCollection"):
+        return BlockCollection(
+            [b.to_codeblock() for b in self.blocks], self.previous_generations + [self]
+        )
+
+    @property
+    def total_cost(self):
+        return sum(b.total_cost for b in self.blocks)
+
+    @property
+    def total_processing_time(self):
+        return sum(b.total_processing_time for b in self.blocks)
+
+    @property
+    def total_request_input_tokens(self):
+        return sum(b.total_request_input_tokens for b in self.blocks)
+
+    @property
+    def total_request_output_tokens(self):
+        return sum(b.total_request_output_tokens for b in self.blocks)
+
+    @property
+    def total_num_requests(self):
+        return sum(b.total_num_requests for b in self.blocks)
+
+    @property
+    def block_type(self):
+        return None
+
+    @property
+    def block_label(self):
+        return None
+
+    @property
+    def translation_completed(self):
+        return all(b.translation_completed for b in self.blocks)
+
+    @property
+    def complete(self):
+        return all(b.complete for b in self.blocks)

janus/llm/model_callbacks.py

@@ -44,12 +44,18 @@ COST_PER_1K_TOKENS: dict[str, dict[str, float]] = {
     "anthropic.claude-instant-v1": {"input": 0.0008, "output": 0.0024},
     "anthropic.claude-3-haiku-20240307-v1:0": {"input": 0.00025, "output": 0.00125},
     "anthropic.claude-3-sonnet-20240229-v1:0": {"input": 0.003, "output": 0.015},
+    "anthropic.claude-3-5-sonnet-20240620-v1:0": {"input": 0.003, "output": 0.015},
+    "anthropic.claude-3-5-sonnet-20241022-v2:0": {"input": 0.003, "output": 0.015},
     "meta.llama2-13b-chat-v1": {"input": 0.00075, "output": 0.001},
     "meta.llama2-70b-chat-v1": {"input": 0.00195, "output": 0.00256},
     "meta.llama2-13b-v1": {"input": 0.0, "output": 0.0},
     "meta.llama2-70b-v1": {"input": 0.00265, "output": 0.0035},
     "meta.llama3-8b-instruct-v1:0": {"input": 0.0003, "output": 0.0006},
     "meta.llama3-70b-instruct-v1:0": {"input": 0.00265, "output": 0.0035},
+    "meta.llama3-3-70b-instruct-v1:0": {"input": 0.00072, "output": 0.00072},
+    "amazon.nova-lite-v1:0": {"input": 0.00006, "output": 0.00024},
+    "amazon.nova-micro-v1:0": {"input": 0.000035, "output": 0.00014},
+    "amazon.nova-pro-v1:0": {"input": 0.0008, "output": 0.0032},
     "amazon.titan-text-lite-v1": {"input": 0.00015, "output": 0.0002},
     "amazon.titan-text-express-v1": {"input": 0.0002, "output": 0.0006},
     "ai21.j2-mid-v1": {"input": 0.0125, "output": 0.0125},

janus/llm/models_info.py

@@ -96,12 +96,16 @@ claude_models = [
     "bedrock-claude-haiku",
     "bedrock-claude-sonnet",
     "bedrock-claude-sonnet-3.5",
+    "bedrock-claude-sonnet-3.5-v2",
 ]
 llama2_models = [
     "bedrock-llama2-70b",
     "bedrock-llama2-70b-chat",
     "bedrock-llama2-13b",
     "bedrock-llama2-13b-chat",
+    "bedrock-llama3-8b-instruct",
+    "bedrock-llama3-70b-instruct",
+    "bedrock-llama3-3-70b-instruct",
 ]
 llama3_models = [
     "bedrock-llama3-8b-instruct",
@@ -113,6 +117,11 @@ titan_models = [
     "bedrock-jurassic-2-mid",
     "bedrock-jurassic-2-ultra",
 ]
+nova_models = [
+    "bedrock-nova-lite",
+    "bedrock-nova-micro",
+    "bedrock-nova-pro",
+]
 cohere_models = [
     "bedrock-command-r-plus",
 ]
@@ -160,12 +169,17 @@ MODEL_ID_TO_LONG_ID = {
     "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-claude-sonnet-3.5-v2": "anthropic.claude-3-5-sonnet-20241022-v2: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",
     "bedrock-llama2-13b-chat": "meta.llama2-13b-v1",
     "bedrock-llama3-8b-instruct": "meta.llama3-8b-instruct-v1:0",
     "bedrock-llama3-70b-instruct": "meta.llama3-70b-instruct-v1:0",
+    "bedrock-llama3-3-70b-instruct": "meta.llama3-3-70b-instruct-v1:0",
+    "bedrock-nova-lite": "amazon.nova-lite-v1:0",
+    "bedrock-nova-micro": "amazon.nova-micro-v1:0",
+    "bedrock-nova-pro": "amazon.nova-pro-v1:0",
     "bedrock-titan-text-lite": "amazon.titan-text-lite-v1",
     "bedrock-titan-text-express": "amazon.titan-text-express-v1",
     "bedrock-jurassic-2-mid": "ai21.j2-mid-v1",
@@ -208,12 +222,17 @@ TOKEN_LIMITS: dict[str, int] = {
     "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,
+    "anthropic.claude-3-5-sonnet-20241022-v2:0": 200_000,
     "meta.llama2-70b-v1": 4096,
     "meta.llama2-70b-chat-v1": 4096,
     "meta.llama2-13b-chat-v1": 4096,
     "meta.llama2-13b-v1": 4096,
     "meta.llama3-8b-instruct-v1:0": 8000,
     "meta.llama3-70b-instruct-v1:0": 8000,
+    "meta.llama3-3-70b-instruct-v1:0": 128_000,
+    "amazon.nova-lite-v1:0": 300_000,
+    "amazon.nova-micro-v1:0": 128_000,
+    "amazon.nova-pro-v1:0": 300_000,
     "amazon.titan-text-lite-v1": 4096,
     "amazon.titan-text-express-v1": 8192,
     "ai21.j2-mid-v1": 8192,

janus/metrics/_tests/test_reading.py

@@ -1,11 +1,25 @@
 import unittest
 
-from janus.metrics.reading import _repeat_text, flesch, gunning_fog
+from janus.metrics.reading import (
+    _repeat_text,
+    automated_readability,
+    coleman_liau,
+    dale_chall,
+    flesch,
+    flesch_grade,
+    gunning_fog,
+    word_count,
+)
 
 
 class TestReading(unittest.TestCase):
     def setUp(self):
-        self.text = "This is a sample text for testing readability metrics"
+        self.text = "This is a sample text for testing readability metrics."
+
+    def test_word_count(self):
+        """Test the word_count function."""
+        count = word_count(self.text)
+        self.assertEqual(count, 9)
 
     def test_repeat_text(self):
         """Test the _repeat_text function."""
@@ -16,12 +30,42 @@ class TestReading(unittest.TestCase):
     def test_flesch(self):
         """Test the Flesch readability score."""
         score = flesch(self.text)
-        self.assertAlmostEqual(score, 47.3, places=2)
+        self.assertAlmostEqual(score, 45.42, places=2)
+
+    def test_flesch_grade(self):
+        """Test the Flesch Grade Level readability score."""
+        score = flesch_grade(self.text)
+        self.assertAlmostEqual(score, 9.2, places=2)
 
     def test_gunning_fog(self):
         """Test the Gunning-Fog readability score."""
         score = gunning_fog(self.text)
-        self.assertAlmostEqual(score, 8.04, places=2)
+        self.assertAlmostEqual(score, 3.97, places=2)
+
+    def test_dale_chall(self):
+        """Test the Dale-Chall readability score."""
+        score = dale_chall(self.text)
+        self.assertAlmostEqual(score, 4.67, places=2)
+
+    def test_automated_readability(self):
+        """Test the Automated Readability Index score."""
+        score = automated_readability(self.text)
+        self.assertAlmostEqual(score, 7.1, places=2)
+
+    def test_coleman_liau(self):
+        """Test the Coleman-Liau Index."""
+        score = coleman_liau(self.text)
+        self.assertAlmostEqual(score, 9.94, places=2)
+
+    def test_blank_target(self):
+        """Test that blank targets return None for all metric functions."""
+        blank = "   "  # blank string with whitespaces
+        self.assertIsNone(flesch(blank))
+        self.assertIsNone(flesch_grade(blank))
+        self.assertIsNone(gunning_fog(blank))
+        self.assertIsNone(dale_chall(blank))
+        self.assertIsNone(automated_readability(blank))
+        self.assertIsNone(coleman_liau(blank))
 
 
 if __name__ == "__main__":

janus/metrics/_tests/test_rouge_score.py

@@ -12,19 +12,13 @@ class TestRouge(unittest.TestCase):
         score = rouge(
             self.target, self.reference, granularity="n", n_gram=2, score_type="f"
         )
-        self.assertIsInstance(score, float)
+        self.assertEqual(score, 0.5)
 
     def test_rouge_with_granularity_l(self):
         score = rouge(
             self.target, self.reference, granularity="l", n_gram=2, score_type="f"
         )
-        self.assertIsInstance(score, float)
-
-    def test_rouge_with_granularity_w(self):
-        score = rouge(
-            self.target, self.reference, granularity="w", n_gram=2, score_type="f"
-        )
-        self.assertIsInstance(score, float)
+        self.assertAlmostEqual(score, 0.8, places=2)
 
     def test_rouge_with_invalid_granularity(self):
         with self.assertRaises(ValueError):
@@ -40,19 +34,19 @@ class TestRouge(unittest.TestCase):
         score = rouge(
             self.target, self.reference, granularity="n", n_gram=2, score_type="f"
         )
-        self.assertIsInstance(score, float)
+        self.assertAlmostEqual(score, 0.5, places=2)
 
     def test_rouge_with_score_type_p(self):
         score = rouge(
             self.target, self.reference, granularity="n", n_gram=2, score_type="p"
         )
-        self.assertIsInstance(score, float)
+        self.assertAlmostEqual(score, 0.5, places=2)
 
     def test_rouge_with_score_type_r(self):
         score = rouge(
             self.target, self.reference, granularity="n", n_gram=2, score_type="r"
         )
-        self.assertIsInstance(score, float)
+        self.assertAlmostEqual(score, 0.5, places=2)
 
     def test_rouge_with_invalid_score_type(self):
         with self.assertRaises(ValueError):