Flowfile 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

test_utils/s3/demo_data_generator.py

@@ -0,0 +1,186 @@
+import logging
+import io
+import os
+import tempfile
+import shutil
+import random
+from datetime import datetime, timedelta
+
+# Third-party libraries
+import boto3
+from botocore.client import Config
+import polars as pl
+import pyarrow as pa
+from pyarrow import parquet as pq
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# --- MinIO/S3 Configuration ---
+MINIO_HOST = os.environ.get("TEST_MINIO_HOST", "localhost")
+MINIO_PORT = int(os.environ.get("TEST_MINIO_PORT", 9000))
+MINIO_ACCESS_KEY = os.environ.get("TEST_MINIO_ACCESS_KEY", "minioadmin")
+MINIO_SECRET_KEY = os.environ.get("TEST_MINIO_SECRET_KEY", "minioadmin")
+MINIO_ENDPOINT_URL = f"http://{MINIO_HOST}:{MINIO_PORT}"
+
+# --- Data Generation Functions ---
+
+def _create_sales_data(s3_client, df: pl.DataFrame, bucket_name: str):
+    """
+    Creates partitioned Parquet files for the sales data based on year and month.
+    s3://data-lake/sales/year=YYYY/month=MM/
+    """
+    logger.info("Writing partitioned sales data...")
+    # Use Polars' built-in partitioning
+    # A temporary local directory is needed to stage the partitioned files before uploading
+    with tempfile.TemporaryDirectory() as temp_dir:
+        df.write_parquet(
+            temp_dir,
+            use_pyarrow=True,
+            pyarrow_options={"partition_cols": ["year", "month"]}
+        )
+        # Walk through the local directory and upload files to S3
+        for root, _, files in os.walk(temp_dir):
+            for file in files:
+                if file.endswith(".parquet"):
+                    local_path = os.path.join(root, file)
+                    # Construct the S3 key to match the desired structure
+                    relative_path = os.path.relpath(local_path, temp_dir)
+                    s3_key = f"data-lake/sales/{relative_path.replace(os.path.sep, '/')}"
+                    s3_client.upload_file(local_path, bucket_name, s3_key)
+    logger.info(f"Finished writing sales data to s3://{bucket_name}/data-lake/sales/")
+
+def _create_customers_data(s3_client, df: pl.DataFrame, bucket_name: str):
+    """
+    Creates a Parquet file for the customers data.
+    s3://data-lake/customers/
+    """
+    logger.info("Writing customers Parquet data...")
+    parquet_buffer = io.BytesIO()
+    df.write_parquet(parquet_buffer)
+    parquet_buffer.seek(0)
+    s3_client.put_object(
+        Bucket=bucket_name,
+        Key='data-lake/customers/customers.parquet',
+        Body=parquet_buffer.getvalue()
+    )
+    logger.info(f"Finished writing customers data to s3://{bucket_name}/data-lake/customers/")
+
+
+def _create_orders_data(s3_client, df: pl.DataFrame, bucket_name: str):
+    """
+    Creates a pipe-delimited CSV file for the orders data.
+    s3://raw-data/orders/
+    """
+    logger.info("Writing orders CSV data...")
+    csv_buffer = io.BytesIO()
+    # Write with pipe delimiter and header
+    df.write_csv(csv_buffer, separator="|")
+    csv_buffer.seek(0)
+    s3_client.put_object(
+        Bucket=bucket_name,
+        Key='raw-data/orders/orders.csv',
+        Body=csv_buffer.getvalue()
+    )
+    logger.info(f"Finished writing orders data to s3://{bucket_name}/raw-data/orders/")
+
+def _create_products_data(df: pl.DataFrame):
+    """
+    Creates a local Parquet file for the products data.
+    """
+    logger.info("Writing local products Parquet data...")
+    # Create a directory for local data if it doesn't exist
+    local_data_dir = "local_data"
+    os.makedirs(local_data_dir, exist_ok=True)
+    file_path = os.path.join(local_data_dir, "local_products.parquet")
+    df.write_parquet(file_path)
+    logger.info(f"Finished writing products data to {file_path}")
+
+
+def create_demo_data(endpoint_url: str, access_key: str, secret_key: str, bucket_name: str):
+    """
+    Populates a MinIO bucket with test data matching the schemas from the examples.
+    """
+    logger.info("🚀 Starting data population for flowfile examples...")
+    s3_client = boto3.client(
+        's3',
+        endpoint_url=endpoint_url,
+        aws_access_key_id=access_key,
+        aws_secret_access_key=secret_key,
+        config=Config(signature_version='s3v4'),
+        region_name='us-east-1'
+    )
+
+    # --- Generate Core DataFrames ---
+    DATA_SIZE = 15_000 # Increased data size for more variety
+    START_DATE = datetime(2022, 1, 1)
+    END_DATE = datetime(2024, 12, 31)
+    TOTAL_DAYS = (END_DATE - START_DATE).days
+
+    # States for region mapping
+    states = ["CA", "OR", "WA", "NY", "NJ", "PA", "TX", "FL", "GA", "IL", "OH", "MI"]
+
+    # Generate base sales data across multiple years
+    sales_data = {
+        "order_id": range(1, DATA_SIZE + 1),
+        "customer_id": [random.randint(100, 299) for _ in range(DATA_SIZE)],
+        "product_id": [random.randint(1, 100) for _ in range(DATA_SIZE)],
+        "order_date": [START_DATE + timedelta(days=random.randint(0, TOTAL_DAYS)) for _ in range(DATA_SIZE)],
+        "quantity": [random.randint(1, 5) for _ in range(DATA_SIZE)],
+        "unit_price": [round(random.uniform(10.0, 500.0), 2) for _ in range(DATA_SIZE)],
+        "discount_rate": [random.choice([0.0, 0.1, 0.15, 0.2, None]) for _ in range(DATA_SIZE)],
+        "status": [random.choice(["completed", "pending", "cancelled"]) for _ in range(DATA_SIZE)],
+        "customer_lifetime_value": [random.uniform(500, 20000) for _ in range(DATA_SIZE)],
+        "state": [random.choice(states) for _ in range(DATA_SIZE)],
+    }
+    sales_df = pl.from_dict(sales_data).with_columns([
+        pl.col("order_date").dt.year().alias("year"),
+        pl.col("order_date").dt.month().alias("month"),
+        # The 'amount' column in the example seems to be the price before discount
+        pl.col("unit_price").alias("amount")
+    ])
+
+    # Generate customers DataFrame
+    unique_customer_ids = sales_df["customer_id"].unique().to_list()
+    customers_df = pl.DataFrame({
+        "customer_id": unique_customer_ids,
+        "customer_segment": [random.choice(["VIP", "Regular", "New"]) for _ in unique_customer_ids]
+    })
+
+    # Generate products DataFrame
+    unique_product_ids = sales_df["product_id"].unique().to_list()
+    # Create a map of product_id to unit_price from the first occurrence in sales_df
+    product_price_map = sales_df.group_by("product_id").agg(pl.first("unit_price")).to_dict(as_series=False)
+    price_dict = dict(zip(product_price_map['product_id'], product_price_map['unit_price']))
+
+    products_df = pl.DataFrame({
+        "product_id": unique_product_ids,
+        "product_category": [random.choice(["Electronics", "Books", "Clothing", "Home Goods"]) for _ in unique_product_ids],
+        "unit_price": [price_dict.get(pid) for pid in unique_product_ids]
+    })
+
+    # Generate orders DataFrame for the CSV file (subset of sales)
+    orders_df = sales_df.select(["customer_id", "product_id", "quantity", "discount_rate"])
+
+    logger.info(f"Generated {len(sales_df)} sales records across {sales_df['year'].n_unique()} years, for {len(customers_df)} customers, and {len(products_df)} products.")
+
+    # --- Write Data to S3 and Local Filesystem ---
+    _create_sales_data(s3_client, sales_df, bucket_name)
+    _create_customers_data(s3_client, customers_df, bucket_name)
+    _create_orders_data(s3_client, orders_df, bucket_name)
+    _create_products_data(products_df)
+
+    logger.info("✅ All test data populated successfully.")
+
+
+if __name__ == '__main__':
+    # The bucket that will be created and populated
+    BUCKET = "flowfile-demo-data"
+
+    create_demo_data(
+        endpoint_url=MINIO_ENDPOINT_URL,
+        access_key=MINIO_ACCESS_KEY,
+        secret_key=MINIO_SECRET_KEY,
+        bucket_name=BUCKET
+    )

test_utils/s3/fixtures.py

@@ -0,0 +1,214 @@
+import os
+import time
+import subprocess
+import logging
+from contextlib import contextmanager
+from typing import Dict, Generator
+import shutil
+import boto3
+from botocore.client import Config
+from test_utils.s3.data_generator import populate_test_data
+from test_utils.s3.demo_data_generator import create_demo_data
+
+logger = logging.getLogger("s3_fixture")
+
+MINIO_HOST = os.environ.get("TEST_MINIO_HOST", "localhost")
+MINIO_PORT = int(os.environ.get("TEST_MINIO_PORT", 9000))
+MINIO_CONSOLE_PORT = int(os.environ.get("TEST_MINIO_CONSOLE_PORT", 9001))
+MINIO_ACCESS_KEY = os.environ.get("TEST_MINIO_ACCESS_KEY", "minioadmin")
+MINIO_SECRET_KEY = os.environ.get("TEST_MINIO_SECRET_KEY", "minioadmin")
+MINIO_CONTAINER_NAME = os.environ.get("TEST_MINIO_CONTAINER", "test-minio-s3")
+MINIO_ENDPOINT_URL = f"http://{MINIO_HOST}:{MINIO_PORT}"
+
+# Operating system detection
+IS_MACOS = os.uname().sysname == 'Darwin' if hasattr(os, 'uname') else False
+IS_WINDOWS = os.name == 'nt'
+
+def get_minio_client():
+    """Get boto3 client for MinIO"""
+    return boto3.client(
+        's3',
+        endpoint_url=MINIO_ENDPOINT_URL,
+        aws_access_key_id=MINIO_ACCESS_KEY,
+        aws_secret_access_key=MINIO_SECRET_KEY,
+        config=Config(signature_version='s3v4'),
+        region_name='us-east-1'
+    )
+
+
+def wait_for_minio(max_retries=30, interval=1):
+    """Wait for MinIO to be ready"""
+    for i in range(max_retries):
+        try:
+            client = get_minio_client()
+            client.list_buckets()
+            logger.info("MinIO is ready")
+            return True
+        except Exception:
+            if i < max_retries - 1:
+                time.sleep(interval)
+            continue
+    return False
+
+def is_container_running(container_name: str) -> bool:
+    """Check if MinIO container is already running"""
+    try:
+        result = subprocess.run(
+            ["docker", "ps", "--filter", f"name={container_name}", "--format", "{{.Names}}"],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return container_name in result.stdout.strip()
+    except subprocess.CalledProcessError:
+        return False
+
+
+def stop_minio_container() -> bool:
+    """Stop the MinIO container and remove its data volume for a clean shutdown."""
+    container_name = MINIO_CONTAINER_NAME
+    volume_name = f"{container_name}-data"
+
+    if not is_container_running(container_name):
+        logger.info(f"Container '{container_name}' is not running.")
+        # Attempt to remove the volume in case it was left orphaned
+        try:
+            subprocess.run(["docker", "volume", "rm", volume_name], check=False, capture_output=True)
+        except Exception:
+            pass  # Ignore errors if volume doesn't exist
+        return True
+
+    logger.info(f"Stopping and cleaning up container '{container_name}' and volume '{volume_name}'...")
+    try:
+        # Stop and remove the container
+        subprocess.run(["docker", "stop", container_name], check=True, capture_output=True)
+        subprocess.run(["docker", "rm", container_name], check=True, capture_output=True)
+
+        # Remove the associated volume to clear all data
+        subprocess.run(["docker", "volume", "rm", volume_name], check=True, capture_output=True)
+
+        logger.info("✅ MinIO container and data volume successfully removed.")
+        return True
+    except subprocess.CalledProcessError as e:
+        stderr = e.stderr.decode()
+        if "no such volume" in stderr:
+            logger.info("Volume was already removed or never created.")
+            return True
+        logger.error(f"❌ Failed to clean up MinIO resources: {stderr}")
+        return False
+
+
+def create_test_buckets():
+    """Create test buckets and populate with sample data"""
+    client = get_minio_client()
+
+    # Create test buckets
+    buckets = ['test-bucket', 'flowfile-test', 'sample-data', 'worker-test-bucket', 'demo-bucket']
+    for bucket in buckets:
+        try:
+            client.create_bucket(Bucket=bucket)
+            logger.info(f"Created bucket: {bucket}")
+        except client.exceptions.BucketAlreadyExists:
+            logger.info(f"Bucket already exists: {bucket}")
+        except client.exceptions.BucketAlreadyOwnedByYou:
+            logger.info(f"Bucket already owned: {bucket}")
+
+
+def is_docker_available() -> bool:
+    """
+    Check if Docker is available on the system.
+
+    Returns:
+        bool: True if Docker is available and working, False otherwise
+    """
+    # Skip Docker on macOS and Windows in CI
+    if (IS_MACOS or IS_WINDOWS) and os.environ.get('CI', '').lower() in ('true', '1', 'yes'):
+        logger.info("Skipping Docker on macOS/Windows in CI environment")
+        return False
+
+    # If docker executable is not in PATH
+    if shutil.which("docker") is None:
+        logger.warning("Docker executable not found in PATH")
+        return False
+
+    # Try a simple docker command
+    try:
+        result = subprocess.run(
+            ["docker", "info"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=5,
+            check=False  # Don't raise exception on non-zero return code
+        )
+
+        if result.returncode != 0:
+            logger.warning("Docker is not operational")
+            return False
+
+        return True
+    except (subprocess.SubprocessError, OSError):
+        logger.warning("Error running Docker command")
+        return False
+
+
+def start_minio_container() -> bool:
+    """Start MinIO container with initialization"""
+    if is_container_running(MINIO_CONTAINER_NAME):
+        logger.info(f"Container {MINIO_CONTAINER_NAME} is already running")
+        return True
+
+    try:
+        # Start MinIO with volume for persistence
+        subprocess.run([
+            "docker", "run", "-d",
+            "--name", MINIO_CONTAINER_NAME,
+            "-p", f"{MINIO_PORT}:9000",
+            "-p", f"{MINIO_CONSOLE_PORT}:9001",
+            "-e", f"MINIO_ROOT_USER={MINIO_ACCESS_KEY}",
+            "-e", f"MINIO_ROOT_PASSWORD={MINIO_SECRET_KEY}",
+            "-v", f"{MINIO_CONTAINER_NAME}-data:/data",
+            "minio/minio", "server", "/data", "--console-address", ":9001"
+        ], check=True)
+
+        # Wait for MinIO to be ready
+        if wait_for_minio():
+            create_test_buckets()
+            populate_test_data(endpoint_url=MINIO_ENDPOINT_URL,
+                               access_key=MINIO_ACCESS_KEY,
+                               secret_key=MINIO_SECRET_KEY,
+                               bucket_name="test-bucket")
+            create_demo_data(endpoint_url=MINIO_ENDPOINT_URL,
+                               access_key=MINIO_ACCESS_KEY,
+                               secret_key=MINIO_SECRET_KEY,
+                               bucket_name="demo-bucket")
+            return True
+        return False
+
+    except Exception as e:
+        logger.error(f"Failed to start MinIO: {e}")
+        stop_minio_container()
+        return False
+
+
+@contextmanager
+def managed_minio() -> Generator[Dict[str, any], None, None]:
+    """Context manager for MinIO container with full connection info"""
+    if not start_minio_container():
+        yield {}
+        return
+
+    try:
+        connection_info = {
+            "endpoint_url": MINIO_ENDPOINT_URL,
+            "access_key": MINIO_ACCESS_KEY,
+            "secret_key": MINIO_SECRET_KEY,
+            "host": MINIO_HOST,
+            "port": MINIO_PORT,
+            "console_port": MINIO_CONSOLE_PORT,
+            "connection_string": f"s3://{MINIO_ACCESS_KEY}:{MINIO_SECRET_KEY}@{MINIO_HOST}:{MINIO_PORT}"
+        }
+        yield connection_info
+    finally:
+        # Optionally keep container running for debugging
+        if os.environ.get("KEEP_MINIO_RUNNING", "false").lower() != "true":
+            stop_minio_container()

flowfile/web/static/assets/AirbyteReader-1ac35765.css

@@ -1,314 +0,0 @@
-
-/* Array input styles */
-.array-input-section[data-v-b2f2d704] {
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
-}
-.input-with-button[data-v-b2f2d704] {
-  display: flex;
-  gap: 8px;
-  align-items: center;
-}
-.items-container[data-v-b2f2d704] {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 10px; /* Space between items */
-}
-.item-box[data-v-b2f2d704] {
-  display: flex;
-  align-items: center;
-  padding: 5px 10px;
-  background-color: #f0f0f0;
-  border-radius: 4px;
-  font-size: 12px;
-  position: relative;
-}
-.remove-btn[data-v-b2f2d704] {
-  margin-left: 8px;
-  cursor: pointer;
-  color: #100f0f72;
-  font-weight: bold;
-}
-.add-btn[data-v-b2f2d704] {
-  padding: 4px 12px;
-  background: #7878ff5b;
-  border: none;
-  border-radius: 3px;
-  cursor: pointer;
-  font-size: 12px;
-  transition: background-color 0.2s;
-  white-space: nowrap;
-}
-.add-btn[data-v-b2f2d704]:hover {
-  background: #6363ff5b;
-}
-
-/* Your existing styles */
-.form-container[data-v-b2f2d704] {
-  font-family: -apple-system, BlinkMacSystemFont, sans-serif;
-  font-size: 13px;
-  color: #333;
-}
-.form-grid[data-v-b2f2d704] {
-  display: grid;
-  gap: 8px;
-  padding: 12px;
-  background: #fff;
-  border: 1px solid #eee;
-  border-radius: 4px;
-}
-.form-item-wrapper[data-v-b2f2d704] {
-  margin-bottom: 2px;
-}
-.single-item[data-v-b2f2d704] {
-  margin-bottom: 4px;
-}
-.compact-header[data-v-b2f2d704] {
-  font-size: 12px;
-  color: #666;
-  margin-bottom: 2px;
-  display: flex;
-  align-items: center;
-  gap: 4px;
-}
-.minimal-header[data-v-b2f2d704] {
-  width: 100%;
-  text-align: left;
-  padding: 6px 8px;
-  background: #f5f5f5;
-  border: 1px solid #eee;
-  border-radius: 3px;
-  font-size: 12px;
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  cursor: pointer;
-  transition: background 0.2s;
-}
-.minimal-header[data-v-b2f2d704]:hover {
-  background: #f0f0f0;
-}
-.minimal-header.is-open[data-v-b2f2d704] {
-  border-bottom-left-radius: 0;
-  border-bottom-right-radius: 0;
-}
-.minimal-chevron[data-v-b2f2d704] {
-  font-size: 14px;
-  color: #999;
-  width: 12px;
-}
-.tag[data-v-b2f2d704] {
-  color: #ff4757;
-  font-size: 14px;
-}
-.type-indicator[data-v-b2f2d704] {
-  color: #999;
-  font-size: 11px;
-}
-.nested-content[data-v-b2f2d704] {
-  padding: 8px;
-  border: 1px solid #eee;
-  border-top: none;
-  background: #fff;
-  border-bottom-left-radius: 3px;
-  border-bottom-right-radius: 3px;
-}
-.nested-item[data-v-b2f2d704] {
-  margin-bottom: 6px;
-}
-.nested-item[data-v-b2f2d704]:last-child {
-  margin-bottom: 0;
-}
-.minimal-input[data-v-b2f2d704] {
-  box-sizing: border-box; /* Add this to include padding in width calculation */
-  width: 100%;
-  padding: 4px 8px;
-  border: 1px solid #ddd;
-  border-radius: 3px;
-  font-size: 12px;
-  background: #fff;
-  transition: border 0.2s;
-}
-.minimal-input[data-v-b2f2d704]:focus {
-  outline: none;
-  border-color: #666;
-}
-.minimal-input[data-v-b2f2d704]::placeholder {
-  color: #ccc;
-}
-.minimal-popover[data-v-b2f2d704] {
-  position: fixed;
-  background: rgba(0, 0, 0, 0.8);
-  color: #fff;
-  padding: 4px 8px;
-  border-radius: 3px;
-  font-size: 12px;
-  max-width: 250px;
-  z-index: 100;
-  pointer-events: none;
-}
-@media (max-width: 640px) {
-.form-grid[data-v-b2f2d704] {
-    padding: 8px;
-    gap: 6px;
-}
-.minimal-header[data-v-b2f2d704] {
-    padding: 4px 6px;
-}
-.minimal-input[data-v-b2f2d704] {
-    padding: 3px 6px;
-}
-}
-
-.to-front[data-v-9dcbd94f] {
-  z-index: 1000;
-}
-.config-section[data-v-9dcbd94f] {
-  margin-top: 16px;
-}
-.stream-section[data-v-9dcbd94f] {
-  margin-top: 16px;
-}
-.stream-select[data-v-9dcbd94f] {
-  width: 100%;
-  max-width: 400px;
-}
-.icon-button[data-v-9dcbd94f] {
-  padding: 2px;
-  border: none;
-  background: none;
-  cursor: pointer;
-  color: #666;
-}
-.icon-button[data-v-9dcbd94f]:hover {
-  color: #333;
-}
-.primary-button[data-v-9dcbd94f] {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  cursor: pointer;
-  padding: 8px 16px;
-  background-color: #7878ff5b;
-  border: none;
-  border-radius: 4px;
-  font-size: 13px;
-  transition: background-color 0.3s ease;
-}
-.primary-button[data-v-9dcbd94f]:hover:not(:disabled) {
-  background-color: #b3b5ba;
-}
-.primary-button[data-v-9dcbd94f]:disabled {
-  opacity: 0.6;
-  cursor: not-allowed;
-}
-.secondary-button[data-v-9dcbd94f] {
-  display: inline-flex;
-  align-items: center;
-  gap: 4px;
-  padding: 4px 8px;
-  background-color: #f1f1f1;
-  border: 1px solid #ddd;
-  border-radius: 4px;
-  font-size: 12px;
-  color: #666;
-  transition: all 0.2s ease;
-}
-.secondary-button[data-v-9dcbd94f]:hover {
-  background-color: #e4e4e4;
-  color: #333;
-}
-.validation-banner[data-v-9dcbd94f] {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  padding: 12px;
-  margin-top: 12px;
-  border-radius: 4px;
-  font-size: 14px;
-}
-.validation-banner.success[data-v-9dcbd94f] {
-  background-color: #ecfdf5;
-  color: #047857;
-}
-.validation-banner.error[data-v-9dcbd94f] {
-  background-color: #fef2f2;
-  color: #dc2626;
-}
-.spin[data-v-9dcbd94f] {
-  animation: spin-9dcbd94f 1s linear infinite;
-}
-@keyframes spin-9dcbd94f {
-from {
-    transform: rotate(0deg);
-}
-to {
-    transform: rotate(360deg);
-}
-}
-.file-upload-label[data-v-9dcbd94f] {
-  display: flex;
-  align-items: center;
-  justify-content: flex-start;
-  background-color: #f5f5f5;
-  border: 1px solid #ddd;
-  border-radius: 4px;
-  padding: 10px 15px;
-  color: #333;
-  font-size: 16px;
-  font-weight: 500;
-  text-align: left;
-  user-select: none;
-  cursor: pointer;
-  transition: background-color 0.3s ease;
-}
-.file-upload-label[data-v-9dcbd94f]:hover {
-  background-color: #e4e4e4;
-}
-.file-icon[data-v-9dcbd94f] {
-  margin-right: 10px;
-  font-size: 20px;
-  width: 24px;
-  height: auto;
-}
-.attention-notice[data-v-9dcbd94f] {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  padding: 4px 8px;
-  border-radius: 4px;
-  width: fit-content;
-  margin-top: 4px;
-}
-.docker-notice[data-v-9dcbd94f] {
-  font-size: 12px;
-  font-weight: 600;
-}
-.warning-icon[data-v-9dcbd94f] {
-  font-size: 14px;
-  animation: pulse-9dcbd94f 2s infinite;
-}
-.flex[data-v-9dcbd94f] {
-  display: flex;
-}
-.justify-between[data-v-9dcbd94f] {
-  justify-content: space-between;
-}
-.items-center[data-v-9dcbd94f] {
-  align-items: center;
-}
-.gap-2[data-v-9dcbd94f] {
-  gap: 8px;
-}
-@keyframes pulse-9dcbd94f {
-0% {
-    opacity: 1;
-}
-50% {
-    opacity: 0.5;
-}
-100% {
-    opacity: 1;
-}
-}