spark-nlp 2.6.3rc1__py2.py3-none-any.whl → 6.2.1__py2.py3-none-any.whl

sparknlp/base/multi_document_assembler.py

@@ -0,0 +1,164 @@
+#  Copyright 2017-2022 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+from pyspark import keyword_only
+from pyspark.ml.param import TypeConverters, Params, Param
+
+from sparknlp.common import AnnotatorType
+from sparknlp.internal import AnnotatorTransformer
+
+
+class MultiDocumentAssembler(AnnotatorTransformer):
+    """Prepares data into a format that is processable by Spark NLP.
+
+    This is the entry point for every Spark NLP pipeline. The
+    `MultiDocumentAssembler` can read either a ``String`` column or an
+    ``Array[String]``. Additionally, :meth:`.setCleanupMode` can be used to
+    pre-process the text (Default: ``disabled``). For possible options please
+    refer the parameters section.
+
+    For more extended examples on document pre-processing see the
+    `Examples <https://github.com/JohnSnowLabs/spark-nlp/blob/master/examples/python/annotation/text/english/document-assembler/Loading_Multiple_Documents.ipynb>`__.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``NONE``               ``DOCUMENT``
+    ====================== ======================
+
+    Parameters
+    ----------
+    inputCols: str or List[str]
+        Input column name.
+    outputCols: str or List[str]
+        Output column name.
+    idCol: str
+        Name of String type column for row id.
+    metadataCol: str
+        Name of Map type column with metadata information
+    cleanupMode: str
+        How to cleanup the document , by default disabled.
+        Possible values: ``disabled, inplace, inplace_full, shrink, shrink_full,
+        each, each_full, delete_full``
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from pyspark.ml import Pipeline
+    >>> data = spark.createDataFrame([["Spark NLP is an open-source text processing library."], ["Spark NLP is a state-of-the-art Natural Language Processing library built on top of Apache Spark"]]).toDF("text", "text2")
+    >>> documentAssembler = MultiDocumentAssembler().setInputCols(["text", "text2"]).setOutputCols(["document1", "document2"])
+    >>> result = documentAssembler.transform(data)
+    >>> result.select("document1").show(truncate=False)
+    +----------------------------------------------------------------------------------------------+
+    |document1                                                                                      |
+    +----------------------------------------------------------------------------------------------+
+    |[[document, 0, 51, Spark NLP is an open-source text processing library., [sentence -> 0], []]]|
+    +----------------------------------------------------------------------------------------------+
+    >>> result.select("document1").printSchema()
+    root
+    |-- document: array (nullable = True)
+    |    |-- element: struct (containsNull = True)
+    |    |    |-- annotatorType: string (nullable = True)
+    |    |    |-- begin: integer (nullable = False)
+    |    |    |-- end: integer (nullable = False)
+    |    |    |-- result: string (nullable = True)
+    |    |    |-- metadata: map (nullable = True)
+    |    |    |    |-- key: string
+    |    |    |    |-- value: string (valueContainsNull = True)
+    |    |    |-- embeddings: array (nullable = True)
+    |    |    |    |-- element: float (containsNull = False)
+    """
+
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    inputCols = Param(Params._dummy(), "inputCols", "input annotations", typeConverter=TypeConverters.toListString)
+    outputCols = Param(Params._dummy(), "outputCols", "output finished annotation cols", typeConverter=TypeConverters.toListString)
+    idCol = Param(Params._dummy(), "idCol", "column for setting an id to such string in row", typeConverter=TypeConverters.toString)
+    metadataCol = Param(Params._dummy(), "metadataCol", "String to String map column to use as metadata", typeConverter=TypeConverters.toString)
+    cleanupMode = Param(Params._dummy(), "cleanupMode", "possible values: disabled, inplace, inplace_full, shrink, shrink_full, each, each_full, delete_full", typeConverter=TypeConverters.toString)
+    name = 'MultiDocumentAssembler'
+
+    @keyword_only
+    def __init__(self):
+        super(MultiDocumentAssembler, self).__init__(classname="com.johnsnowlabs.nlp.MultiDocumentAssembler")
+        self._setDefault(cleanupMode='disabled')
+
+    @keyword_only
+    def setParams(self):
+        kwargs = self._input_kwargs
+        return self._set(**kwargs)
+
+    def setInputCols(self, *value):
+        """Sets column names of input annotations.
+
+        Parameters
+        ----------
+        *value : List[str]
+            Input columns for the annotator
+        """
+        if len(value) == 1 and type(value[0]) == list:
+            return self._set(inputCols=value[0])
+        else:
+            return self._set(inputCols=list(value))
+
+    def setOutputCols(self, *value):
+        """Sets column names of output annotations.
+
+        Parameters
+        ----------
+        *value : List[str]
+            List of output columns
+        """
+        if len(value) == 1 and type(value[0]) == list:
+            return self._set(outputCols=value[0])
+        else:
+            return self._set(outputCols=list(value))
+
+    def setIdCol(self, value):
+        """Sets name of string type column for row id.
+
+        Parameters
+        ----------
+        value : str
+            Name of the Id Column
+        """
+        return self._set(idCol=value)
+
+    def setMetadataCol(self, value):
+        """Sets name for Map type column with metadata information.
+
+        Parameters
+        ----------
+        value : str
+            Name of the metadata column
+        """
+        return self._set(metadataCol=value)
+
+    def setCleanupMode(self, value):
+        """Sets how to cleanup the document, by default disabled.
+        Possible values: ``disabled, inplace, inplace_full, shrink, shrink_full,
+        each, each_full, delete_full``
+
+        Parameters
+        ----------
+        value : str
+            Cleanup mode
+        """
+        if value.strip().lower() not in ['disabled', 'inplace', 'inplace_full', 'shrink', 'shrink_full', 'each', 'each_full', 'delete_full']:
+            raise Exception("Cleanup mode possible values: disabled, inplace, inplace_full, shrink, shrink_full, each, each_full, delete_full")
+        return self._set(cleanupMode=value)
+
+    def getOutputCols(self):
+        """Gets output columns name of annotations."""
+        return self.getOrDefault(self.outputCols)

sparknlp/base/prompt_assembler.py

@@ -0,0 +1,207 @@
+#  Copyright 2017-2024 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for the PromptAssembler."""
+
+from pyspark import keyword_only
+from pyspark.ml.param import TypeConverters, Params, Param
+
+from sparknlp.common import AnnotatorType
+from sparknlp.internal import AnnotatorTransformer
+
+
+class PromptAssembler(AnnotatorTransformer):
+    """Assembles a sequence of messages into a single string using a template. These strings can then
+    be used as prompts for large language models.
+
+    This annotator expects an array of two-tuples as the type of the input column (one array of
+    tuples per row). The first element of the tuples should be the role and the second element is
+    the text of the message. Possible roles are "system", "user" and "assistant".
+
+    An assistant header can be added to the end of the generated string by using
+    ``setAddAssistant(True)``.
+
+    At the moment, this annotator uses llama.cpp as a backend to parse and apply the templates.
+    llama.cpp uses basic pattern matching to determine the type of the template, then applies a
+    basic version of the template to the messages. This means that more advanced templates are not
+    supported.
+
+    For an extended example see the
+    `example notebook <https://github.com/JohnSnowLabs/spark-nlp/blob/master/examples/python/llama.cpp/PromptAssember_with_AutoGGUFModel.ipynb>`__.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``NONE``               ``DOCUMENT``
+    ====================== ======================
+
+    Parameters
+    ----------
+    inputCol
+        Input column name
+    outputCol
+        Output column name
+    chatTemplate
+        Template used for the chat
+    addAssistant
+        Whether to add an assistant header to the end of the generated string
+
+    Examples
+    --------
+    >>> from sparknlp.base import *
+    >>> messages = [
+    ...     [
+    ...         ("system", "You are a helpful assistant."),
+    ...         ("assistant", "Hello there, how can I help you?"),
+    ...         ("user", "I need help with organizing my room."),
+    ...     ]
+    ... ]
+    >>> df = spark.createDataFrame([messages]).toDF("messages")
+    >>> template = (
+    ...     "{{- bos_token }} {%- if custom_tools is defined %} {%- set tools = custom_tools %} {%- "
+    ...     "endif %} {%- if not tools_in_user_message is defined %} {%- set tools_in_user_message = true %} {%- "
+    ...     'endif %} {%- if not date_string is defined %} {%- set date_string = "26 Jul 2024" %} {%- endif %} '
+    ...     "{%- if not tools is defined %} {%- set tools = none %} {%- endif %} {#- This block extracts the "
+    ...     "system message, so we can slot it into the right place. #} {%- if messages[0]['role'] == 'system' %}"
+    ...     " {%- set system_message = messages[0]['content']|trim %} {%- set messages = messages[1:] %} {%- else"
+    ...     ' %} {%- set system_message = "" %} {%- endif %} {#- System message + builtin tools #} {{- '
+    ...     '"<|start_header_id|>system<|end_header_id|>\\n\\n" }} {%- if builtin_tools is defined or tools is '
+    ...     'not none %} {{- "Environment: ipython\\n" }} {%- endif %} {%- if builtin_tools is defined %} {{- '
+    ...     '"Tools: " + builtin_tools | reject(\\'equalto\', \\'code_interpreter\\') | join(", ") + "\\n\\n"}} '
+    ...     '{%- endif %} {{- "Cutting Knowledge Date: December 2023\\n" }} {{- "Today Date: " + date_string '
+    ...     '+ "\\n\\n" }} {%- if tools is not none and not tools_in_user_message %} {{- "You have access to '
+    ...     'the following functions. To call a function, please respond with JSON for a function call." }} {{- '
+    ...     '\\'Respond in the format {"name": function name, "parameters": dictionary of argument name and its'
+    ...     ' value}.\\' }} {{- "Do not use variables.\\n\\n" }} {%- for t in tools %} {{- t | tojson(indent=4) '
+    ...     '}} {{- "\\n\\n" }} {%- endfor %} {%- endif %} {{- system_message }} {{- "<|eot_id|>" }} {#- '
+    ...     "Custom tools are passed in a user message with some extra guidance #} {%- if tools_in_user_message "
+    ...     "and not tools is none %} {#- Extract the first user message so we can plug it in here #} {%- if "
+    ...     "messages | length != 0 %} {%- set first_user_message = messages[0]['content']|trim %} {%- set "
+    ...     'messages = messages[1:] %} {%- else %} {{- raise_exception("Cannot put tools in the first user '
+    ...     "message when there's no first user message!\\") }} {%- endif %} {{- "
+    ...     "'<|start_header_id|>user<|end_header_id|>\\n\\n' -}} {{- \\"Given the following functions, please "
+    ...     'respond with a JSON for a function call " }} {{- "with its proper arguments that best answers the '
+    ...     'given prompt.\\n\\n" }} {{- \\'Respond in the format {"name": function name, "parameters": '
+    ...     'dictionary of argument name and its value}.\\' }} {{- "Do not use variables.\\n\\n" }} {%- for t in '
+    ...     'tools %} {{- t | tojson(indent=4) }} {{- "\\n\\n" }} {%- endfor %} {{- first_user_message + '
+    ...     "\\"<|eot_id|>\\"}} {%- endif %} {%- for message in messages %} {%- if not (message.role == 'ipython' "
+    ...     "or message.role == 'tool' or 'tool_calls' in message) %} {{- '<|start_header_id|>' + message['role']"
+    ...     " + '<|end_header_id|>\\n\\n'+ message['content'] | trim + '<|eot_id|>' }} {%- elif 'tool_calls' in "
+    ...     'message %} {%- if not message.tool_calls|length == 1 %} {{- raise_exception("This model only '
+    ...     'supports single tool-calls at once!") }} {%- endif %} {%- set tool_call = message.tool_calls[0]'
+    ...     ".function %} {%- if builtin_tools is defined and tool_call.name in builtin_tools %} {{- "
+    ...     "'<|start_header_id|>assistant<|end_header_id|>\\n\\n' -}} {{- \\"<|python_tag|>\\" + tool_call.name + "
+    ...     '".call(" }} {%- for arg_name, arg_val in tool_call.arguments | items %} {{- arg_name + \\'="\\' + '
+    ...     'arg_val + \\'"\\' }} {%- if not loop.last %} {{- ", " }} {%- endif %} {%- endfor %} {{- ")" }} {%- '
+    ...     "else %} {{- '<|start_header_id|>assistant<|end_header_id|>\\n\\n' -}} {{- '{\\"name\": \\"' + "
+    ...     'tool_call.name + \\'", \\' }} {{- \\'"parameters": \\' }} {{- tool_call.arguments | tojson }} {{- "}" '
+    ...     "}} {%- endif %} {%- if builtin_tools is defined %} {#- This means we're in ipython mode #} {{- "
+    ...     '"<|eom_id|>" }} {%- else %} {{- "<|eot_id|>" }} {%- endif %} {%- elif message.role == "tool" '
+    ...     'or message.role == "ipython" %} {{- "<|start_header_id|>ipython<|end_header_id|>\\n\\n" }} {%- '
+    ...     "if message.content is mapping or message.content is iterable %} {{- message.content | tojson }} {%- "
+    ...     'else %} {{- message.content }} {%- endif %} {{- "<|eot_id|>" }} {%- endif %} {%- endfor %} {%- if '
+    ...     "add_generation_prompt %} {{- '<|start_header_id|>assistant<|end_header_id|>\\n\\n' }} {%- endif %} "
+    ... )
+    >>> prompt_assembler = (
+    ...     PromptAssembler()
+    ...     .setInputCol("messages")
+    ...     .setOutputCol("prompt")
+    ...     .setChatTemplate(template)
+    ... )
+    >>> prompt_assembler.transform(df).select("prompt.result").show(truncate=False)
+    +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |result                                                                                                                                                                                                                                                                                                                      |
+    +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |[<|start_header_id|>system<|end_header_id|>\\n\\nYou are a helpful assistant.<|eot_id|><|start_header_id|>assistant<|end_header_id|>\\n\\nHello there, how can I help you?<|eot_id|><|start_header_id|>user<|end_header_id|>\\n\\nI need help with organizing my room.<|eot_id|><|start_header_id|>assistant<|end_header_id|>\\n\\n]|
+    +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    """
+
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    inputCol = Param(
+        Params._dummy(),
+        "inputCol",
+        "input column name",
+        typeConverter=TypeConverters.toString,
+    )
+    outputCol = Param(
+        Params._dummy(),
+        "outputCol",
+        "output column name",
+        typeConverter=TypeConverters.toString,
+    )
+    chatTemplate = Param(
+        Params._dummy(),
+        "chatTemplate",
+        "Template used for the chat",
+        typeConverter=TypeConverters.toString,
+    )
+    addAssistant = Param(
+        Params._dummy(),
+        "addAssistant",
+        "Whether to add an assistant header to the end of the generated string",
+        typeConverter=TypeConverters.toBoolean,
+    )
+    name = "PromptAssembler"
+
+    @keyword_only
+    def __init__(self):
+        super(PromptAssembler, self).__init__(
+            classname="com.johnsnowlabs.nlp.PromptAssembler"
+        )
+        self._setDefault(outputCol="prompt", addAssistant=True)
+
+    @keyword_only
+    def setParams(self):
+        kwargs = self._input_kwargs
+        return self._set(**kwargs)
+
+    def setInputCol(self, value):
+        """Sets input column name.
+
+        Parameters
+        ----------
+        value : str
+            Name of the input column
+        """
+        return self._set(inputCol=value)
+
+    def setOutputCol(self, value):
+        """Sets output column name.
+
+        Parameters
+        ----------
+        value : str
+            Name of the Output Column
+        """
+        return self._set(outputCol=value)
+
+    def setChatTemplate(self, value):
+        """Sets the chat template.
+
+        Parameters
+        ----------
+        value : str
+            Template used for the chat
+        """
+        return self._set(chatTemplate=value)
+
+    def setAddAssistant(self, value):
+        """Sets whether to add an assistant header to the end of the generated string.
+
+        Parameters
+        ----------
+        value : bool
+            Whether to add an assistant header to the end of the generated string
+        """
+        return self._set(addAssistant=value)

sparknlp/base/recursive_pipeline.py

@@ -0,0 +1,107 @@
+#  Copyright 2017-2022 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for the RecursivePipeline."""
+
+from pyspark import keyword_only
+from pyspark.ml import PipelineModel, Estimator, Pipeline, Transformer
+from pyspark.ml.wrapper import JavaEstimator
+
+from sparknlp.common import AnnotatorProperties
+from sparknlp.internal import RecursiveEstimator
+from sparknlp.base import HasRecursiveTransform
+
+
+class RecursivePipeline(Pipeline, JavaEstimator):
+    """Recursive pipelines are Spark NLP specific pipelines that allow a Spark
+    ML Pipeline to know about itself on every Pipeline Stage task.
+
+    This allows annotators to utilize this same pipeline against external
+    resources to process them in the same way the user decides.
+
+    Only some of the annotators take advantage of this. RecursivePipeline
+    behaves exactly the same as normal Spark ML pipelines, so they can be used
+    with the same intention.
+
+    Examples
+    --------
+    >>> from sparknlp.annotator import *
+    >>> from sparknlp.base import *
+    >>> recursivePipeline = RecursivePipeline(stages=[
+    ...     documentAssembler,
+    ...     sentenceDetector,
+    ...     tokenizer,
+    ...     lemmatizer,
+    ...     finisher
+    ... ])
+    """
+    @keyword_only
+    def __init__(self, *args, **kwargs):
+        super(RecursivePipeline, self).__init__(*args, **kwargs)
+        self._java_obj = self._new_java_obj("com.johnsnowlabs.nlp.RecursivePipeline", self.uid)
+        kwargs = self._input_kwargs
+        self.setParams(**kwargs)
+
+    def _fit(self, dataset):
+        stages = self.getStages()
+        for stage in stages:
+            if not (isinstance(stage, Estimator) or isinstance(stage, Transformer)):
+                raise TypeError(
+                    "Cannot recognize a pipeline stage of type %s." % type(stage))
+        indexOfLastEstimator = -1
+        for i, stage in enumerate(stages):
+            if isinstance(stage, Estimator):
+                indexOfLastEstimator = i
+        transformers = []
+        for i, stage in enumerate(stages):
+            if i <= indexOfLastEstimator:
+                if isinstance(stage, Transformer):
+                    transformers.append(stage)
+                    dataset = stage.transform(dataset)
+                elif isinstance(stage, RecursiveEstimator):
+                    model = stage.fit(dataset, pipeline=PipelineModel(transformers))
+                    transformers.append(model)
+                    if i < indexOfLastEstimator:
+                        dataset = model.transform(dataset)
+                else:
+                    model = stage.fit(dataset)
+                    transformers.append(model)
+                    if i < indexOfLastEstimator:
+                        dataset = model.transform(dataset)
+            else:
+                transformers.append(stage)
+        return PipelineModel(transformers)
+
+
+class RecursivePipelineModel(PipelineModel):
+    """Fitted RecursivePipeline.
+
+    Behaves the same as a Spark PipelineModel does. Not intended to be
+    initialized by itself. To create a RecursivePipelineModel please fit data to
+    a :class:`.RecursivePipeline`.
+    """
+    def __init__(self, pipeline_model):
+        super(PipelineModel, self).__init__()
+        self.stages = pipeline_model.stages
+
+    def _transform(self, dataset):
+        for t in self.stages:
+            if isinstance(t, HasRecursiveTransform):
+                # drops current stage from the recursive pipeline within
+                dataset = t.transform_recursive(dataset, PipelineModel(self.stages[:-1]))
+            elif isinstance(t, AnnotatorProperties) and t.getLazyAnnotator():
+                pass
+            else:
+                dataset = t.transform(dataset)
+        return dataset
+

sparknlp/base/table_assembler.py

@@ -0,0 +1,145 @@
+#  Copyright 2017-2022 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for the TableAssembler."""
+from sparknlp.common import *
+
+
+class TableAssembler(AnnotatorModel):
+    """This transformer parses text into tabular representation. The input consists of DOCUMENT annotations and the
+    output are TABLE annotations. The source format can be either JSON or CSV. The CSV format support alternative
+    delimiters (e.g. tab), as well as escaping delimiters by surrounding cell values with double quotes.
+
+    The transformer stores tabular data internally as JSON. The default input format is also JSON.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``DOCUMENT``           ``TABLE``
+    ====================== ======================
+
+    Parameters
+    ----------
+        inputFormat
+            The format of the source representation of the table ('json' or 'csv')
+
+        csvDelimiter
+            The delimiter used for parsing CSV files (defailt is comma)
+
+        escapeCsvDelimiter
+            Whether to escape Csv delimiter by surrounding values with double quotes
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>>
+    >>> document_assembler = DocumentAssembler() \\
+    ...     .setInputCol("table_csv") \\
+    ...     .setOutputCol("document_table")
+    >>> table_assembler = TableAssembler()\\
+    >>>     .setInputFormat("csv")\\
+    >>>     .setInputCols(["document_table"])\\
+    >>>     .setOutputCol("table")
+    >>>
+    >>> csv_data = "\\n".join([
+    >>> "name, money, age",
+    >>> "Donald Trump, \"100,000,000\", 75",
+    >>> "Elon Musk, \"20,000,000,000,000\", 55"])
+    >>> data = spark.createDataFrame([[csv_data]]) \\
+    ...    .toDF("table_csv")
+    >>> pipeline = Pipeline().setStages([
+    ...     document_assembler,
+     ...     table_assembler
+    ... ]).fit(data)
+    >>> result = pipeline.transform(data)
+    >>> result.select("table").show(truncate=False)
+    +-----------------------------------------------+
+    |table                                          |
+    +-----------------------------------------------+
+    |[[table, 0, 118, {                             |
+    |   "header":["name","money","age"],            |
+    |   "rows":[                                    |
+    |    ["Donald Trump","100,000,000","75"],       |
+    |    ["Elon Musk","20,000,000,000,000","55"]]   |
+    | },                                            |
+    | [sentence -> 0, input_format -> csv], []]]    |
+    +-----------------------------------------------+
+"""
+    name = "TableAssembler"
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT]
+
+    outputAnnotatorType = AnnotatorType.TABLE
+
+    inputFormat = Param(
+        Params._dummy(),
+        "inputFormat",
+        "Input format ('json' or 'csv')",
+        typeConverter=TypeConverters.toString)
+
+    csvDelimiter = Param(
+        Params._dummy(),
+        "csvDelimiter",
+        "CSV delimiter",
+        typeConverter=TypeConverters.toString)
+
+    escapeCsvDelimiter = Param(
+        Params._dummy(),
+        "escapeCsvDelimiter",
+        "Escape Csv delimiter by surrounding values with double quotes",
+        typeConverter=TypeConverters.toBoolean)
+
+    def setInputFormat(self, value):
+        """Sets the table input format. The following formats are currently supported: json, csv.
+
+        Parameters
+        ----------
+        value : str
+            Table input format
+        """
+        return self._set(inputFormat=value)
+
+    def setCsvDelimiter(self, value):
+        """Sets the CSV delimiter.
+
+        Parameters
+        ----------
+        value : str
+            CSV delimiter
+        """
+        return self._set(csvDelimiter=value)
+
+    def setEscapeCsvDelimiter(self, value):
+        """Escape Csv delimiter by surrounding values with double quotes
+
+        Parameters
+        ----------
+        value : bool
+            True of Csv delimiter is escaped by surrounding values with double quotes
+        """
+        return self._set(escapeCsvDelimiter=value)
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.TableAssembler", java_model=None):
+        super(TableAssembler, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+        self._setDefault(
+            inputFormat="json",
+            csvDelimiter=",",
+            escapeCsvDelimiter=True
+        )