flowtask 5.13.4__tar.gz → 5.13.6__tar.gz

{flowtask-5.13.4 → flowtask-5.13.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowtask
-Version: 5.13.4
+Version: 5.13.6
 Summary: Framework for Task orchestration
 Author-email: Jesus Lara <jesuslarag@gmail.com>
 License: Apache-2.0
@@ -105,7 +105,7 @@ Requires-Dist: pillow-heif<2,>=1.3.0
 Requires-Dist: pgvector==0.4.1
 Requires-Dist: proxylists>=0.14.0
 Requires-Dist: async-notify[all]>=1.4.0
-Requires-Dist: querysource>=3.17.0
+Requires-Dist: querysource>=5.2.5
 Requires-Dist: asyncdb[all]>=2.11.7
 Requires-Dist: navconfig[default,uvloop]>=1.7.13
 Requires-Dist: navigator-auth>=0.15.8

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/CopyToBigQuery.py

@@ -4,6 +4,7 @@ import datetime as dt
 import math
 import time
 import pandas as pd
+from querysource.types.dt.transforms import parse_datetime_series, to_wall_clock
 from asyncdb import AsyncDB
 from asyncdb.exceptions import (
     StatementError,
@@ -640,6 +641,17 @@ class CopyToBigQuery(CopyTo, PandasDataframe):
             self._logger.warning(f'CopyTo: Could not retrieve table schema: {err}')
         return column_types
 
+    @staticmethod
+    def _is_date_objects(series: pd.Series) -> bool:
+        """Return True for an object column whose non-null values are all plain ``datetime.date``.
+
+        Such columns are already DATE-ready and are left unchanged.
+        """
+        if not pd.api.types.is_object_dtype(series):
+            return False
+        values = series.dropna()
+        return not values.empty and all(type(v) is dt.date for v in values)
+
     def _convert_dataframe_to_bigquery_types(self, df, column_types):
         """Convert DataFrame columns to match BigQuery schema types."""
         converted_df = df.copy()
@@ -668,8 +680,9 @@ class CopyToBigQuery(CopyTo, PandasDataframe):
                     self._logger.debug(
                         f"CopyTo: Converted {col} to DATE (from numeric values)"
                     )
-                elif not pd.api.types.is_object_dtype(converted_df[col]):
-                    dates = pd.to_datetime(converted_df[col], errors="coerce").dt.date
+                elif not self._is_date_objects(converted_df[col]):
+                    # str / string / object of strings or timestamps: local calendar date
+                    dates = to_wall_clock(converted_df[col], field=col).dt.date
                     converted_df[col] = dates.astype(object).where(
                         dates.notna(), None
                     )
@@ -679,13 +692,20 @@ class CopyToBigQuery(CopyTo, PandasDataframe):
 
             # Handle DATETIME type
             elif bq_type == "DATETIME":
-                if pd.api.types.is_datetime64_any_dtype(converted_df[col]):
-                    converted_df[col] = converted_df[col].dt.tz_localize(None)
+                if not pd.api.types.is_numeric_dtype(converted_df[col]):
+                    # civil value: every entry keeps its own local wall-clock
+                    converted_df[col] = to_wall_clock(converted_df[col], field=col)
 
             # Handle TIMESTAMP type
             elif bq_type == "TIMESTAMP":
-                if pd.api.types.is_datetime64_any_dtype(converted_df[col]):
-                    converted_df[col] = converted_df[col].dt.tz_localize(None)
+                if not pd.api.types.is_numeric_dtype(converted_df[col]):
+                    # instant: normalise to UTC before dropping the tz (BigQuery reads naive as UTC)
+                    values = parse_datetime_series(
+                        converted_df[col], infer_tz=False, field=col
+                    )
+                    if isinstance(values.dtype, pd.DatetimeTZDtype):
+                        values = values.dt.tz_convert("UTC").dt.tz_localize(None)
+                    converted_df[col] = values
 
             # Handle INTEGER type (GoogleSQL: INT64; legacy: INTEGER)
             elif bq_type in ("INT64", "INTEGER"):

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/CopyToPg.py

@@ -16,6 +16,7 @@ from pandas.api.types import (
 )
 import numpy as np
 from typing import Optional
+from querysource.types.dt.transforms import to_wall_clock
 import orjson
 import asyncpg
 from datamodel import Field
@@ -393,6 +394,23 @@ class CopyToPg(CopyTo):
         if converted:
             self._logger.debug(f"CopyToPg: coerced to text for {self.schema}.{self.tablename}: {converted}")
 
+    def _apply_naive_tz(self) -> None:
+        """Convert every ``naive_tz`` column to its local wall-clock (naive datetime64).
+
+        Missing columns are skipped with a warning; naive datetime columns are left as
+        they are; tz-aware, string and object columns go through QuerySource's
+        ``to_wall_clock`` (each value keeps its own local time). Must run before the
+        NaT -> None cleanup so converted NaT values are cleaned too.
+        """
+        for col in self._naive_columns:
+            if col not in self.data.columns:
+                self._logger.warning(f"CopyToPg: naive_tz column {col!r} not found; skipped")
+                continue
+            series = self.data[col]
+            if is_datetime64_any_dtype(series) and not isinstance(series.dtype, pd.DatetimeTZDtype):
+                continue
+            self.data[col] = to_wall_clock(series, field=col)
+
     async def _copy_dataframe(self):
         # insert data directly into table
         columns = list(self.data.columns)
@@ -547,6 +565,9 @@ class CopyToPg(CopyTo):
                         # Get PostgreSQL column types
                         pg_column_types = await self._get_column_types(conn)
 
+                    if self._naive_columns:
+                        self._apply_naive_tz()
+
                     # Handle datetime columns - replace NaT with None
                     datetime_cols = self.data.select_dtypes(include=['datetime64[ns]', 'datetime64[ns, UTC]'])
                     if not datetime_cols.empty:
@@ -554,24 +575,6 @@ class CopyToPg(CopyTo):
                             pd.notnull(datetime_cols), None
                         )
 
-                    if self._naive_columns:
-                        # Remove the timezone on tz-naive columns:
-                        for col in self._naive_columns:
-                            if col not in self.data.columns:
-                                continue
-
-                        # If the column is not datetime-like, coerce it first (optional)
-                        if not is_datetime64_any_dtype(self.data[col]):
-                            self.data[col] = pd.to_datetime(
-                                self.data[col],
-                                errors="coerce",  # bad values → NaT
-                                utc=True  # parse as UTC if a tz string is present
-                            )
-                        # After the coercion, act only on tz-aware columns
-                        if isinstance(self.data[col].dtype, pd.DatetimeTZDtype):
-                            # tz_localize(None) drops the tz info but keeps the *wall time*
-                            # e.g. 2025-03-20 19:11:09+00:00 → 2025-03-20 19:11:09
-                            self.data[col] = self.data[col].dt.tz_localize(None)
                     if self._json_columns:
                         for col in self._json_columns:
                             if col in self.data.columns:

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/DuplicatePhoto.py

@@ -13,7 +13,7 @@ from pgvector.utils import Vector
 from navigator.libs.json import JSONContent
 from ..interfaces.flow import FlowComponent
 from ..exceptions import ConfigError, ComponentError
-from ..conf import default_dsn
+from ..conf import default_dsn, pg_application_name
 
 IDENT_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
 
@@ -252,6 +252,9 @@ class DuplicatePhoto(FlowComponent):
             max_queries=100,
             init=self.pgvector_init,
             timeout=10,
+            server_settings={
+                "application_name": pg_application_name("DuplicatePhoto")
+            },
         )
         # Check if the table exists
         if not self.pool:

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/ExtractTranscript.py

@@ -17,7 +17,7 @@ from sqlalchemy import create_engine, text, bindparam
 from ..interfaces.flow import FlowComponent
 from ..interfaces.Boto3Client import Boto3Client
 from ..exceptions import ConfigError, ComponentError
-from ..conf import default_dsn
+from ..conf import default_dsn, pg_application_name
 
 # Import torch conditionally for CUDA cleanup
 try:
@@ -1179,7 +1179,12 @@ class ExtractTranscript(Boto3Client, FlowComponent):
                     dsn = str(dsn)
                 if isinstance(dsn, str) and dsn.startswith('postgres:'):
                     dsn = dsn.replace('postgres:', 'postgresql:')
-                self._lookup_engine = create_engine(dsn, echo=False)
+                engine_kwargs: dict = {}
+                if isinstance(dsn, str) and dsn.startswith('postgresql'):
+                    engine_kwargs['connect_args'] = {
+                        'application_name': pg_application_name('ExtractTranscript')
+                    }
+                self._lookup_engine = create_engine(dsn, echo=False, **engine_kwargs)
             except Exception as err:
                 self._logger.error(f"Error creating lookup engine: {err}")
                 return None

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/IcimsFolderCopy.py

@@ -4,6 +4,7 @@ import asyncio
 from navconfig.logging import logging
 from asyncdb.exceptions import ProviderError
 from asyncdb.drivers.pg import pg
+from ..conf import pg_application_name
 from ..interfaces.flow import FlowComponent
 from ..exceptions import ComponentError, DataNotFound
 from querysource.conf import default_dsn, DB_TIMEOUT
@@ -68,7 +69,13 @@ class IcimsFolderCopy(FlowComponent):
     async def run(self):
         """Execute the folder copying process based on database results using Pandas."""
         try:
-            db = pg(dsn=self.dsn, timeout=self.timeout)
+            db = pg(
+                dsn=self.dsn,
+                timeout=self.timeout,
+                server_settings={
+                    "application_name": pg_application_name("IcimsFolderCopy")
+                },
+            )
         except ProviderError as e:
             raise ComponentError(f"Error connecting to database: {e}")
 

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/MergeFiles.py

@@ -11,6 +11,7 @@ from ..exceptions import ComponentError
 from ..parsers.maps import open_model
 from ..interfaces.flow import FlowComponent
 from .OpenWithBase import detect_encoding, excel_based
+from .pandas_io import _post_parse_dates, _preserve_date_inputs
 
 
 class MergeFiles(FlowComponent):
@@ -176,13 +177,13 @@ class MergeFiles(FlowComponent):
                     file_engine = "pyxlsb"
                 else:
                     file_engine = "openpyxl"
+                dates = []
                 # get the Model (if any):
                 if hasattr(self, "model"):
                     columns = await open_model(
                         self.model, self._program, path=self._taskstore.get_path()
                     )
                     fields = []
-                    dates = []
                     for field, dtype in columns["fields"].items():
                         fields.append(field)
                         try:
@@ -192,8 +193,12 @@ class MergeFiles(FlowComponent):
                         if t in {"date", "datetime", "time"}:
                             dates.append(field)
                     args["names"] = fields
-                    if dates:
-                        args["parse_dates"] = dates
+                reader_options = _preserve_date_inputs(args, dates)
+                date_options = {
+                    key: reader_options.pop(key)
+                    for key in ("dayfirst", "date_format")
+                    if dates and key in reader_options
+                }
                 files = []
                 file_stats = {}
                 for file in self.data:
@@ -205,8 +210,9 @@ class MergeFiles(FlowComponent):
                             na_values=["TBD", "NULL", "null", "", "#NA"],
                             engine=file_engine,
                             keep_default_na=True,
-                            **args,
+                            **reader_options,
                         )
+                        df = _post_parse_dates(df, dates, **date_options)
                         file_args = {}
                         if hasattr(self, 'file_stats'):
                             first_row = df.iloc[0][self.file_stats['columns']].to_dict()

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/NetworkNinja/models/forms.py

@@ -7,6 +7,7 @@ from datamodel import BaseModel, Field
 from datamodel.parsers.json import json_encoder
 from querysource.conf import default_dsn, async_default_dsn
 from querysource.outputs.tables import PgOutput
+from ....conf import pg_server_settings
 from .abstract import AbstractPayload
 from .organization import Organization
 from .client import Client
@@ -465,7 +466,9 @@ class FormData(AbstractPayload):
 
         logger.debug(f"Processing form update: {previous_form} -> {new_form}")
 
-        async with await AsyncDB('pg', dsn=default_dsn).connection() as conn:
+        async with await AsyncDB(
+            'pg', dsn=default_dsn, server_settings=pg_server_settings('NetworkNinja')
+        ).connection() as conn:
             try:
                 # Use PL/pgSQL to handle the UPDATE exception properly
                 transaction = f"""

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/NetworkNinja/router.py

@@ -34,7 +34,8 @@ from ...interfaces.http import HTTPService
 from ...conf import (
     NETWORKNINJA_API_KEY,
     NETWORKNINJA_BASE_URL,
-    NETWORKNINJA_ENV
+    NETWORKNINJA_ENV,
+    pg_pool_options,
 )
 from .models import NetworkNinja_Map, NN_Order
 from .models.abstract import AbstractPayload
@@ -491,8 +492,13 @@ class NetworkNinja(HTTPService, FlowComponent):
         return final_form_ids
 
     async def close(self):
-        if self._pool:
-            await self._pool.close()
+        """Release the PostgreSQL pool (safe to call more than once)."""
+        pool, self._pool = self._pool, None
+        if pool:
+            try:
+                await pool.close()
+            except Exception as exc:  # pylint: disable=W0718
+                self._logger.warning(f"Error closing NetworkNinja pool: {exc!s}")
 
     def _evaluate_input(self):
         if self.previous or self.input is not None:
@@ -526,13 +532,31 @@ class NetworkNinja(HTTPService, FlowComponent):
         return True
 
     async def run(self):
-        """Run NetworkNinja Router."""
+        """Run NetworkNinja Router.
+
+        Opens a short-lived PostgreSQL pool for the duration of the action.
+        The task runner only calls ``close()`` when ``run()`` returns, so the
+        pool is released here as well whenever the action raises (for example
+        ``DataNotFound`` from ``get_batches`` on an empty NetworkNinja queue).
+        """
+        self._pool = AsyncPool(
+            'pg',
+            dsn=default_dsn,
+            **pg_pool_options(suffix='NetworkNinja'),
+        )
+        await self._pool.connect()
+        try:
+            return await self._run_action()
+        except BaseException:
+            await self.close()
+            raise
+
+    async def _run_action(self):
+        """Execute the configured NetworkNinja action and return its result."""
         tasks = []
         fn = getattr(self, self._action)
         self.add_metric("ACTION", self._action)
         self._result = {}
-        self._pool = AsyncPool('pg', dsn=default_dsn, max_clients=1000)
-        await self._pool.connect()
         if self._action == 'get_batch':
             try:
                 result = await fn()

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/OpenWithBase.py

@@ -19,7 +19,7 @@ from ..exceptions import FileNotFound, ComponentError
 from ..utils.mail import MailMessage
 from ..utils import check_empty
 from ..parsers.maps import open_map, open_model
-from ..conf import TASK_PATH, DEFAULT_ENCODING
+from ..conf import TASK_PATH, DEFAULT_ENCODING, pg_server_settings
 from ..interfaces.flow import FlowComponent
 from ..utils.constants import excel_based
 
@@ -224,7 +224,12 @@ class OpenWithBase(FlowComponent):
                         event_loop = asyncio.get_running_loop()
                     except RuntimeError:
                         event_loop = asyncio.get_event_loop()
-                    db = AsyncDB("pg", dsn=asyncpg_url, loop=event_loop)
+                    db = AsyncDB(
+                        "pg",
+                        dsn=asyncpg_url,
+                        loop=event_loop,
+                        server_settings=pg_server_settings(self.__class__.__name__),
+                    )
                     async with await db.connection() as conn:
                         result, error = await conn.query(discover)
                         if error:

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/OpenWithPandas.py

@@ -10,6 +10,8 @@ import numpy as np
 from ..utils import check_empty
 from ..exceptions import ComponentError, DataNotFound, EmptyFile
 from .OpenWithBase import OpenWithBase, excel_based
+from querysource.types.dt.transforms import parse_datetime_series, to_wall_clock
+from .pandas_io import _post_parse_dates, _preserve_date_inputs, _split_parse_dates
 
 
 # Suppress specific warning
@@ -387,6 +389,13 @@ class OpenWithPandas(OpenWithBase):
         # uses async aiofiles and a chunked iterator — kept inline).
         if hasattr(self, "bigfile"):
             try:
+                date_kwargs, date_columns = _split_parse_dates(self.parse_dates)
+                reader_options = _preserve_date_inputs({**add_columns, **date_kwargs, **self.args}, date_columns)
+                date_options = {
+                    key: reader_options.pop(key)
+                    for key in ("dayfirst", "date_format")
+                    if date_columns and key in reader_options
+                }
                 tp = pandas.read_csv(
                     filename,
                     sep=self.separator,
@@ -399,11 +408,16 @@ class OpenWithPandas(OpenWithBase):
                     skipinitialspace=True,
                     iterator=True,
                     chunksize=int(self.chunksize),
-                    **add_columns,
-                    **self.parse_dates,
-                    **self.args,
+                    **reader_options,
+                )
+                return _post_parse_dates(
+                    pandas.concat(
+                        tp,
+                        ignore_index=reader_options.get("index_col") is None or reader_options.get("index_col") is False,
+                    ),
+                    date_columns,
+                    **date_options,
                 )
-                return pandas.concat(tp, ignore_index=True)
             except pandas.errors.EmptyDataError as err:
                 raise ComponentError(
                     f"Empty Data File on: {filename}, error: {err}"
@@ -459,7 +473,10 @@ class OpenWithPandas(OpenWithBase):
                 for file in self._data:
                     try:
                         df = pandas.DataFrame(
-                            data=file, **add_columns, **self.parse_dates, **self.args
+                            data=file, **add_columns, **self.args
+                        )
+                        df = _post_parse_dates(
+                            df, _split_parse_dates(self.parse_dates)[1]
                         )
                         result.append(df)
                     except pandas.errors.EmptyDataError as err:
@@ -605,9 +622,17 @@ class OpenWithPandas(OpenWithBase):
                         or dtype == "timestamp with time zone"
                         or dtype == "date"
                     ):
-                        if df[column].dtype != "datetime64[ns]":
-                            df[column] = pandas.to_datetime(df[column], errors="coerce")
-                            df[column] = df[column].astype("datetime64[ns]")
+                        if dtype == "timestamp with time zone":
+                            values = parse_datetime_series(
+                                df[column], infer_tz=False, field=column
+                            )
+                            if isinstance(values.dtype, pandas.DatetimeTZDtype):
+                                values = values.dt.tz_convert("UTC")
+                            else:
+                                values = values.dt.tz_localize("UTC")
+                            df[column] = values
+                        else:
+                            df[column] = to_wall_clock(df[column], field=column)
                     elif (
                         dtype == "character varying"
                         or dtype == "character"

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/PlanogramCompliance.py

@@ -8,10 +8,12 @@ from pathlib import Path
 from PIL import Image
 from asyncdb import AsyncDB
 from querysource.conf import default_dsn
+from ..conf import pg_server_settings
 import re
 from parrot.conf import PLANOGRAM_FOLDER
 from parrot.clients.google import GoogleGenAIClient, GoogleModel
 from parrot_pipelines.models import PlanogramConfig, EndcapGeometry
+from parrot_pipelines.planogram.plan import PlanogramCompliance as PlanogramPipeline
 from ..interfaces.flow import FlowComponent
 from ..interfaces.pipelines.parrot import AIPipeline
 from ..exceptions import ComponentError, ConfigError
@@ -54,6 +56,7 @@ class PlanogramCompliance(AIPipeline, FlowComponent):
     | id_column              | No  | DataFrame column used as per-row image id (default ``photo_id``)|
     | reference_images       | No  | Mapping key -> image file or directory under ``images/``;       |
     |                        |     | overrides the ``reference_images`` column of the row            |
+    |                        |     | (ignored for types without references, e.g. ``ink_wall``)       |
     | llm_backend            | No  | LLM backend as ``provider:model``; overrides the ``llm_backend``|
     |                        |     | column of the row (default: the ai-parrot package default)      |
     | llm_config             | No  | Arguments of an explicit Google GenAI client; when given it wins|
@@ -200,7 +203,7 @@ class PlanogramCompliance(AIPipeline, FlowComponent):
                 "planogram_config_table is not specified"
             )
         planogram_query = f"SELECT * FROM {self._planogram_config_table} WHERE config_name = $1"
-        db = AsyncDB('pg', dsn=default_dsn)
+        db = AsyncDB('pg', dsn=default_dsn, server_settings=pg_server_settings('PlanogramCompliance'))
         async with await db.connection() as conn:
             result = await conn.fetch_one(planogram_query, self._planogram_name)
         if not result:
@@ -255,19 +258,27 @@ class PlanogramCompliance(AIPipeline, FlowComponent):
             self.confidence_threshold = row['confidence_threshold']
         if row.get('detection_model'):
             self.detection_model = row['detection_model']
-        # Task reference images win; otherwise use the ones stored in the row.
-        references = reference_images or self._reference_images
-        if not references:
-            references = self._db_reference_images(
-                self._decode_json_column(row, 'reference_images')
+        # DB value takes precedence, the task value is the fallback.
+        planogram_type = row.get('planogram_type') or self._planogram_type
+        layout_config = self._decode_json_column(row, 'planogram_config') or {}
+        references: Dict[str, Union[Path, List[Path]]] = {}
+        if self._uses_reference_images(planogram_type, layout_config):
+            # Task reference images win; otherwise use the ones stored in the row.
+            references = reference_images or self._prepare_task_references()
+            if not references:
+                references = self._db_reference_images(
+                    self._decode_json_column(row, 'reference_images')
+                )
+        else:
+            self._logger.debug(
+                f"Planogram type '{planogram_type}' does not use reference images; skipping them"
             )
         try:
             planogram_config = PlanogramConfig(
                 planogram_id=row.get('planogram_id'),
                 config_name=self._planogram_name,
-                # DB value takes precedence, the task value is the fallback.
-                planogram_type=row.get('planogram_type') or self._planogram_type,
-                planogram_config=self._decode_json_column(row, 'planogram_config') or {},
+                planogram_type=planogram_type,
+                planogram_config=layout_config,
                 endcap_geometry=geometry,
                 roi_detection_prompt=row.get('roi_detection_prompt') or None,
                 object_identification_prompt=row.get('object_identification_prompt') or None,
@@ -284,6 +295,40 @@ class PlanogramCompliance(AIPipeline, FlowComponent):
         self._logger.debug('Planogram config loaded: %s', planogram_config)
         return planogram_config
 
+    def _uses_reference_images(self, planogram_type: str, layout_config: Dict[str, Any]) -> bool:
+        """Ask the pipeline whether this planogram type consumes reference images.
+
+        Args:
+            planogram_type: Resolved planogram type of the configuration.
+            layout_config: The ``planogram_config`` column (may override ``layout_profile.references``).
+
+        Returns:
+            False for types that identify products without references (e.g. ``ink_wall``); True
+            when the installed ai-parrot predates ``uses_reference_images``.
+
+        Raises:
+            ConfigError: Unknown planogram type or an invalid ``layout_profile`` override.
+        """
+        uses_references = getattr(PlanogramPipeline, 'uses_reference_images', None)
+        if uses_references is None:
+            return True
+        try:
+            return bool(uses_references(planogram_type, layout_config))
+        except ValueError as e:
+            raise ConfigError(
+                f"Invalid planogram configuration: {e}"
+            ) from e
+
+    def _prepare_task_references(self) -> Dict[str, Union[Path, List[Path]]]:
+        """Resolve the task ``reference_images`` once, only for types that use them.
+
+        Returns:
+            The cached mapping of catalogue key to a Path or a list of Paths.
+        """
+        if not self._reference_images and self.reference_images:
+            self._reference_images = self._prepare_reference_images()
+        return self._reference_images
+
     @staticmethod
     def _decode_json_column(row: Dict[str, Any], column: str) -> Any:
         """Return a JSONB column of the row as a Python object.
@@ -381,16 +426,12 @@ class PlanogramCompliance(AIPipeline, FlowComponent):
                 f"Image column '{self.image_column}' not found in DataFrame"
             )
 
-        # Prepare reference images list - convert to string paths as expected by pipeline
-        self._reference_images = self._prepare_reference_images()
-
         # Initialize LLM for pipeline
         self._llm = self._initialize_llm()
 
-        # Generate Planogram Configuration:
-        self.planogram_config = await self.get_planogram_config(
-            reference_images=self._reference_images
-        )
+        # Generate Planogram Configuration; reference images are resolved there,
+        # only when the planogram type uses them.
+        self.planogram_config = await self.get_planogram_config()
 
         self._logger.info(
             f"PlanogramPipeline started with {len(self.data)} rows to process"

{flowtask-5.13.4 → flowtask-5.13.6}/flowtask/components/ProductReportBot.py

@@ -17,6 +17,7 @@ from parrot.models.google import ConversationalScriptConfig, FictionalSpeaker
 from parrot.conf import STATIC_DIR
 from asyncdb import AsyncDB
 from querysource.conf import default_dsn
+from ..conf import pg_server_settings
 from parrot.models.responses import AgentResponse, AIMessage
 from parrot.models.basic import CompletionUsage
 from pathlib import Path
@@ -826,7 +827,7 @@ class ProductReportBot(ParrotAgentConfigMixin, ParrotBot, FlowComponent):
             )
 
         query = query_file.read_text()
-        db = AsyncDB('pg', dsn=default_dsn)
+        db = AsyncDB('pg', dsn=default_dsn, server_settings=pg_server_settings('ProductReportBot'))
         async with await db.connection() as conn:
             product_data, error = await conn.query(query, model)
             if error:
@@ -992,7 +993,7 @@ class ProductReportBot(ParrotAgentConfigMixin, ParrotBot, FlowComponent):
                 response_dict.pop(field, None)
             
            
-            db = AsyncDB('pg', dsn=default_dsn)
+            db = AsyncDB('pg', dsn=default_dsn, server_settings=pg_server_settings('ProductReportBot'))
             async with await db.connection() as conn:
                 ProductResponse.Meta.connection = conn
                 ProductResponse.Meta.schema = program_slug