bizon 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

bizon/connectors/sources/notion/tests/notion_pipeline.py

@@ -0,0 +1,7 @@
+import os
+
+from bizon.engine.engine import RunnerFactory
+
+if __name__ == "__main__":
+    runner = RunnerFactory.create_from_yaml(filepath=os.path.abspath("test-pipeline-notion.yml"))
+    runner.run()

bizon/connectors/sources/notion/tests/test_notion.py

@@ -0,0 +1,113 @@
+"""
+Quick test script for Notion source intermediate functions.
+
+Usage:
+    # Set your token
+    export NOTION_TOKEN="your_notion_integration_token"
+
+    # Run interactively
+    python -i test_notion.py
+
+    # Then test functions:
+    >>> page = source.get_page("page-id-here")
+    >>> blocks = source.fetch_blocks_recursively("page-id-here")
+    >>> for b in blocks[:5]:
+    ...     print(source._block_to_markdown(b))
+"""
+
+import os
+
+from bizon.connectors.sources.notion.src.config import NotionSourceConfig, NotionStreams
+from bizon.connectors.sources.notion.src.source import NotionSource
+from bizon.source.auth.authenticators.token import TokenAuthParams
+from bizon.source.auth.config import AuthConfig, AuthType
+
+
+def create_notion_source(
+    token: str = None,
+    page_ids: list = None,
+    database_ids: list = None,
+    stream: NotionStreams = NotionStreams.BLOCKS,
+) -> NotionSource:
+    """Create a NotionSource instance for testing."""
+    token = token or os.environ.get("NOTION_TOKEN")
+    if not token:
+        raise ValueError("Provide token or set NOTION_TOKEN environment variable")
+
+    config = NotionSourceConfig(
+        name="notion",
+        stream=stream,
+        page_ids=page_ids or [],
+        database_ids=database_ids or [],
+        authentication=AuthConfig(
+            type=AuthType.BEARER,
+            params=TokenAuthParams(token=token),
+        ),
+        init_pipeline=False,
+        max_recursion_depth=30,
+    )
+    return NotionSource(config)
+
+
+# ==================== HELPER FUNCTIONS ====================
+
+
+def get_block(source: NotionSource, block_id: str) -> dict:
+    """Fetch a single block by ID."""
+    response = source.session.get(f"https://api.notion.com/v1/blocks/{block_id}")
+    response.raise_for_status()
+    return response.json()
+
+
+def get_page_markdown(source: NotionSource, page_id: str) -> str:
+    """Fetch all blocks from a page and return combined markdown."""
+    blocks = source.fetch_blocks_recursively(page_id, source_page_id=page_id)
+    lines = []
+    for block in blocks:
+        md = source._block_to_markdown(block)
+        if md:
+            # Add indentation based on depth
+            indent = "  " * block.get("depth", 0)
+            lines.append(f"{indent}{md}")
+    return "\n".join(lines)
+
+
+def inspect_blocks(source: NotionSource, page_id: str, max_blocks: int = 10):
+    """Fetch and print block details for inspection."""
+    blocks = source.fetch_blocks_recursively(page_id, source_page_id=page_id)
+    print(f"Found {len(blocks)} blocks")
+    for i, block in enumerate(blocks[:max_blocks]):
+        print(f"\n--- Block {i} ({block.get('type')}) ---")
+        print(f"ID: {block.get('id')}")
+        print(f"Depth: {block.get('depth')}, Order: {block.get('page_order')}")
+        print(f"Markdown: {source._block_to_markdown(block)}")
+
+
+def list_pages_in_database(source: NotionSource, database_id: str) -> list:
+    """List all page IDs in a database."""
+    return source.get_pages_from_database(database_id, apply_filter=False)
+
+
+# ==================== MAIN ====================
+
+if __name__ == "__main__":
+    # Create source if token is available
+    token = os.environ.get("NOTION_TOKEN")
+    if token:
+        source = create_notion_source(token=token)
+        print("NotionSource created and available as 'source'")
+        print("\nAvailable functions:")
+        print("  source.get_page(page_id)")
+        print("  source.get_database(database_id)")
+        print("  source.get_block_children(block_id)")
+        print("  source.fetch_blocks_recursively(page_id)")
+        print("  source._block_to_markdown(block)")
+        print("  source.search()")
+        print("\nHelper functions:")
+        print("  get_block(source, block_id)")
+        print("  get_page_markdown(source, page_id)")
+        print("  inspect_blocks(source, page_id)")
+        print("  list_pages_in_database(source, database_id)")
+    else:
+        print("Set NOTION_TOKEN env var or call:")
+        print("  source = create_notion_source(token='your_token')")

bizon/connectors/sources/periscope/src/source.py

@@ -41,7 +41,6 @@ class PeriscopeSourceConfig(SourceConfig):
 
 
 class PeriscopeSource(AbstractSource):
-
     def __init__(self, config: PeriscopeSourceConfig):
         super().__init__(config)
         self.config: PeriscopeSourceConfig = config
@@ -127,7 +126,6 @@ class PeriscopeSource(AbstractSource):
         return self.transform_response_to_source_iteration(records_json)
 
     def get_dashboards_metadata(self, pagination: dict = None) -> SourceIteration:
-
         params = {
             "client_site_id": self.config.client_site_id,
             "filters": [{"name": "typeFilter", "input": "Dashboard"}],
@@ -186,7 +184,6 @@ class PeriscopeSource(AbstractSource):
         dashboard_charts: List[dict] = []
 
         for iter_count in range(MAXIMUM_ITERATION):
-
             # Break the loop if no more charts are available
             if iter_count > 0 and len(iter_charts) == 0:
                 break
@@ -217,10 +214,8 @@ class PeriscopeSource(AbstractSource):
                 iter_textboxes = response.json().get("TextBox")
 
                 for chart in iter_charts:
-                    # Only fetch charts connected to gorgias-growth-production
                     if str(chart.get("database_id")) == str(self.config.database_id):
                         if chart.get("id") not in charts_list:
-
                             charts_list.add(chart.get("id"))
 
                             chart["raw_text"] = None
@@ -250,7 +245,6 @@ class PeriscopeSource(AbstractSource):
         return dashboard_charts
 
     def get_charts(self, pagination: dict = None) -> SourceIteration:
-
         BATCH_SIZE = 10
 
         if not pagination:

bizon/connectors/sources/pokeapi/src/source.py

@@ -23,7 +23,6 @@ class PokeAPISourceConfig(SourceConfig):
 
 
 class PeriscopeSource(AbstractSource):
-
     def __init__(self, config: PokeAPISourceConfig):
         super().__init__(config)
         self.config: PokeAPISourceConfig = config

bizon/connectors/sources/sana_ai/config/sana.example.yml

@@ -0,0 +1,25 @@
+name: sana to file
+
+source:
+  name: sana_ai
+  stream: insight_report
+  domain: my_domain
+  query: 'SELECT "user", "user_type", "user_role", "user_origin", "user_registration_step", "user_creation_date", "user_disabled_date", "user_completion_date", "user_status", "user_last_active_date", "user_attribute_evangelist" FROM "analytics"."users" ORDER BY "user" ASC'
+  authentication:
+    type: oauth
+    params:
+      token_refresh_endpoint: https://my_domain.sana.ai/api/token
+      client_id: <client_id>
+      client_secret: <client_secret>
+      grant_type: client_credentials
+      access_token_name: accessToken
+      expires_in_name: expiresIn
+      response_field_path: data
+      scopes:
+        - read
+        - write
+
+destination:
+  name: file
+  config:
+    destination_id: sana_ai_user_status

bizon/connectors/sources/sana_ai/src/source.py

@@ -0,0 +1,85 @@
+import csv
+import io
+import time
+from typing import Any, List, Tuple
+
+from loguru import logger
+from pydantic import Field
+from requests.auth import AuthBase
+
+from bizon.source.auth.builder import AuthBuilder
+from bizon.source.auth.config import AuthType
+from bizon.source.config import SourceConfig
+from bizon.source.models import SourceIteration, SourceRecord
+from bizon.source.source import AbstractSource
+
+
+class SanaSourceConfig(SourceConfig):
+    query: str = Field(..., description="Query to get the data from the Sana Insight API")
+    domain: str = Field(..., description="Domain of the Sana instance")
+
+
+class SanaSource(AbstractSource):
+    def __init__(self, config: SanaSourceConfig):
+        super().__init__(config)
+        self.config: SanaSourceConfig = config
+        self.base_url = f"https://{config.domain}.sana.ai/api/v1"
+
+    def get_authenticator(self) -> AuthBase:
+        if self.config.authentication.type.value == AuthType.OAUTH:
+            return AuthBuilder.oauth2(params=self.config.authentication.params)
+
+    @staticmethod
+    def streams() -> List[str]:
+        return ["insight_report"]
+
+    @staticmethod
+    def get_config_class() -> SourceConfig:
+        return SanaSourceConfig
+
+    def check_connection(self) -> Tuple[bool | Any | None]:
+        return True, None
+
+    def get_total_records_count(self) -> int | None:
+        return None
+
+    def create_insight_report_job(self, query: str) -> str:
+        """Create an insight report for the given query"""
+        response = self.session.post(f"{self.base_url}/reports/query", json={"query": query, "format": "csv"})
+        return response.json()["data"]["jobId"]
+
+    def get_insight_report_job(self, job_id: str) -> dict:
+        """Get an insight report job for the given job id"""
+        response = self.session.get(f"{self.base_url}/reports/jobs/{job_id}")
+        return response.json()
+
+    def get_insight_report(self, pagination: dict) -> SourceIteration:
+        """Return all insight report for the given query"""
+
+        job_id = self.create_insight_report_job(self.config.query)
+        logger.info(f"Created insight report job {job_id} for query {self.config.query}")
+
+        response = self.get_insight_report_job(job_id)
+        status = response["data"]["status"]
+        while status != "successful":
+            time.sleep(3)
+            response = self.get_insight_report_job(job_id)
+            status = response["data"]["status"]
+            logger.info(f"Insight report job {job_id} is {status}")
+
+        link = response["data"]["link"]["url"]
+        logger.info(f"Link for insight report job {job_id} is {link}")
+
+        csv_response = self.session.get(link)
+        csv_content = csv_response.content.decode("utf-8")
+
+        reader = csv.DictReader(io.StringIO(csv_content))
+        data = [SourceRecord(id=str(i), data=row) for i, row in enumerate(reader)]
+
+        return SourceIteration(records=data, next_pagination={})
+
+    def get(self, pagination: dict = None) -> SourceIteration:
+        if self.config.stream == "insight_report":
+            return self.get_insight_report(pagination)
+
+        raise NotImplementedError(f"Stream {self.config.stream} not implemented for Sana")

bizon/destination/buffer.py

@@ -9,7 +9,6 @@ from .models import destination_record_schema
 
 
 class DestinationBuffer:
-
     def __init__(self, buffer_size: int, buffer_flush_timeout: int) -> None:
         self.buffer_size = buffer_size * 1024 * 1024  # Convert to bytes
         self.buffer_flush_timeout = buffer_flush_timeout

bizon/destination/config.py

@@ -28,7 +28,6 @@ class RecordSchemaConfig(BaseModel):
 
 
 class AbstractDestinationDetailsConfig(BaseModel):
-
     # Forbid extra keys in the model
     model_config = ConfigDict(extra="forbid")
 
@@ -42,6 +41,11 @@ class AbstractDestinationDetailsConfig(BaseModel):
         description="Maximum time in seconds for buffering after which the records will be written to the destination. Set to 0 to deactivate the timeout buffer check.",  # noqa
     )
 
+    max_concurrent_threads: int = Field(
+        default=10,
+        description="Maximum number of concurrent threads to use for writing to the destination.",
+    )
+
     record_schemas: Optional[list[RecordSchemaConfig]] = Field(
         default=None, description="Schemas for the records. Required if unnest is set to true."
     )
@@ -71,4 +75,8 @@ class AbstractDestinationConfig(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     name: DestinationTypes = Field(..., description="Name of the destination")
+    alias: str = Field(
+        ...,
+        description="Alias of the destination, used for tracking the system name (ie bigquery for bigquery_streaming)",
+    )
     config: AbstractDestinationDetailsConfig = Field(..., description="Configuration for the destination")

bizon/destination/destination.py

@@ -10,6 +10,7 @@ from pydantic import BaseModel, Field
 from bizon.common.models import SyncMetadata
 from bizon.engine.backend.backend import AbstractBackend
 from bizon.engine.backend.models import JobStatus
+from bizon.monitoring.monitor import AbstractMonitor
 from bizon.source.callback import AbstractSourceCallback
 from bizon.source.config import SourceSyncModes
 
@@ -43,17 +44,18 @@ class DestinationIteration(BaseModel):
 
 
 class AbstractDestination(ABC):
-
     def __init__(
         self,
         sync_metadata: SyncMetadata,
         config: AbstractDestinationDetailsConfig,
         backend: AbstractBackend,
         source_callback: AbstractSourceCallback,
+        monitor: AbstractMonitor,
     ):
         self.sync_metadata = sync_metadata
         self.config = config
         self.backend = backend
+        self.monitor = monitor
         self.buffer = DestinationBuffer(
             buffer_size=self.config.buffer_size, buffer_flush_timeout=self.config.buffer_flush_timeout
         )
@@ -141,7 +143,6 @@ class AbstractDestination(ABC):
 
         # Last iteration, write all records to destination
         if last_iteration:
-
             if self.buffer.df_destination_records.height == 0 and self.buffer.is_empty:
                 logger.info("No records to write to destination, already written, buffer is empty.")
                 return DestinationBufferStatus.RECORDS_WRITTEN
@@ -191,6 +192,14 @@ class AbstractDestination(ABC):
         logger.info(
             f"Buffer ripeness {round(self.buffer.ripeness / 60, 2)} min. Max ripeness {round(self.buffer.buffer_flush_timeout / 60, 2)} min."  # noqa
         )
+        logger.info(
+            f"Current records size to process: {round(df_destination_records.estimated_size(unit='b') / 1024 / 1024, 2)} Mb."
+        )
+
+        if df_destination_records.estimated_size(unit="b") > self.buffer.buffer_size:
+            raise ValueError(
+                f"Records size {round(df_destination_records.estimated_size(unit='b') / 1024 / 1024, 2)} Mb is greater than buffer size {round(self.buffer.buffer_size / 1024 / 1024, 2)} Mb. Please increase destination buffer_size or reduce batch_size from the source."
+            )
 
         # Write buffer to destination if buffer is ripe and create a new buffer for the new iteration
         if self.buffer.is_ripe:
@@ -276,15 +285,19 @@ class DestinationFactory:
         config: AbstractDestinationConfig,
         backend: AbstractBackend,
         source_callback: AbstractSourceCallback,
+        monitor: AbstractMonitor,
     ) -> AbstractDestination:
-
         if config.name == DestinationTypes.LOGGER:
             from bizon.connectors.destinations.logger.src.destination import (
                 LoggerDestination,
             )
 
             return LoggerDestination(
-                sync_metadata=sync_metadata, config=config.config, backend=backend, source_callback=source_callback
+                sync_metadata=sync_metadata,
+                config=config.config,
+                backend=backend,
+                source_callback=source_callback,
+                monitor=monitor,
             )
 
         elif config.name == DestinationTypes.BIGQUERY:
@@ -293,7 +306,11 @@ class DestinationFactory:
             )
 
             return BigQueryDestination(
-                sync_metadata=sync_metadata, config=config.config, backend=backend, source_callback=source_callback
+                sync_metadata=sync_metadata,
+                config=config.config,
+                backend=backend,
+                source_callback=source_callback,
+                monitor=monitor,
             )
 
         elif config.name == DestinationTypes.BIGQUERY_STREAMING:
@@ -302,7 +319,11 @@ class DestinationFactory:
             )
 
             return BigQueryStreamingDestination(
-                sync_metadata=sync_metadata, config=config.config, backend=backend, source_callback=source_callback
+                sync_metadata=sync_metadata,
+                config=config.config,
+                backend=backend,
+                source_callback=source_callback,
+                monitor=monitor,
             )
 
         elif config.name == DestinationTypes.BIGQUERY_STREAMING_V2:
@@ -311,7 +332,11 @@ class DestinationFactory:
             )
 
             return BigQueryStreamingV2Destination(
-                sync_metadata=sync_metadata, config=config.config, backend=backend, source_callback=source_callback
+                sync_metadata=sync_metadata,
+                config=config.config,
+                backend=backend,
+                source_callback=source_callback,
+                monitor=monitor,
             )
 
         elif config.name == DestinationTypes.FILE:
@@ -320,7 +345,11 @@ class DestinationFactory:
             )
 
             return FileDestination(
-                sync_metadata=sync_metadata, config=config.config, backend=backend, source_callback=source_callback
+                sync_metadata=sync_metadata,
+                config=config.config,
+                backend=backend,
+                source_callback=source_callback,
+                monitor=monitor,
             )
 
-        raise ValueError(f"Destination {config.name}" f"with params {config} not found")
+        raise ValueError(f"Destination {config.name}with params {config} not found")

bizon/engine/backend/adapters/sqlalchemy/backend.py

@@ -5,7 +5,7 @@ from typing import Optional, Union
 from loguru import logger
 from pytz import UTC
 from sqlalchemy import Result, Select, create_engine, func, inspect, select, update
-from sqlalchemy.engine import Engine, create_engine
+from sqlalchemy.engine import Engine
 from sqlalchemy.orm import Session, scoped_session, sessionmaker
 
 from bizon.engine.backend.backend import AbstractBackend
@@ -26,7 +26,6 @@ from .config import BigQueryConfigDetails, PostgresConfigDetails, SQLiteConfigDe
 
 
 class SQLAlchemyBackend(AbstractBackend):
-
     def __init__(self, config: Union[PostgresConfigDetails, SQLiteConfigDetails], type: BackendTypes, **kwargs):
         super().__init__(config, type)
 
@@ -81,7 +80,6 @@ class SQLAlchemyBackend(AbstractBackend):
         )
 
     def _get_engine(self) -> Engine:
-
         if self.type == BackendTypes.BIGQUERY:
             return self._get_engine_bigquery()
 
@@ -96,7 +94,7 @@ class SQLAlchemyBackend(AbstractBackend):
         # ONLY FOR UNIT TESTS: SQLite in memory
         if self.type == BackendTypes.SQLITE_IN_MEMORY:
             return create_engine(
-                f"sqlite:///:memory:",
+                "sqlite:///:memory:",
                 echo=self.config.echoEngine,
                 connect_args={"check_same_thread": False},
             )
@@ -388,7 +386,6 @@ class SQLAlchemyBackend(AbstractBackend):
         pagination: Optional[dict] = None,
         session: Session | None = None,
     ) -> DestinationCursor:
-
         destination_cursor = DestinationCursor(
             name=name,
             source_name=source_name,

bizon/engine/backend/adapters/sqlalchemy/config.py

@@ -55,7 +55,6 @@ class SQLiteInMemoryConfig(AbstractBackendConfig):
 
 ## BIGQUERY ##
 class BigQueryConfigDetails(SQLAlchemyConfigDetails):
-
     database: str = Field(
         description="GCP Project name",
         default=...,

bizon/engine/config.py

@@ -23,7 +23,6 @@ from .runner.config import RunnerConfig, RunnerFuturesConfig, RunnerTypes
 
 
 class EngineConfig(BaseModel):
-
     # Forbid extra keys in the model
     model_config = ConfigDict(extra="forbid")
 

bizon/engine/engine.py

@@ -21,7 +21,6 @@ def replace_env_variables_in_config(config: dict) -> dict:
 class RunnerFactory:
     @staticmethod
     def create_from_config_dict(config: dict) -> AbstractRunner:
-
         # Replace env variables in config
         config = replace_env_variables_in_config(config=config)
 

bizon/engine/pipeline/consumer.py

@@ -36,7 +36,6 @@ class AbstractQueueConsumer(ABC):
         pass
 
     def process_queue_message(self, queue_message: QueueMessage) -> PipelineReturnStatus:
-
         # Apply the transformation
         try:
             df_source_records = self.transform.apply_transforms(df_source_records=queue_message.df_source_records)

bizon/engine/pipeline/producer.py

@@ -105,7 +105,6 @@ class Producer:
     def run(
         self, job_id: int, stop_event: Union[multiprocessing.synchronize.Event, threading.Event]
     ) -> PipelineReturnStatus:
-
         return_value: PipelineReturnStatus = PipelineReturnStatus.SUCCESS
 
         # Init queue
@@ -132,7 +131,6 @@ class Producer:
             return PipelineReturnStatus.BACKEND_ERROR
 
         while not cursor.is_finished:
-
             if stop_event.is_set():
                 logger.info("Stop event is set, terminating producer ...")
                 return PipelineReturnStatus.KILLED_BY_RUNNER
@@ -226,9 +224,7 @@ class Producer:
             items_in_queue = f"{self.queue.get_size()} items in queue." if self.queue.get_size() else ""
 
             logger.info(
-                (
-                    f"Iteration {cursor.iteration} finished in {datetime.now(tz=UTC) - timestamp_start_iteration}. {items_in_queue}"
-                )
+                f"Iteration {cursor.iteration} finished in {datetime.now(tz=UTC) - timestamp_start_iteration}. {items_in_queue}"
             )
 
         logger.info("Terminating destination ...")

bizon/engine/queue/adapters/kafka/config.py

@@ -1,4 +1,4 @@
-from typing import List, Literal
+from typing import Literal
 
 from pydantic import BaseModel, Field
 

bizon/engine/queue/adapters/kafka/queue.py

@@ -13,7 +13,6 @@ from .consumer import KafkaConsumer_
 
 
 class KafkaQueue(AbstractQueue):
-
     def __init__(self, config: KafkaConfigDetails) -> None:
         super().__init__(config)
         self.config: KafkaConfigDetails = config

bizon/engine/queue/adapters/python_queue/consumer.py

@@ -35,7 +35,6 @@ class PythonQueueConsumer(AbstractQueueConsumer):
         self.monitor.track_pipeline_status(PipelineReturnStatus.RUNNING)
 
     def run(self, stop_event: Union[threading.Event, multiprocessing.synchronize.Event]) -> PipelineReturnStatus:
-
         while True:
             # Handle kill signal from the runner
             if stop_event.is_set():

bizon/engine/queue/adapters/python_queue/queue.py

@@ -9,7 +9,6 @@ from bizon.destination.destination import AbstractDestination
 from bizon.engine.queue.config import QUEUE_TERMINATION, QueueMessage
 from bizon.engine.queue.queue import AbstractQueue, AbstractQueueConsumer
 from bizon.monitoring.monitor import AbstractMonitor
-from bizon.source.callback import AbstractSourceCallback
 from bizon.source.models import SourceIteration
 from bizon.transform.transform import Transform
 
@@ -18,7 +17,6 @@ from .consumer import PythonQueueConsumer
 
 
 class PythonQueue(AbstractQueue):
-
     def __init__(self, config: PythonQueueConfigDetails, **kwargs) -> None:
         super().__init__(config)
         self.config: PythonQueueConfigDetails = config

bizon/engine/queue/adapters/rabbitmq/consumer.py

@@ -24,7 +24,6 @@ class RabbitMQConsumer(AbstractQueueConsumer):
         channel.queue_declare(queue=self.config.queue.queue_name)
 
         for method_frame, properties, body in channel.consume(self.config.queue.queue_name):
-
             queue_message = QueueMessage.model_validate_json(body)
             if queue_message.signal == QUEUE_TERMINATION:
                 logger.info("Received termination signal, waiting for destination to close gracefully ...")

bizon/engine/queue/adapters/rabbitmq/queue.py

@@ -13,7 +13,6 @@ from .consumer import RabbitMQConsumer
 
 
 class RabbitMQ(AbstractQueue):
-
     def __init__(self, config: RabbitMQConfigDetails) -> None:
         super().__init__(config)
         self.config: RabbitMQConfigDetails = config

bizon/engine/queue/config.py

@@ -27,7 +27,6 @@ class QueueTypes(str, Enum):
 
 
 class AbastractQueueConfigDetails(BaseModel, ABC):
-
     # Forbid extra keys in the model
     model_config = ConfigDict(extra="forbid")
 
@@ -38,7 +37,6 @@ class AbastractQueueConfigDetails(BaseModel, ABC):
 
 
 class AbstractQueueConfig(BaseModel, ABC):
-
     # Forbid extra keys in the model
     model_config = ConfigDict(extra="forbid")
 

bizon/engine/runner/adapters/process.py

@@ -8,7 +8,6 @@ from bizon.engine.runner.runner import AbstractRunner
 
 
 class ProcessRunner(AbstractRunner):
-
     def __init__(self, config: dict):
         super().__init__(config)
 
@@ -36,7 +35,6 @@ class ProcessRunner(AbstractRunner):
         with concurrent.futures.ProcessPoolExecutor(
             max_workers=self.bizon_config.engine.runner.config.max_workers
         ) as executor:
-
             future_producer = executor.submit(
                 AbstractRunner.instanciate_and_run_producer,
                 self.bizon_config,