vizflow 0.3.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

vizflow/__init__.py

@@ -5,8 +5,10 @@ Usage:
     import vizflow as vf
 """
 
-__version__ = "0.3.0"
+__version__ = "0.4.1"
 
-from .config import Config
+from .config import ColumnSchema, Config, get_config, set_config
+from .io import load_alpha, load_calendar, load_trade, scan_trade, scan_trades
 from .market import CN, CRYPTO, Market, Session
 from .ops import aggregate, bin, parse_time
+from .presets import YLIN

vizflow/config.py

@@ -4,6 +4,25 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Any
+
+# Global config instance
+_global_config: Config | None = None
+
+
+@dataclass
+class ColumnSchema:
+    """Schema for a column with type casting.
+
+    Attributes:
+        cast_to: Target type after casting (e.g. pl.Int64)
+
+    Example:
+        # Handle float precision errors: 1.00000002 → 1
+        ColumnSchema(cast_to=pl.Int64)
+    """
+
+    cast_to: Any  # pl.DataType, but avoid import for now
 
 
 @dataclass
@@ -11,63 +30,173 @@ class Config:
     """Central configuration for a pipeline run.
 
     Attributes:
-        input_dir: Directory containing input files
-        output_dir: Directory for output files
-        input_pattern: Pattern for input files, e.g. "{date}.feather"
-        market: Market identifier, e.g. "CN", "crypto"
-        columns: Mapping from semantic names to actual column names
+        alpha_dir: Directory containing alpha files
+        alpha_pattern: Pattern for alpha files, e.g. "alpha_{date}.feather"
+        trade_dir: Directory containing trade files
+        trade_pattern: Pattern for trade files, e.g. "trade_{date}.feather"
+        calendar_path: Path to calendar parquet file
+        replay_dir: Directory for FIFO replay output (materialization 1)
+        aggregate_dir: Directory for aggregation output (materialization 2)
+        market: Market identifier, e.g. "CN"
+        alpha_columns: Mapping from semantic names to alpha column names
+        trade_columns: Mapping from semantic names to trade column names
+        alpha_schema: Schema evolution for alpha columns
+        trade_schema: Schema evolution for trade columns
         binwidths: Mapping from column names to bin widths
+        group_by: Columns to group by in aggregation
         horizons: List of forward return horizons in seconds
         time_cutoff: Optional time cutoff (e.g. 143000000 for 14:30:00)
     """
 
-    input_dir: Path
-    output_dir: Path
-    input_pattern: str = "{date}.feather"
+    # === Input Paths ===
+    alpha_dir: Path | None = None
+    alpha_pattern: str = "alpha_{date}.feather"
+    trade_dir: Path | None = None
+    trade_pattern: str = "trade_{date}.feather"
+    calendar_path: Path | None = None
+
+    # === Output Paths ===
+    replay_dir: Path | None = None      # FIFO output (materialization 1)
+    aggregate_dir: Path | None = None   # Aggregation output (materialization 2)
+
+    # === Market ===
     market: str = "CN"
-    columns: dict[str, str] = field(default_factory=dict)
+
+    # === Column Mapping ===
+    alpha_columns: dict[str, str] = field(default_factory=dict)
+    trade_columns: dict[str, str] = field(default_factory=dict)
+
+    # === Schema Evolution ===
+    alpha_schema: dict[str, ColumnSchema] = field(default_factory=dict)
+    trade_schema: dict[str, ColumnSchema] = field(default_factory=dict)
+
+    # === Column Mapping ===
+    column_preset: str | None = None  # "ylin" or None
+    column_rename: dict[str, str] = field(default_factory=dict)  # Custom rename map
+
+    # === Aggregation ===
     binwidths: dict[str, float] = field(default_factory=dict)
     group_by: list[str] = field(default_factory=list)
+
+    # === Analysis ===
     horizons: list[int] = field(default_factory=list)
     time_cutoff: int | None = None
 
     def __post_init__(self):
         """Convert paths to Path objects if needed."""
-        if isinstance(self.input_dir, str):
-            self.input_dir = Path(self.input_dir)
-        if isinstance(self.output_dir, str):
-            self.output_dir = Path(self.output_dir)
-
-    def col(self, semantic: str) -> str:
+        if isinstance(self.alpha_dir, str):
+            self.alpha_dir = Path(self.alpha_dir)
+        if isinstance(self.trade_dir, str):
+            self.trade_dir = Path(self.trade_dir)
+        if isinstance(self.calendar_path, str):
+            self.calendar_path = Path(self.calendar_path)
+        if isinstance(self.replay_dir, str):
+            self.replay_dir = Path(self.replay_dir)
+        if isinstance(self.aggregate_dir, str):
+            self.aggregate_dir = Path(self.aggregate_dir)
+
+    def col(self, semantic: str, source: str = "trade") -> str:
         """Get actual column name from semantic name.
 
         Args:
             semantic: Semantic column name (e.g. "timestamp", "price")
+            source: "alpha" or "trade"
 
         Returns:
             Actual column name, or the semantic name if no mapping exists
         """
-        return self.columns.get(semantic, semantic)
+        if source == "alpha":
+            return self.alpha_columns.get(semantic, semantic)
+        return self.trade_columns.get(semantic, semantic)
 
-    def get_input_path(self, date: str) -> Path:
-        """Get input file path for a date.
+    def get_alpha_path(self, date: str) -> Path:
+        """Get alpha file path for a date.
 
         Args:
             date: Date string, e.g. "20241001"
 
         Returns:
-            Full path to input file
+            Full path to alpha file
+
+        Raises:
+            ValueError: If alpha_dir is not set
         """
-        return self.input_dir / self.input_pattern.format(date=date)
+        if self.alpha_dir is None:
+            raise ValueError("alpha_dir is not set in Config")
+        return self.alpha_dir / self.alpha_pattern.format(date=date)
 
-    def get_output_path(self, date: str, suffix: str = ".parquet") -> Path:
-        """Get output file path for a date.
+    def get_trade_path(self, date: str) -> Path:
+        """Get trade file path for a date.
+
+        Args:
+            date: Date string, e.g. "20241001"
+
+        Returns:
+            Full path to trade file
+
+        Raises:
+            ValueError: If trade_dir is not set
+        """
+        if self.trade_dir is None:
+            raise ValueError("trade_dir is not set in Config")
+        return self.trade_dir / self.trade_pattern.format(date=date)
+
+    def get_replay_path(self, date: str, suffix: str = ".parquet") -> Path:
+        """Get replay output file path for a date (FIFO results).
+
+        Args:
+            date: Date string, e.g. "20241001"
+            suffix: File suffix, default ".parquet"
+
+        Returns:
+            Full path to replay output file
+
+        Raises:
+            ValueError: If replay_dir is not set
+        """
+        if self.replay_dir is None:
+            raise ValueError("replay_dir is not set in Config")
+        return self.replay_dir / f"{date}{suffix}"
+
+    def get_aggregate_path(self, date: str, suffix: str = ".parquet") -> Path:
+        """Get aggregate output file path for a date (partial results).
 
         Args:
             date: Date string, e.g. "20241001"
             suffix: File suffix, default ".parquet"
 
         Returns:
-            Full path to output file
+            Full path to aggregate output file
+
+        Raises:
+            ValueError: If aggregate_dir is not set
         """
-        return self.output_dir / f"{date}{suffix}"
+        if self.aggregate_dir is None:
+            raise ValueError("aggregate_dir is not set in Config")
+        return self.aggregate_dir / f"{date}{suffix}"
+
+
+def set_config(config: Config) -> None:
+    """Set the global config.
+
+    Args:
+        config: Config instance to set as global
+    """
+    global _global_config
+    _global_config = config
+
+
+def get_config() -> Config:
+    """Get the global config.
+
+    Returns:
+        The global Config instance
+
+    Raises:
+        RuntimeError: If config has not been set via set_config()
+    """
+    if _global_config is None:
+        raise RuntimeError(
+            "Config not set. Call vf.set_config(config) first."
+        )
+    return _global_config

vizflow/io.py

@@ -0,0 +1,239 @@
+"""I/O functions for VizFlow with automatic schema evolution."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import polars as pl
+
+from .config import Config, get_config
+
+if TYPE_CHECKING:
+    pass
+
+
+def load_alpha(date: str, config: Config | None = None) -> pl.LazyFrame:
+    """Load alpha data for a date with automatic schema evolution.
+
+    Args:
+        date: Date string, e.g. "20241001"
+        config: Config to use, or get_config() if None
+
+    Returns:
+        LazyFrame with schema evolution applied
+
+    Example:
+        >>> config = vf.Config(
+        ...     output_dir=Path("/data/output"),
+        ...     alpha_dir=Path("/data/alpha"),
+        ...     alpha_schema={"qty": vf.ColumnSchema(cast_to=pl.Int64)}
+        ... )
+        >>> vf.set_config(config)
+        >>> alpha = vf.load_alpha("20241001")
+    """
+    config = config or get_config()
+    path = config.get_alpha_path(date)
+    df = pl.scan_ipc(path)
+
+    # Apply schema evolution (type casting)
+    for col_name, schema in config.alpha_schema.items():
+        df = df.with_columns(pl.col(col_name).cast(schema.cast_to))
+
+    return df
+
+
+def load_trade(date: str, config: Config | None = None) -> pl.LazyFrame:
+    """Load trade data for a date with automatic schema evolution.
+
+    Args:
+        date: Date string, e.g. "20241001"
+        config: Config to use, or get_config() if None
+
+    Returns:
+        LazyFrame with schema evolution applied
+
+    Example:
+        >>> config = vf.Config(
+        ...     output_dir=Path("/data/output"),
+        ...     trade_dir=Path("/data/trade"),
+        ...     trade_schema={"qty": vf.ColumnSchema(cast_to=pl.Int64)}
+        ... )
+        >>> vf.set_config(config)
+        >>> trade = vf.load_trade("20241001")  # qty: 1.00000002 → 1
+    """
+    config = config or get_config()
+    path = config.get_trade_path(date)
+    df = pl.scan_ipc(path)
+
+    # Apply schema evolution (type casting)
+    for col_name, schema in config.trade_schema.items():
+        df = df.with_columns(pl.col(col_name).cast(schema.cast_to))
+
+    return df
+
+
+def load_calendar(config: Config | None = None) -> pl.DataFrame:
+    """Load trading calendar.
+
+    Args:
+        config: Config to use, or get_config() if None
+
+    Returns:
+        DataFrame with date, prev_date, next_date columns
+
+    Raises:
+        ValueError: If calendar_path is not set in config
+
+    Example:
+        >>> config = vf.Config(
+        ...     output_dir=Path("/data/output"),
+        ...     calendar_path=Path("/data/calendar.parquet")
+        ... )
+        >>> vf.set_config(config)
+        >>> calendar = vf.load_calendar()
+    """
+    config = config or get_config()
+    if config.calendar_path is None:
+        raise ValueError("calendar_path is not set in Config")
+    return pl.read_parquet(config.calendar_path)
+
+
+def _scan_file(path) -> pl.LazyFrame:
+    """Scan a file based on its extension.
+
+    Args:
+        path: Path to file
+
+    Returns:
+        LazyFrame from the file
+
+    Supported formats:
+        - .feather, .ipc, .arrow: IPC format (pl.scan_ipc)
+        - .csv, .meords: CSV format (pl.scan_csv)
+        - .parquet: Parquet format (pl.scan_parquet)
+    """
+    suffix = str(path).lower().split(".")[-1]
+
+    if suffix in ("feather", "ipc", "arrow"):
+        return pl.scan_ipc(path)
+    elif suffix in ("csv", "meords"):
+        return pl.scan_csv(path)
+    elif suffix == "parquet":
+        return pl.scan_parquet(path)
+    else:
+        # Default to IPC
+        return pl.scan_ipc(path)
+
+
+def scan_trade(date: str, config: Config | None = None) -> pl.LazyFrame:
+    """Scan single date trade file with column mapping.
+
+    Supports both IPC/feather format and CSV format (including .meords files).
+
+    Args:
+        date: Date string, e.g. "20241001"
+        config: Config to use, or get_config() if None
+
+    Returns:
+        LazyFrame with column mapping and schema evolution applied
+
+    Example:
+        >>> config = vf.Config(
+        ...     trade_dir=Path("/data/yuanzhao/"),
+        ...     trade_pattern="{date}.meords",
+        ...     column_preset="ylin",
+        ... )
+        >>> vf.set_config(config)
+        >>> df = vf.scan_trade("20241001")
+    """
+    config = config or get_config()
+    path = config.get_trade_path(date)
+    df = _scan_file(path)
+    return _apply_mapping(df, config)
+
+
+def scan_trades(config: Config | None = None) -> pl.LazyFrame:
+    """Scan all trade files with column mapping.
+
+    Args:
+        config: Config to use, or get_config() if None
+
+    Returns:
+        LazyFrame with column mapping and schema evolution applied
+
+    Raises:
+        ValueError: If trade_dir is not set or no files found
+
+    Example:
+        >>> config = vf.Config(
+        ...     trade_dir=Path("/data/yuanzhao/"),
+        ...     trade_pattern="{date}.feather",
+        ...     column_preset="ylin",
+        ... )
+        >>> vf.set_config(config)
+        >>> df = vf.scan_trades()
+    """
+    config = config or get_config()
+    if config.trade_dir is None:
+        raise ValueError("trade_dir is not set in Config")
+
+    pattern = config.trade_pattern.replace("{date}", "*")
+    files = sorted(config.trade_dir.glob(pattern))
+    if not files:
+        raise ValueError(f"No files found matching {pattern} in {config.trade_dir}")
+
+    # Concatenate all files using lazy scanning
+    dfs = [_scan_file(f) for f in files]
+    df = pl.concat(dfs)
+    return _apply_mapping(df, config)
+
+
+def _apply_mapping(df: pl.LazyFrame, config: Config) -> pl.LazyFrame:
+    """Apply column rename + schema evolution.
+
+    Args:
+        df: Input LazyFrame
+        config: Config with mapping settings
+
+    Returns:
+        LazyFrame with mapping applied
+    """
+    # Drop record type prefix column if present (from CSV files)
+    existing = set(df.collect_schema().names())
+    if "#HFTORD" in existing:
+        df = df.drop("#HFTORD")
+        existing.remove("#HFTORD")
+
+    # Get rename map from preset or custom
+    rename_map = _get_rename_map(config)
+
+    if rename_map:
+        existing = set(df.collect_schema().names())
+        to_rename = {k: v for k, v in rename_map.items() if k in existing}
+        if to_rename:
+            df = df.rename(to_rename)
+
+    # Schema evolution (type casting) - use renamed column names
+    for col_name, schema in config.trade_schema.items():
+        df = df.with_columns(pl.col(col_name).cast(schema.cast_to))
+
+    return df
+
+
+def _get_rename_map(config: Config) -> dict[str, str]:
+    """Get rename map from preset name or custom dict.
+
+    Args:
+        config: Config with column_preset or column_rename
+
+    Returns:
+        Dict mapping old column names to new names
+    """
+    if config.column_rename:
+        return config.column_rename
+    if config.column_preset:
+        from .presets import YLIN
+
+        presets = {"ylin": YLIN}
+        return presets.get(config.column_preset.lower(), {})
+    return {}

vizflow/ops.py

@@ -4,61 +4,90 @@ from __future__ import annotations
 
 import polars as pl
 
-from .market import Market
+from .config import get_config
 
 
 def parse_time(
     df: pl.LazyFrame,
-    market: Market,
-    timestamp_col: str = "timestamp",
+    timestamp_col: str = "ticktime",
 ) -> pl.LazyFrame:
-    """Add elapsed_seconds column based on market sessions.
+    """Parse HHMMSSMMM timestamp to time-of-day and elapsed milliseconds.
+
+    Adds two columns:
+    - tod_{timestamp_col}: pl.Time (time-of-day HH:MM:SS.mmm) - good for plotting
+    - elapsed_{timestamp_col}: pl.Int64 (milliseconds since market open)
 
     Args:
         df: Input LazyFrame
-        market: Market definition (only CN supported)
-        timestamp_col: Column with integer timestamp (H/HHMMSSMMM format)
+        timestamp_col: Column with integer HHMMSSMMM format timestamps
             e.g., 93012145 = 09:30:12.145, 142058425 = 14:20:58.425
 
     Returns:
-        LazyFrame with elapsed_seconds column (float, includes milliseconds)
-        e.g., 09:30:12.145 → 12.145 (12 seconds + 145ms into trading)
+        LazyFrame with tod and elapsed columns added
 
     Raises:
+        RuntimeError: If config not set via set_config()
         NotImplementedError: If market is not CN
+
+    Example:
+        >>> config = vf.Config(market="CN", input_dir=".", output_dir=".")
+        >>> vf.set_config(config)
+        >>> df = vf.parse_time(df, "ticktime")
+        >>> # Creates: tod_ticktime (pl.Time), elapsed_ticktime (pl.Int64)
     """
-    if market.name != "CN":
-        raise NotImplementedError(f"Market {market.name} not supported yet")
-
-    col = pl.col(timestamp_col)
-
-    # Parse H/HHMMSSMMM → hour, minute, second, millisecond
-    h = col // 10000000  # 93012145 // 10000000 = 9
-    m = (col // 100000) % 100  # 93012145 // 100000 = 930, 930 % 100 = 30
-    s = (col // 1000) % 100  # 93012145 // 1000 = 93012, 93012 % 100 = 12
-    ms = col % 1000  # 93012145 % 1000 = 145
-
-    # CN market: calculate elapsed seconds from market open
-    # Morning: 09:30-11:30 (2 hours = 7200 seconds)
-    # Afternoon: 13:00-15:00 (2 hours = 7200 seconds)
-    base_seconds = (
-        pl.when((h == 9) & (m >= 30))
-        .then((m - 30) * 60 + s)  # 09:30-09:59
-        .when(h == 10)
-        .then(30 * 60 + m * 60 + s)  # 10:00-10:59
-        .when((h == 11) & (m < 30))
-        .then(90 * 60 + m * 60 + s)  # 11:00-11:29
-        .when((h >= 13) & (h < 15))
-        .then(7200 + (h - 13) * 3600 + m * 60 + s)  # 13:00-14:59
-        .when((h == 15) & (m == 0) & (s == 0))
-        .then(14400)  # 15:00:00 exactly
-        .otherwise(None)  # Outside trading hours
+    config = get_config()
+
+    if config.market != "CN":
+        raise NotImplementedError(f"Market {config.market} not supported yet")
+
+    # Parse HHMMSSMMM to components
+    df = df.with_columns([
+        (pl.col(timestamp_col) // 10000000).alias("_hour"),
+        (pl.col(timestamp_col) // 100000 % 100).alias("_minute"),
+        (pl.col(timestamp_col) // 1000 % 100).alias("_second"),
+        (pl.col(timestamp_col) % 1000).alias("_ms"),
+    ])
+
+    # Add time-of-day column (pl.Time)
+    # Convert to nanoseconds since midnight
+    tod_ns = (
+        pl.col("_hour") * 3_600_000_000_000
+        + pl.col("_minute") * 60_000_000_000
+        + pl.col("_second") * 1_000_000_000
+        + pl.col("_ms") * 1_000_000
+    )
+    df = df.with_columns(tod_ns.cast(pl.Time).alias(f"tod_{timestamp_col}"))
+
+    # Add elapsed milliseconds (int)
+    # CN market: 09:30-11:30 (morning), 13:00-15:00 (afternoon)
+    # Using user's hardcoded logic
+    elapsed_ms = (
+        pl.when(pl.col("_hour") < 12)
+        .then(
+            # Morning session: from 09:30:00.000
+            (
+                (pl.col("_hour") - 9) * 3600
+                + (pl.col("_minute") - 30) * 60
+                + pl.col("_second")
+            )
+            * 1000
+            + pl.col("_ms")
+        )
+        .otherwise(
+            # Afternoon session: 2 hours of morning + time since 13:00
+            (
+                2 * 3600 + (pl.col("_hour") - 13) * 3600 + pl.col("_minute") * 60 + pl.col("_second")
+            )
+            * 1000
+            + pl.col("_ms")
+        )
     )
+    df = df.with_columns(elapsed_ms.cast(pl.Int64).alias(f"elapsed_{timestamp_col}"))
 
-    # Include milliseconds as fractional part
-    elapsed = base_seconds.cast(pl.Float64) + ms.cast(pl.Float64) / 1000.0
+    # Drop temporary columns
+    df = df.drop(["_hour", "_minute", "_second", "_ms"])
 
-    return df.with_columns(elapsed.alias("elapsed_seconds"))
+    return df
 
 
 def bin(df: pl.LazyFrame, widths: dict[str, float]) -> pl.LazyFrame:

vizflow/presets.py

@@ -0,0 +1,63 @@
+"""Column mapping presets for VizFlow."""
+
+# Yuanzhao's log format -> VizFlow standard
+YUANZHAO = {
+    # Order columns (18)
+    "symbol": "ukey",
+    "orderId": "order_id",
+    "orderSide": "order_side",
+    "orderQty": "order_qty",
+    "orderPrice": "order_price",
+    "priceType": "order_price_type",
+    "fillQty": "order_filled_qty",
+    "fillPrice": "fill_price",
+    "lastExchangeTs": "update_exchange_ts",
+    "createdTs": "create_exchange_ts",
+    "localTs": "create_local_ts",
+    "qtyAhead": "qty_ahead",
+    "qtyBehind": "qty_behind",
+    "orderStatus": "order_curr_state",
+    "orderTposType": "order_tpos_type",
+    "alphaTs": "alpha_ts",
+    "event": "event_type",
+    "cumFilledNotional": "order_filled_notional",
+    # Quote columns (15)
+    "bid": "bid_px0",
+    "bid2": "bid_px1",
+    "bid3": "bid_px2",
+    "bid4": "bid_px3",
+    "bid5": "bid_px4",
+    "ask": "ask_px0",
+    "ask2": "ask_px1",
+    "ask3": "ask_px2",
+    "ask4": "ask_px3",
+    "ask5": "ask_px4",
+    "bsize": "bid_size0",
+    "bsize2": "bid_size1",
+    "bsize3": "bid_size2",
+    "bsize4": "bid_size3",
+    "bsize5": "bid_size4",
+    "asize": "ask_size0",
+    "asize2": "ask_size1",
+    "asize3": "ask_size2",
+    "asize4": "ask_size3",
+    "asize5": "ask_size4",
+    "isRebasedQuote": "is_rebased",
+    "quoteSeqNum": "seq_num",
+    "quoteTs": "timestamp",
+    # Position columns (11)
+    "startPos": "init_net_pos",
+    "pos": "current_net_pos",
+    "realizedPos": "current_realized_net_pos",
+    "openBuyPos": "open_buy",
+    "openSellPos": "open_sell",
+    "cumBuy": "cum_buy",
+    "cumSell": "cum_sell",
+    "cashFlow": "cash_flow",
+    "frozenCash": "frozen_cash",
+    "globalCumBuyNotional": "cum_buy_filled_notional",
+    "globalCumSellNotional": "cum_sell_filled_notional",
+}
+
+# Alias: ylin (Yuanzhao's username)
+YLIN = YUANZHAO

{vizflow-0.3.0.dist-info → vizflow-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vizflow
-Version: 0.3.0
+Version: 0.4.1
 Requires-Python: >=3.9
 Requires-Dist: polars>=0.20.0
 Provides-Extra: dev

vizflow-0.4.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+vizflow/__init__.py,sha256=s03IltxCkl4odJo8ywVERpOD8Dl0GqOaKhFyELjGwM4,387
+vizflow/config.py,sha256=IiVau-4WyO_7NOWlR7Tw58RpDeGFYBbgkNzH7xuQIUg,6544
+vizflow/io.py,sha256=Z2W-jU8nrX52DjzzXCxfHkKSWl3AGnIUC3cFDg4dCTk,6906
+vizflow/market.py,sha256=MtNz_nnZxC66Aq-i2PXEwaFCTknijFWYZUUv6798k2s,2493
+vizflow/ops.py,sha256=NL-Gtv-m_O1hv-0RUb9Wt43916HsQ5tYK_0e_uKR90w,4062
+vizflow/presets.py,sha256=RdxlFouysHBH8IftQx3v5e9Mq82DznxZFbMxv4w1vnA,1825
+vizflow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vizflow-0.4.1.dist-info/METADATA,sha256=qRa3pRup8YXzTvR9kxBFmhNZR_BBqsR1CkYrOa3t-As,388
+vizflow-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+vizflow-0.4.1.dist-info/RECORD,,

vizflow-0.3.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-vizflow/__init__.py,sha256=_2uMkH3E9eiPvkbE8-2Rmq4J5zjXxZcgqcSa3wnDI5E,244
-vizflow/config.py,sha256=1bc4maiFzeTVVMAcHyeJku4f5KcU-LlWGFpcHhjXylg,2356
-vizflow/market.py,sha256=MtNz_nnZxC66Aq-i2PXEwaFCTknijFWYZUUv6798k2s,2493
-vizflow/ops.py,sha256=-C-e_WYJCdfl8DHkSvufyE_tMkruq6AI2MBoCwt2Hqo,3304
-vizflow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vizflow-0.3.0.dist-info/METADATA,sha256=hixuCfcNqckSK81T-vosviHJoCPS60Ju6brL-tHWwdg,388
-vizflow-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-vizflow-0.3.0.dist-info/RECORD,,