symbolicai 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

symai/extended/solver.py

@@ -57,14 +57,15 @@ $> Max is 2 years older than his brother. In 5 years, Max will be 3 times as old
 --------------
 """
 
+
 class ProblemClassifierPreProcessor(PreProcessor):
     def __call__(self, argument):
-        return f'$> {argument.prop.instance!s}\n//'
+        return f"$> {argument.prop.instance!s}\n//"
 
 
 class OptionsPreProcessor(PreProcessor):
     def __call__(self, argument):
-        return f'$> :{argument.prop.instance!s}: == :{argument.args[0]!s}: =>'
+        return f"$> :{argument.prop.instance!s}: == :{argument.args[0]!s}: =>"
 
 
 class ProblemClassifier(Expression):
@@ -75,32 +76,41 @@ class ProblemClassifier(Expression):
         return PROBLEM_CATEGORY_CONTEXT
 
     def __eq__(self, other, **kwargs) -> bool:
-        @core.few_shot(prompt="Verify equality of the following categories. Ignore typos, upper / lower case or singular / plural differences:\n",
-                     examples=Prompt([
-                         '$> :Arithmetic formula: == :Arithmetics formula: =>True EOF',
-                         '$> :arithmetic formula: == :Arithmetic formula: =>True EOF',
-                         '$> :arithmetic formula: == :arithmeticformula: =>True EOF',
-                         '$> :arithmetic formula: == :Implication and logical expressions: =>False EOF',
-                         '$> :Linear algebra: == :Implication and logical expressions: =>False EOF',
-                         '$> :Linear algebra: == :Unknown category: =>False EOF',
-                         '$> :Linear algebra: == :Linear algebra: =>True EOF',
-                         '$> :Probability and statistics: == :Probabilities and statistics: =>True EOF',
-                         '$> :PROBABILITY AND STATISTICS: == :Probability and statistics: =>True EOF',
-                         '$> :PROBABILITY AND STATISTICS: == :UNKNOWN CATEGORY: =>False EOF',
-                     ]),
-                     pre_processors=[OptionsPreProcessor()],
-                     post_processors=[StripPostProcessor()],
-                     stop=['EOF'], **kwargs)
+        @core.few_shot(
+            prompt="Verify equality of the following categories. Ignore typos, upper / lower case or singular / plural differences:\n",
+            examples=Prompt(
+                [
+                    "$> :Arithmetic formula: == :Arithmetics formula: =>True EOF",
+                    "$> :arithmetic formula: == :Arithmetic formula: =>True EOF",
+                    "$> :arithmetic formula: == :arithmeticformula: =>True EOF",
+                    "$> :arithmetic formula: == :Implication and logical expressions: =>False EOF",
+                    "$> :Linear algebra: == :Implication and logical expressions: =>False EOF",
+                    "$> :Linear algebra: == :Unknown category: =>False EOF",
+                    "$> :Linear algebra: == :Linear algebra: =>True EOF",
+                    "$> :Probability and statistics: == :Probabilities and statistics: =>True EOF",
+                    "$> :PROBABILITY AND STATISTICS: == :Probability and statistics: =>True EOF",
+                    "$> :PROBABILITY AND STATISTICS: == :UNKNOWN CATEGORY: =>False EOF",
+                ]
+            ),
+            pre_processors=[OptionsPreProcessor()],
+            post_processors=[StripPostProcessor()],
+            stop=["EOF"],
+            **kwargs,
+        )
         def _func(_, other) -> bool:
             pass
+
         return _func(self, other)
 
     def forward(self, **kwargs) -> str:
-        @core.few_shot(prompt="Classify the user query to the mathematical classes:\n",
-                     examples=[],
-                     pre_processors=[ProblemClassifierPreProcessor()],
-                     post_processors=[StripPostProcessor()],
-                     stop=['EOF'], **kwargs)
+        @core.few_shot(
+            prompt="Classify the user query to the mathematical classes:\n",
+            examples=[],
+            pre_processors=[ProblemClassifierPreProcessor()],
+            post_processors=[StripPostProcessor()],
+            stop=["EOF"],
+            **kwargs,
+        )
         def _func(_) -> str:
             pass
 
@@ -109,34 +119,40 @@ class ProblemClassifier(Expression):
 
 class FormulaCheckerPreProcessor(PreProcessor):
     def __call__(self, argument):
-        return f'$> {argument.prop.instance!s} =>'
+        return f"$> {argument.prop.instance!s} =>"
 
 
 class FormulaChecker(Expression):
     def forward(self, **kwargs) -> bool:
-        @core.few_shot(prompt="Is the following statement in an explicit formula form without natural language text?:\n",
-                     examples=Prompt([
-                         '$> 2 + 2 * 2 =>True EOF',
-                         '$> x + 2 = 3 =>True EOF',
-                         '$> Set of all natural numbers =>False EOF',
-                         '$> Probability of drawing a red ball =>False EOF',
-                         '$> (a + b) * (a - b) =>True EOF',
-                         '$> Add the square root of nine to the square root of x =>False EOF',
-                         '$> Five plus two equals seven =>False EOF',
-                         '$> 5 + 2 = 7 =>True EOF',
-                         '$> x is seven =>False EOF',
-                         '$> x = 7 =>True EOF',
-                         '$> Anna has two apples. She gives one to her brother. How many apples does Anna have now? =>False EOF',
-                         '$> 0.447662 =>True EOF',
-                         '$> Subtract the x from y squared =>False EOF',
-                         '$> The sum of the first n natural numbers =>False EOF',
-                         '$> Sum[x=5, {i=0, n=10}] =>True EOF',
-                     ]),
-                     pre_processors=[FormulaCheckerPreProcessor()],
-                     post_processors=[StripPostProcessor()],
-                     stop=['EOF'], **kwargs)
+        @core.few_shot(
+            prompt="Is the following statement in an explicit formula form without natural language text?:\n",
+            examples=Prompt(
+                [
+                    "$> 2 + 2 * 2 =>True EOF",
+                    "$> x + 2 = 3 =>True EOF",
+                    "$> Set of all natural numbers =>False EOF",
+                    "$> Probability of drawing a red ball =>False EOF",
+                    "$> (a + b) * (a - b) =>True EOF",
+                    "$> Add the square root of nine to the square root of x =>False EOF",
+                    "$> Five plus two equals seven =>False EOF",
+                    "$> 5 + 2 = 7 =>True EOF",
+                    "$> x is seven =>False EOF",
+                    "$> x = 7 =>True EOF",
+                    "$> Anna has two apples. She gives one to her brother. How many apples does Anna have now? =>False EOF",
+                    "$> 0.447662 =>True EOF",
+                    "$> Subtract the x from y squared =>False EOF",
+                    "$> The sum of the first n natural numbers =>False EOF",
+                    "$> Sum[x=5, {i=0, n=10}] =>True EOF",
+                ]
+            ),
+            pre_processors=[FormulaCheckerPreProcessor()],
+            post_processors=[StripPostProcessor()],
+            stop=["EOF"],
+            **kwargs,
+        )
         def _func(_) -> bool:
             pass
+
         return _func(self)
 
 
@@ -149,27 +165,33 @@ class FormulaChecker(Expression):
 
 class FormulaWriterPreProcessor(PreProcessor):
     def __call__(self, argument):
-        return f'$> {argument.prop.instance!s} =>'
+        return f"$> {argument.prop.instance!s} =>"
 
 
 class FormulaWriter(Expression):
     def forward(self, **kwargs) -> str:
-        @core.few_shot(prompt="Rewrite the following natural language statement in a mathematical formula or higher-order logic statement to be solved by Mathematica:\n",
-                     examples=Prompt([
-                         '$> Add 5 plus 3 =>5 + 3 EOF',
-                         '$> Seventy plus twenty =>70 + 20 EOF',
-                         '$> Divide 5 by three =>5 / 3 EOF',
-                         '$> The square root of pi plus x. =>Sqrt[Pi + x] EOF',
-                         '$> Eight point five six seven one four two seven =>8.5671427 EOF',
-                         '$> Give a solution for a quadratic equation x^2 + 2x + 1 =>Solve[x^2 + 2x + 1 ==0, x] EOF',
-                         '$> Sum x n times from i equals 0 to n equals 10. x is equals to 5. =>Sum[x=5, {i=0, n=10}] EOF',
-                         '$> Multiply the first statement in brackets a plus b times the second term in brackets c minus d =>(a + b) * (c - d) EOF'
-                     ]),
-                     pre_processors=[FormulaWriterPreProcessor()],
-                     post_processors=[StripPostProcessor()],
-                     stop=['EOF'], **kwargs)
+        @core.few_shot(
+            prompt="Rewrite the following natural language statement in a mathematical formula or higher-order logic statement to be solved by Mathematica:\n",
+            examples=Prompt(
+                [
+                    "$> Add 5 plus 3 =>5 + 3 EOF",
+                    "$> Seventy plus twenty =>70 + 20 EOF",
+                    "$> Divide 5 by three =>5 / 3 EOF",
+                    "$> The square root of pi plus x. =>Sqrt[Pi + x] EOF",
+                    "$> Eight point five six seven one four two seven =>8.5671427 EOF",
+                    "$> Give a solution for a quadratic equation x^2 + 2x + 1 =>Solve[x^2 + 2x + 1 ==0, x] EOF",
+                    "$> Sum x n times from i equals 0 to n equals 10. x is equals to 5. =>Sum[x=5, {i=0, n=10}] EOF",
+                    "$> Multiply the first statement in brackets a plus b times the second term in brackets c minus d =>(a + b) * (c - d) EOF",
+                ]
+            ),
+            pre_processors=[FormulaWriterPreProcessor()],
+            post_processors=[StripPostProcessor()],
+            stop=["EOF"],
+            **kwargs,
+        )
         def _func(_) -> str:
             pass
+
         return _func(self)
 
 
@@ -199,17 +221,19 @@ _value_obj_ = problem_statement
 
 class SATSolver(Expression):
     def forward(self, code):
-        assert z3 is not None, "The z3 library is not installed. Please install it using `pip install 'symbolicai[solver]'` and try again."
+        assert z3 is not None, (
+            "The z3 library is not installed. Please install it using `pip install 'symbolicai[solver]'` and try again."
+        )
         # Create the execution template
-        runner    = Execute(enclosure=True)
+        runner = Execute(enclosure=True)
         # Execute the code
         statement = runner(code)
         # Create a new solver instance
-        S         = z3.Solver()
+        S = z3.Solver()
         # Create a new query
-        query     = statement['locals']['_output_'](S)
+        query = statement["locals"]["_output_"](S)
         # Check if the query can be solved
-        r         = S.check()
+        r = S.check()
         # Print the solution
         if r == z3.sat:
             # Get the model
@@ -232,8 +256,8 @@ class Solver(Expression):
         super().__init__(**kwargs)
         self.sym_return_type = Solver
         self.solver = SATSolver()
-        self.conv   = Conversation(init=LOGIC_TEMPLATE)
-        self.pp     = CodeExtractPostProcessor()
+        self.conv = Conversation(init=LOGIC_TEMPLATE)
+        self.pp = CodeExtractPostProcessor()
 
     def rewrite_formula(self, sym, **kwargs):
         formula = sym
@@ -247,16 +271,20 @@ class Solver(Expression):
         classifier = ProblemClassifier(sym)
         problem = classifier(**kwargs)
 
-        if problem == 'Arithmetics formula' or problem == 'Equations':
+        if problem == "Arithmetics formula" or problem == "Equations":
             formula = self.rewrite_formula(sym, **kwargs)
             UserMessage(str(formula))
-        elif problem == 'Implication and logical expressions':
-            res     = self.conv(sym, **kwargs)
-            code    = self.pp(str(res), None, tag="python")
-            formula = self.solver(code, lambda: 'German')
+        elif problem == "Implication and logical expressions":
+            res = self.conv(sym, **kwargs)
+            code = self.pp(str(res), None, tag="python")
+            formula = self.solver(code, lambda: "German")
             UserMessage(str(formula))
-        elif problem == 'Probability and statistics' or problem == 'Linear algebra' or problem == 'Linguistic problem with relations':
-            UserMessage('This feature is not yet implemented.', raise_with=NotImplementedError)
+        elif (
+            problem == "Probability and statistics"
+            or problem == "Linear algebra"
+            or problem == "Linguistic problem with relations"
+        ):
+            UserMessage("This feature is not yet implemented.", raise_with=NotImplementedError)
         else:
             return "Sorry, something went wrong. Please check if your backend is available and try again or report an issue to the devs. :("
         return None
@@ -271,8 +299,8 @@ def process_query(args) -> None:
 
 def run() -> None:
     # All the logic of argparse goes in this function
-    parser = argparse.ArgumentParser(description='Welcome to the Symbolic<AI/> Shell support tool!')
-    parser.add_argument('query', type=str, help='The prompt for the shell query.')
+    parser = argparse.ArgumentParser(description="Welcome to the Symbolic<AI/> Shell support tool!")
+    parser.add_argument("query", type=str, help="The prompt for the shell query.")
 
     args = parser.parse_args()
     process_query(args)

symai/extended/summarizer.py

@@ -1,4 +1,3 @@
-
 from ..components import Clean, Outline, Sequence, Stream, Translate
 from ..symbol import Expression, Symbol
 
@@ -9,12 +8,14 @@ class Summarizer(Expression):
             filters = []
         super().__init__(**kwargs)
         filters = filters if isinstance(filters, (list, tuple)) else [filters]
-        self.data_stream = Stream(Sequence(
-            Clean(),
-            Translate(),
-            Outline(),
-            *filters,
-        ))
+        self.data_stream = Stream(
+            Sequence(
+                Clean(),
+                Translate(),
+                Outline(),
+                *filters,
+            )
+        )
 
     def forward(self, sym: Symbol, **kwargs) -> Symbol:
         vals = list(self.data_stream(sym, **kwargs))

symai/extended/taypan_interpreter.py

@@ -9,15 +9,12 @@ from ..symbol import Expression, Symbol
 def create_template():
     package_path = pathlib.Path(__file__).parent.absolute()
 
-
-    with (package_path / 'symbol.py').open() as f:
+    with (package_path / "symbol.py").open() as f:
         SYMBOL_API = f.read()
 
-
-    with (package_path / 'components.py').open() as f:
+    with (package_path / "components.py").open() as f:
         COMPONENTS_API = f.read()
 
-
     return f"""[Description]
     You are a programming language re-writing system from Taypan (high-level general-purpose programming language based on neuro-symbolic virtual machine) to Python interpreter, analogous to the relation between Scala and Java is the relation of Taypan to Python.
 
@@ -113,7 +110,7 @@ def create_template():
 
 class TaypanPreProcessor(PreProcessor):
     def __call__(self, argument):
-        return f'```taypan\n{argument.args[0]!s}\n =>'
+        return f"```taypan\n{argument.args[0]!s}\n =>"
 
 
 class TaypanInterpreter(Expression):
@@ -127,9 +124,13 @@ class TaypanInterpreter(Expression):
         self.description = create_template()
 
     def forward(self, sym: Symbol, **kwargs) -> Symbol:
-        @zero_shot(prompt="Translate the Taypan code to Python code:\n",
-                   pre_processors=[TaypanPreProcessor()],
-                   post_processors=[CodeExtractPostProcessor()], **kwargs)
+        @zero_shot(
+            prompt="Translate the Taypan code to Python code:\n",
+            pre_processors=[TaypanPreProcessor()],
+            post_processors=[CodeExtractPostProcessor()],
+            **kwargs,
+        )
         def _func(_, text) -> str:
             pass
+
         return _func(self, sym)

symai/extended/vectordb.py

@@ -21,8 +21,8 @@ from .metrics import (
     ranking_algorithm_sort,
 )
 
-logging.getLogger('sentence_transformers').setLevel(logging.WARNING)
-logging.getLogger('datasets').setLevel(logging.WARNING)
+logging.getLogger("sentence_transformers").setLevel(logging.WARNING)
+logging.getLogger("datasets").setLevel(logging.WARNING)
 
 
 class VectorDB(Expression):
@@ -35,6 +35,7 @@ class VectorDB(Expression):
     _default_top_k: ClassVar[int] = 5
     _default_storage_path: ClassVar[Path] = HOME_PATH / "localdb"
     _default_index_name: ClassVar[str] = "dataindex"
+
     def __init__(
         self,
         documents=_default_documents,
@@ -46,7 +47,7 @@ class VectorDB(Expression):
         index_dims=_default_index_dims,
         top_k=_default_top_k,
         index_name=_default_index_name,
-        **kwargs
+        **kwargs,
     ):
         super().__init__(**kwargs)
         self.config = deepcopy(SYMAI_CONFIG)
@@ -77,7 +78,10 @@ class VectorDB(Expression):
         elif "adams" in similarity_metric:
             self.similarity_metric = adams_similarity
         else:
-            UserMessage("Similarity metric not supported. Please use either 'dot', 'cosine', 'euclidean', 'adams', or 'derrida'.", raise_with=ValueError)
+            UserMessage(
+                "Similarity metric not supported. Please use either 'dot', 'cosine', 'euclidean', 'adams', or 'derrida'.",
+                raise_with=ValueError,
+            )
 
         if load_on_init:
             if isinstance(load_on_init, (str, Path)):
@@ -87,8 +91,11 @@ class VectorDB(Expression):
                 self.load()
 
     def _init_embedding_model(self):
-        if self.config['EMBEDDING_ENGINE_API_KEY'] is None or  self.config['EMBEDDING_ENGINE_API_KEY'] == '':
-            self.model = Interface('ExtensityAI/embeddings') # default to local model
+        if (
+            self.config["EMBEDDING_ENGINE_API_KEY"] is None
+            or self.config["EMBEDDING_ENGINE_API_KEY"] == ""
+        ):
+            self.model = Interface("ExtensityAI/embeddings")  # default to local model
         else:
             self.model = lambda x: Symbol(x).embedding
 
@@ -158,7 +165,10 @@ class VectorDB(Expression):
         if len(documents) == 0:
             return []
         texts = self._to_texts(documents, key)
-        batches = [texts[index : index + self.batch_size] for index in range(0, len(texts), self.batch_size)]
+        batches = [
+            texts[index : index + self.batch_size]
+            for index in range(0, len(texts), self.batch_size)
+        ]
         embeddings = []
         for batch in batches:
             embeddings.extend(self._embed_batch(batch))
@@ -186,8 +196,7 @@ class VectorDB(Expression):
                 )
             ]
         return [
-            {"document": document, "index": index}
-            for index, document in enumerate(self.documents)
+            {"document": document, "index": index} for index, document in enumerate(self.documents)
         ]
 
     def add(self, documents, vectors=None):
@@ -222,7 +231,7 @@ class VectorDB(Expression):
             A vector to add to the database.
 
         """
-        vector = (vector if vector is not None else self.embedding_function([document])[0])
+        vector = vector if vector is not None else self.embedding_function([document])[0]
         if self.vectors is None:
             self.vectors = np.empty((0, len(vector)), dtype=np.float32)
         elif len(vector) != self.vectors.shape[1]:
@@ -269,7 +278,7 @@ class VectorDB(Expression):
         Clears the database.
 
         """
-        self.vectors   = None
+        self.vectors = None
         self.documents = []
 
     def save(self, storage_file: str | None = None):
@@ -296,7 +305,7 @@ class VectorDB(Expression):
             with storage_file.open("wb") as f:
                 pickle.dump(data, f)
 
-    def load(self, storage_file : str | None = None):
+    def load(self, storage_file: str | None = None):
         """
         Loads the database from a file.
 
@@ -326,7 +335,7 @@ class VectorDB(Expression):
         self.vectors = data["vectors"].astype(np.float32) if data["vectors"] is not None else None
         self.documents = data["documents"]
 
-    def purge(self, index_name : str):
+    def purge(self, index_name: str):
         """
         Purges the database file from your machine, but does not delete the database from memory.
         Use the `clear` method to clear the database from memory.
@@ -371,7 +380,9 @@ class VectorDB(Expression):
             A list of results.
 
         """
-        assert self.vectors is not None, "Error: Cannot query the database without prior insertion / initialization."
+        assert self.vectors is not None, (
+            "Error: Cannot query the database without prior insertion / initialization."
+        )
         top_k = top_k or self.index_top_k
         query_vector = self.embedding_function([query])[0] if vector is None else vector
         if isinstance(query_vector, list):
@@ -380,5 +391,7 @@ class VectorDB(Expression):
             self.vectors, query_vector, top_k=top_k, metric=self.similarity_metric
         )
         if return_similarities:
-            return list(zip([self.documents[index] for index in ranked_results], similarities, strict=False))
+            return list(
+                zip([self.documents[index] for index in ranked_results], similarities, strict=False)
+            )
         return [self.documents[index] for index in ranked_results]

symai/formatter/formatter.py

@@ -21,16 +21,16 @@ class ParagraphFormatter(Expression):
 
     def split_files(self, input_text=""):
         input_ = input_text.strip()
-        if input_.startswith('# ----[FILE_START]') and '# ----[FILE_END]' in input_:
+        if input_.startswith("# ----[FILE_START]") and "# ----[FILE_END]" in input_:
             self._has_file_start = True
             # split text file-wise and create a map of file names and their contents
             files = {}
-            split_text = input_.split('# ----[FILE_START]')
+            split_text = input_.split("# ----[FILE_START]")
             for _i, file in enumerate(split_text):
                 if not file.strip():
                     continue
-                _, content_file = file.split('[FILE_CONTENT]:')
-                content, file_name = content_file.split('# ----[FILE_END]')
+                _, content_file = file.split("[FILE_CONTENT]:")
+                content, file_name = content_file.split("# ----[FILE_END]")
                 files[file_name.strip()] = content.strip()
         else:
             files = {"": input_}
@@ -40,8 +40,10 @@ class ParagraphFormatter(Expression):
         if file_name and self._has_file_start:
             header = f"# ----[FILE_START]<PART{part}/{total_parts}>{file_name}[FILE_CONTENT]:\n"
             footer = f"\n# ----[FILE_END]{file_name}\n"
-            if '[FILE_CONTENT]:' in paragraph: # TODO: remove this if statement after fixing the bug
-                paragraph = paragraph.split('[FILE_CONTENT]:')[-1].strip()
+            if (
+                "[FILE_CONTENT]:" in paragraph
+            ):  # TODO: remove this if statement after fixing the bug
+                paragraph = paragraph.split("[FILE_CONTENT]:")[-1].strip()
             paragraph = header + paragraph + footer
         return paragraph
 
@@ -67,7 +69,12 @@ class ParagraphFormatter(Expression):
             input_ = file_content.strip()
             split_text = self.NEWLINES_RE.split(input_)
 
-            par = [self._add_header_footer(p, file_name, part=i+1, total_parts=len(split_text)) + "\n" for i, p in enumerate(split_text) if p.strip()]
+            par = [
+                self._add_header_footer(p, file_name, part=i + 1, total_parts=len(split_text))
+                + "\n"
+                for i, p in enumerate(split_text)
+                if p.strip()
+            ]
             # p + "\n" ensures that all lines in the paragraph end with a newline
             # p.strip() == True if paragraph has other characters than whitespace
 
@@ -85,14 +92,20 @@ class ParagraphFormatter(Expression):
                 # n splits
                 total_parts = (len(words) // max_length + 1) * self._get_total_parts(text)
                 for p, i in enumerate(range(0, len(words), max_length)):
-                    paragraph = ' '.join(words[i:i + max_length])
-                    paragraphs.append(self._add_header_footer(paragraph, file_name, part=p+1, total_parts=total_parts) + "\n")
+                    paragraph = " ".join(words[i : i + max_length])
+                    paragraphs.append(
+                        self._add_header_footer(
+                            paragraph, file_name, part=p + 1, total_parts=total_parts
+                        )
+                        + "\n"
+                    )
             else:
                 paragraphs.append(text)
         return paragraphs
 
-    @core_ext.bind(engine='embedding', property='max_tokens')
-    def _max_tokens(self): pass
+    @core_ext.bind(engine="embedding", property="max_tokens")
+    def _max_tokens(self):
+        pass
 
     def split_max_tokens_exceeded(self, input_text: List[str], token_ratio=0.5):
         paragraphs = []
@@ -107,8 +120,13 @@ class ParagraphFormatter(Expression):
                 text_len_ = len(str(text)) // splits_
                 total_parts = (text_len_ + 1) * self._get_total_parts(text)
                 for i in range(splits_):
-                    paragraph = text[i * text_len_:(i + 1) * text_len_]
-                    paragraphs.append(self._add_header_footer(paragraph, file_name, part=i+1, total_parts=total_parts) + "\n")
+                    paragraph = text[i * text_len_ : (i + 1) * text_len_]
+                    paragraphs.append(
+                        self._add_header_footer(
+                            paragraph, file_name, part=i + 1, total_parts=total_parts
+                        )
+                        + "\n"
+                    )
             else:
                 paragraphs.append(text)
         return paragraphs
@@ -126,7 +144,9 @@ class ParagraphFormatter(Expression):
 class SentenceFormatter(Expression):
     def __init__(self, value=None, **kwargs):
         super().__init__(value, **kwargs)
-        self.SENTENCES_RE = re.compile(r"[.!?]\n*|[\n]{1,}")  # Sentence ending characters followed by newlines
+        self.SENTENCES_RE = re.compile(
+            r"[.!?]\n*|[\n]{1,}"
+        )  # Sentence ending characters followed by newlines
 
     def split_sentences(self, input_text=""):
         input_ = input_text.strip()
@@ -161,13 +181,7 @@ class RegexFormatter(Expression):
 
 
 class TextContainerFormatter(Expression):
-    def __init__(
-            self,
-            value: Any = None,
-            key: str ="text",
-            text_split: int = 4,
-            **kwargs
-        ):
+    def __init__(self, value: Any = None, key: str = "text", text_split: int = 4, **kwargs):
         super().__init__(value, **kwargs)
         self.key = key
         self.text_split = text_split
@@ -179,7 +193,7 @@ class TextContainerFormatter(Expression):
         chunks = [text for container in tqdm(containers) for text in self._chunk(container)]
         return self._to_symbol(chunks)
 
-    def _chunk(self, container: 'TextContainer') -> List[str]:
+    def _chunk(self, container: "TextContainer") -> List[str]:
         text = container.text
         step = len(text) // self.text_split
         splits = []
@@ -189,16 +203,10 @@ class TextContainerFormatter(Expression):
                 # Unify the last chunk with the previous one if necessary
                 splits.append(self._as_str(text[i:], container))
                 break
-            splits.append(self._as_str(text[i:i+step], container))
+            splits.append(self._as_str(text[i : i + step], container))
             i += step
             c += 1
         return splits
 
-    def _as_str(self, text: str, container: 'TextContainer') -> str:
-        return (
-            '---\n'
-            f"id: {container.id}\n"
-            f"page: {container.page}\n"
-            '---\n'
-            f"{text}"
-        )
+    def _as_str(self, text: str, container: "TextContainer") -> str:
+        return f"---\nid: {container.id}\npage: {container.page}\n---\n{text}"