flowtask 5.8.4__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

flowtask/components/CreateReport/charts/pie.py

@@ -0,0 +1,64 @@
+from typing import Any, Union, List, Dict
+import orjson
+from pyecharts.charts import Pie
+from borax.datasets.fetch import fetch
+import pyecharts.options as opts
+from .base import baseChart
+
+
+class pieChart(baseChart):
+    rosetype: str = "radius"
+    formatter: str = "{b}: {c} / {d}%"
+
+    def __init__(self, title: str, data: Union[List, Dict], **kwargs):
+        if "rosetype" in kwargs:
+            self.rosetype = kwargs["rosetype"]
+            del kwargs["rosetype"]
+        super(pieChart, self).__init__(title, data, **kwargs)
+
+    def get_chart(self):
+        return Pie(init_opts=self.init_opts)
+
+    def set_chart(self, data: Any, title: str, **kwargs):
+        # x, y = Base.cast(o_data)
+        dst = self._encoder(data)
+        dst = orjson.loads(dst)
+        # print('DATA ', dst)
+        if isinstance(dst, dict):
+            names, values = zip(*dst.items())
+        else:
+            names, values = fetch(dst, *self._fields)
+        self.args["data_pair"] = [list(z) for z in zip(names, values)]
+        # add arguments:
+        self.chart.add(series_name="", **self.args).set_global_opts(
+            **self.get_global_opts(title, **kwargs)
+        ).set_series_opts(**self.get_series_opts(**kwargs))
+
+    def get_basic_args(self, **kwargs):
+        return {
+            "radius": "55%",
+            "center": ["50%", "50%"],
+            # "rosetype": self.rosetype
+        }
+
+    def get_series_opts(self, **kwargs):
+        return {
+            "label_opts": opts.LabelOpts(
+                position="outside",
+                # formatter="{a|{a}}{abg|}\n{hr|}\n {b|{b}: }{c}  {per|{d}%}  ",
+                formatter=self.formatter,
+                is_show=True,
+            )
+        }
+
+    def get_global_opts(self, title: str, **kwargs):
+        return {
+            "title_opts": opts.TitleOpts(
+                title=title,
+                pos_left="center",
+                pos_top="0",
+            ),
+            "legend_opts": opts.LegendOpts(
+                is_show=True, pos_left="center", pos_bottom="20"
+            ),
+        }

flowtask/components/CreateReport/utils.py

@@ -0,0 +1,9 @@
+""" Utilities and Functions."""
+from aiohttp import TCPConnector, ClientSession
+
+
+async def get_json_data(url: str) -> dict:
+    """Get a JSON data from a remote Source."""
+    async with ClientSession(connector=TCPConnector(ssl=False)) as session:
+        async with session.get(url=url) as response:
+            return await response.json()

flowtask/components/CustomerSatisfaction.py

@@ -0,0 +1,196 @@
+from collections.abc import Callable
+import asyncio
+from typing import Any
+# Bot Infraestructure:
+from parrot.bots.basic import BasicBot
+from .flow import FlowComponent
+from ..exceptions import ComponentError, ConfigError
+from ..conf import TASK_STORAGES
+
+class CustomerSatisfaction(FlowComponent):
+    """
+        CustomerSatisfaction
+
+        Overview
+
+            The CustomerSatisfaction class is a component for interacting with an IA Agent for making Customer Satisfaction Analysis.
+            It extends the FlowComponent class.
+
+        .. table:: Properties
+        :widths: auto
+
+            +------------------+----------+--------------------------------------------------------------------------------------------------+
+            | Name             | Required | Description                                                                                      |
+            +------------------+----------+--------------------------------------------------------------------------------------------------+
+            | output_column    |   Yes    | Column for saving the Customer Satisfaction information.                                         |
+            +------------------+----------+--------------------------------------------------------------------------------------------------+
+        Return
+
+            A Pandas Dataframe with the Customer Satisfaction statistics.
+
+    
+
+        Example:
+
+        ```yaml
+        CustomerSatisfaction:
+          llm:
+            name: VertexLLM
+            model_name: gemini-1.5-pro
+            temperature: 0.4
+          review_column: review
+          product_column: product_name
+          columns:
+          - product_id
+          - product_name
+          - product_model
+          - product_type
+          - product_variant
+          - account_name
+          - picture_url
+          - url
+          output_column: customer_satisfaction
+        ```
+
+    """ # noqa
+
+    def __init__(
+        self,
+        loop: asyncio.AbstractEventLoop = None,
+        job: Callable = None,
+        stat: Callable = None,
+        **kwargs,
+    ):
+        super().__init__(
+            loop=loop, job=job, stat=stat, **kwargs
+        )
+        # System Prompt:
+        self.system_prompt = "Customer Satisfaction: "
+        self._bot_name = kwargs.get('bot_name', 'CustomerBot')
+        # TaskStorage
+        # Find in the taskstorage, the "prompts" directory.
+        prompt_path = self._taskstore.path.joinpath(self._program, 'prompts')
+        if not prompt_path.exists():
+            raise ConfigError(
+                f"{self.system_prompt} Prompts Path Not Found: {prompt_path}"
+            )
+        self.prompt_path = prompt_path
+        # is hardcoded to this particular Bot.
+        self.system_prompt_file = 'reviewbot.txt'
+        # Bot Object:
+        self._bot: Any = None
+
+    async def start(self, **kwargs):
+        """
+            start
+
+            Overview
+
+                The start method is a method for starting the CustomerSatisfaction component.
+
+            Parameters
+
+                kwargs: dict
+                    A dictionary containing the parameters for the CustomerSatisfaction component.
+
+            Return
+
+                True if the CustomerSatisfaction component started successfully.
+
+        """
+        if self.previous:
+            self.data = self.input
+        else:
+            raise ComponentError(
+                "CustomerBot: Data Was Not Found"
+            )
+        if not self.output_column:
+            raise ConfigError(
+                "Customer Satisfaction: output_column is required"
+            )
+        # check if Prompt File exists
+        prompt_file = self.prompt_path.joinpath(self.system_prompt_file)
+        if not prompt_file.exists():
+            raise ConfigError(
+                f"{self.system_prompt} Prompt File Not Found: {prompt_file}"
+            )
+        self.system_prompt_file = prompt_file.name
+        # read the prompt file as text:
+        with open(prompt_file, 'r') as f:
+            self.system_prompt = f.read()
+        # Set the Bot:
+        try:
+            self._bot = BasicBot(
+                name=self._bot_name,
+                system_prompt=self.system_prompt,
+                goal="Customer Satisfaction Analysis using Reviews",
+                use_llm=self.llm.get('name', 'name'),
+                model_name=self.llm.get('model_name', "gemini-2.0-flash-001"),
+            )
+            # configure the bot:
+            await self._bot.configure()
+        except Exception as err:
+            raise ComponentError(
+                f"{self.system_prompt} Error Configuring Bot: {err}"
+            ) from err
+        return True
+
+    def format_question(self, product_name, reviews):
+        question = f"""
+        Product: {product_name}
+
+        Question:
+        "What is the overall customer sentiment, likes and dislikes,
+        and what insights can be derived from these product reviews for product: {product_name}?"
+
+        Customer Reviews:
+
+        """
+        for review in reviews:
+            question += f"* {review}\n"
+        return question
+
+    async def run(self):
+        """
+            run
+
+            Overview
+
+                The run method is a method for running the CustomerSatisfaction component.
+
+            Return
+
+                A Pandas Dataframe with the Customer Satisfaction statistics.
+
+        """
+        # Group reviews by product_name and aggregate them into a list
+        grouped = self.data.groupby(self.product_column)[self.review_column].apply(list).reset_index()
+        products_evaluation = {}
+        for _, row in grouped.iterrows():
+            product_name = row[self.product_column]
+            reviews = row[self.review_column]
+            formatted_question = self.format_question(product_name, reviews)
+            result = await self._bot.question(
+                question=formatted_question,
+                return_docs=False
+            )
+            products_evaluation[product_name] = {
+                "answer": result.answer
+            }
+        # Then, create a dataframe only with the columns in "self.columns" grouped.
+        grouped_df = self.data.groupby(self.columns).agg(
+            num_reviews=(self.review_column, "count"),
+            avg_rating=("rating", "mean")
+        ).reset_index()
+        # Add the Customer Satisfaction column, using the dictionary and match per product_name column
+        grouped_df[self.output_column] = grouped_df[self.product_column].map(
+            lambda x: products_evaluation[x]['answer']
+        )
+        # Remove the starting ```json and ending ``` using a regex
+        grouped_df[self.output_column] = grouped_df[self.output_column].str.replace(r'^```json\s*|\s*```$', '', regex=True)
+        # return the grouped dataframe
+        self._result = grouped_df
+        return self._result
+
+    async def close(self):
+        pass

flowtask/components/DataInput.py

@@ -0,0 +1,200 @@
+import asyncio
+from typing import Dict, List
+from collections.abc import Callable
+from navconfig.logging import logging
+from asyncdb.exceptions import ProviderError
+from ..exceptions import DataNotFound, ComponentError
+from ..conf import TASK_PATH
+from .flow import FlowComponent
+from .DbClient import DbClient
+from ..interfaces import TemplateSupport
+
+
+class DataInput(DbClient, FlowComponent, TemplateSupport):
+    """
+    DataInput
+
+    Class to execute queries against a database and retrieve results using asyncDB.
+
+    Inherits from both `DbClient` (for database connection management) and
+    `FlowComponent` (for component lifecycle management).
+
+    .. table:: Properties
+    :widths: auto
+
+        +---------------+----------+------------------------------------------------------------------------------+
+        | Name          | Required | Description                                                                  |
+        +---------------+----------+------------------------------------------------------------------------------+
+        | driver        |   Yes    | asyncDB driver to use (defaults to "pg" for PostgreSQL).                     |
+        |               |          | Can be overridden by a "driver" key in the "credentials" dictionary.         |
+        +---------------+----------+------------------------------------------------------------------------------+
+        | credentials   |   Yes    | Dictionary containing database connection credentials (user, password, etc.).|
+        +---------------+----------+------------------------------------------------------------------------------+
+        | query         |   Yes    | SQL query or queries to be executed. Can be provided in different formats:   |
+        |               |          |  * String (single query)                                                     |
+        |               |          |  * List (multiple queries)                                                   |
+        |               |          |  * Dictionary (named queries) - key-value pairs where key is the query name  |
+        |               |          |    and value is the query string.                                            |
+        |               |          | If not provided, no queries will be executed.                                |
+        +---------------+----------+------------------------------------------------------------------------------+
+        | file          |   Yes    | Path to a file containing a single or multiple SQL queries (alternative to   |
+        |               |          | `query`).                                                                    |
+        |               |          | If provided along with `query`, `file` takes precedence.                     |
+        +---------------+----------+------------------------------------------------------------------------------+
+        | as_dataframe  |    No    | Boolean flag indicating whether to convert query results to DataFrames.      |
+        |               |          | Defaults to False (returns raw results).                                     |
+        +---------------+----------+------------------------------------------------------------------------------+
+
+    .. returns::
+      The return value depends on the number of queries executed and the `as_dataframe` property:
+         * **Single Query:**
+             * DataFrame (if `as_dataframe` is True): Pandas DataFrame containing the query results.
+             * raw result object (default): Raw result object specific to the database driver.
+         * **Multiple Queries:**
+             * List[DataFrame] (if `as_dataframe` is True): List of DataFrames, each corresponding to a query result.
+             * List[raw result object] (default): List of raw result objects, each representing a query result.
+      Returns None if no queries are provided.
+    
+
+        Example:
+
+        ```yaml
+        DataInput:
+          query: SELECT * FROM xfinity.product_types
+          as_string: true
+        ```
+
+    """  # noqa
+    _credentials: dict = {
+        "host": str,
+        "port": int,
+        "user": str,
+        "password": str,
+        "database": str,
+    }
+
+    def __init__(
+        self,
+        loop: asyncio.AbstractEventLoop = None,
+        job: Callable = None,
+        stat: Callable = None,
+        **kwargs,
+    ):
+        self.queries: List = []
+        self.driver = kwargs.pop('driver', "pg")  # default driver
+        kwargs['driver'] = self.driver
+        # Extract tablename and schema from arguments:
+        self._tablename: str = kwargs.pop('tablename', None)
+        self._schema: str = kwargs.pop('schema', None)
+        # MongoDB related:
+        self._dbtype: str = kwargs.pop('dbtype', 'mongodb')
+        super().__init__(
+            loop=loop,
+            job=job,
+            stat=stat,
+            **kwargs
+        )
+        if self.credentials and "driver" in self.credentials:
+            self.driver = self.credentials.pop('driver')
+
+    async def start(self, **kwargs) -> bool:
+        await super(DataInput, self).start(**kwargs)
+        self.queries = []
+        if hasattr(self, "query"):
+            if isinstance(self.query, str):  # sigle query # pylint: disable=E0203
+                self.query = self.mask_replacement(self.query)
+                self.queries.append(self.query)
+            elif isinstance(self.query, list):  # multiple queries:
+                for query in self.query:
+                    query = self.mask_replacement(query)
+                    self.queries.append(query)
+            elif isinstance(self.query, dict):  # named queries:
+                for name, query in self.query.items():
+                    qs = {}
+                    query = self.mask_replacement(query)
+                    qs[name] = query
+                    self.queries.append(qs)
+        elif hasattr(self, "file"):  # query from a File
+            if isinstance(self.file, str):  # sigle query
+                self._logger.debug(f"Execute SQL File: {self.file!s}")
+                file_path = TASK_PATH.joinpath(self._program, "sql", self.file)
+                qs = await self.open_sqlfile(file_path)
+                self.queries.append(qs)
+            elif isinstance(self.file, list):  # multiple queries:
+                for file in self.file:
+                    query = await self.open_sqlfile(file)
+                    self.queries.append(qs)
+        else:
+            # are queries based on conditions over direct tables:
+            if self.driver == 'mongo':
+                self.queries.append(
+                    {
+                        "collection": self._tablename,
+                        "database": self._schema,
+                    }
+                )
+        return True
+
+    async def close(self):
+        self.connection = None
+
+    async def run(self):
+        try:
+            print(self.driver, self.credentials)
+            db = await self.connection(
+                driver=self.driver, credentials=self.credentials
+            )
+            print('DB > ', db)
+        except Exception as e:
+            logging.error(e)
+            raise
+        try:
+            async with await db.connection() as conn:
+                if conn.is_connected() is not True:
+                    raise ComponentError(
+                        f"DB Error: driver {self.driver} is not connected."
+                    )
+                results = []
+                for query in self.queries:
+                    print('QUERY > ', query, type(query))
+                    if isinstance(query, str):
+                        result = await self._query(query, conn)
+                        rst = len(result)
+                        st = {"query": query, "result": rst}
+                        self.add_metric(f"Query: {query}", st)
+                        if self.as_dataframe is True:
+                            # converting to a dataframe
+                            df = await self.get_dataframe(result)
+                            results.append(df)
+                        else:
+                            results.append(result)
+                    elif isinstance(query, dict):
+                        result = await self._query(query, conn)
+                        if self.as_dataframe is True:
+                            df = await self.get_dataframe(result)
+                            results.append(df)
+                        else:
+                            results.append(result)
+                        # qs = {}
+                        # [(key, value)] = query.items()
+                        # result = await self._query(value, conn)
+                        # rst = len(result)
+                        # st = {"query": query, "result": rst}
+                        # self.add_metric(f"Query: {key}", st)
+                        # if self.as_dataframe is True:
+                        #     df = await self.get_dataframe(result)
+                        #     qs[key] = df
+                        # else:
+                        #     qs[key] = result
+                if len(results) == 1:
+                    self._result = results[0]
+                else:
+                    self._result = results
+                return self._result
+        except DataNotFound:
+            raise
+        except ProviderError as e:
+            raise ComponentError(f"Error connecting to database: {e}") from e
+        except Exception as e:
+            logging.error(e)
+            raise