wherewolf 0.1.0__py3-none-any.whl

wherewolf/app.py

@@ -0,0 +1,305 @@
+import streamlit as st
+from wherewolf.execution import DuckDBEngine, SparkEngine, QueryResult
+from wherewolf.translation import Translator
+from wherewolf.storage import HistoryManager
+from wherewolf.export import Exporter
+from wherewolf.ui import FileBrowser
+from streamlit_ace import st_ace
+
+# --- Configuration ---
+st.set_page_config(
+    page_title="Wherewolf SQL Workbench",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Hide Streamlit options (hamburger menu and footer)
+hide_st_style = """
+            <style>
+            /* Hide the Streamlit main menu (hamburger) */
+            #MainMenu {visibility: hidden;}
+            /* Hide the "Made with Streamlit" footer */
+            footer {visibility: hidden;}
+            /* Hide the Deploy button specifically */
+            .stAppDeployButton {display: none;}
+            /* 
+               We do NOT hide 'stToolbar' or 'header' entirely 
+               because they contain the sidebar toggle button.
+            */
+            </style>
+            """
+st.markdown(hide_st_style, unsafe_allow_html=True)
+
+# --- Initialize Session State ---
+if "path_input" not in st.session_state:
+    st.session_state.path_input = ""
+if "query_result" not in st.session_state:
+    st.session_state.query_result = None
+if "is_running" not in st.session_state:
+    st.session_state.is_running = False
+if "history" not in st.session_state:
+    st.session_state.history = []
+if "selected_query" not in st.session_state:
+    st.session_state.selected_query = "SELECT * FROM dataset LIMIT 10"
+if "executed_input_dialect_key" not in st.session_state:
+    st.session_state.executed_input_dialect_key = "duckdb"
+if "last_engine_name" not in st.session_state:
+    st.session_state.last_engine_name = "DuckDB"
+if "input_dialect_ui" not in st.session_state:
+    st.session_state.input_dialect_ui = "DuckDB"
+
+# --- Early State Update Pattern ---
+# This avoids StreamlitAPIException by updating state BEFORE widgets are instantiated.
+if "pending_path" in st.session_state:
+    st.session_state.path_input = st.session_state.pending_path
+    del st.session_state.pending_path
+
+if "pending_query" in st.session_state:
+    st.session_state.selected_query = st.session_state.pending_query
+    del st.session_state.pending_query
+
+# --- Instances ---
+history_manager = HistoryManager()
+translator = Translator()
+
+# --- Sidebar ---
+with st.sidebar:
+    st.title("🐺 Wherewolf")
+
+    # 1. BROWSE LOGIC
+    # The browser is now the primary path selection tool.
+    with st.expander("📁 Browse Local Files", expanded=True):
+        show_hidden = st.checkbox("Show Hidden Files", value=False)
+        selected_path = FileBrowser.render_explorer(show_hidden=show_hidden)
+        if selected_path:
+            # Set PENDING path and rerun
+            st.session_state.pending_path = selected_path
+            st.rerun()
+
+    # Display the active path clearly in the sidebar
+    if st.session_state.path_input:
+        st.info(f"📄 Active: `{st.session_state.path_input}`")
+    else:
+        st.warning("⚠️ No dataset loaded.")
+
+    engine_name = st.selectbox("Execution Engine", ["DuckDB", "Spark"])
+
+    # Auto-align input dialect if engine changes
+    if st.session_state.last_engine_name != engine_name:
+        st.session_state.input_dialect_ui = engine_name
+        st.session_state.last_engine_name = engine_name
+
+    preview_limit = st.slider("Preview Size", 10, 1000, 100)
+    export_format = st.selectbox("Export Format", ["CSV", "Excel", "Parquet"])
+
+    st.divider()
+    st.subheader("Query History")
+    history = history_manager.get_all()
+    if history:
+        history_labels = [f"{h['timestamp'][:16]} - {h['query'][:30]}..." for h in history]
+        selected_history = st.selectbox("Select from History", ["Select..."] + history_labels)
+        if selected_history != "Select...":
+            idx = history_labels.index(selected_history)
+            # Use PENDING state to avoid instantiation errors
+            st.session_state.pending_query = history[idx]["query"]
+            st.session_state.pending_path = history[idx]["path"]
+            st.rerun()
+    else:
+        st.write("No history yet.")
+
+    if st.button("Clear History"):
+        history_manager.clear()
+        st.rerun()
+
+    st.divider()
+    st.subheader("Editor Settings")
+    themes = sorted(
+        [
+            "tomorrow_night_eighties",
+            "monokai",
+            "twilight",
+            "ambiance",
+            "chaos",
+            "clouds_midnight",
+            "dracula",
+            "gob",
+            "solarized_dark",
+            "terminal",
+            "vibrant_ink",
+            "chrome",
+            "clouds",
+            "crimson_editor",
+            "dawn",
+            "dreamweaver",
+            "eclipse",
+            "github",
+            "solarized_light",
+            "textmate",
+            "tomorrow",
+            "xcode",
+        ]
+    )
+    ace_theme = st.selectbox(
+        "Editor Theme",
+        themes,
+        index=themes.index("dracula"),
+    )
+
+# --- Main Area ---
+col_h1, col_h2 = st.columns([0.7, 0.3])
+with col_h1:
+    st.header("SQL Editor")
+with col_h2:
+    input_dialect_ui = st.selectbox(
+        "Input Dialect", options=["DuckDB", "Spark", "Azure SQL"], key="input_dialect_ui"
+    )
+
+# Use st_ace for syntax highlighting
+query_text = st_ace(
+    value=st.session_state.selected_query,
+    language="sql",
+    theme=ace_theme,
+    height=300,
+    key="sql_editor",
+    auto_update=True,
+)
+
+col1, col2 = st.columns([0.1, 0.9])
+with col1:
+    run_button = st.button("🚀 Run", type="primary", disabled=st.session_state.is_running)
+with col2:
+    cancel_button = st.button("🛑 Cancel", disabled=not st.session_state.is_running)
+
+# --- Execution Logic ---
+if run_button and st.session_state.path_input:
+    st.session_state.is_running = True
+    st.session_state.query_result = None
+
+    if engine_name == "DuckDB":
+        engine = DuckDBEngine()
+    else:
+        engine = SparkEngine()
+
+    # Map dialects
+    dialect_mapping = {"DuckDB": "duckdb", "Spark": "spark", "Azure SQL": "tsql"}
+    input_dialect_key = dialect_mapping[input_dialect_ui]
+    engine_dialect_key = dialect_mapping[engine_name]
+
+    # Save the executed input dialect so the Translation section knows where to translate from
+    st.session_state.executed_input_dialect_key = input_dialect_key
+
+    query_to_run = query_text
+    translation_error = None
+
+    # Translate query if the input dialect is different from the execution engine
+    if input_dialect_key != engine_dialect_key:
+        try:
+            query_to_run = translator.translate(
+                query_text, from_dialect=input_dialect_key, to_dialect=engine_dialect_key
+            )
+        except Exception as e:
+            translation_error = str(e)
+
+    if translation_error:
+        st.session_state.query_result = QueryResult(
+            success=False,
+            error_message=f"Failed to translate input query from {input_dialect_ui} to {engine_name}:\n{translation_error}",
+        )
+        st.session_state.selected_query = query_text
+    else:
+        with st.spinner(f"Running query on {engine_name}..."):
+            result = engine.execute(query_to_run, st.session_state.path_input, limit=preview_limit)
+            st.session_state.query_result = result
+            st.session_state.selected_query = query_text
+
+            if result.success:
+                history_manager.add_entry(
+                    engine_name.lower(), query_text, st.session_state.path_input
+                )
+
+    st.session_state.is_running = False
+    st.rerun()
+
+# --- Results Display ---
+if st.session_state.query_result:
+    result: QueryResult = st.session_state.query_result
+
+    if result.success:
+        # --- Translation Section ---
+        st.divider()
+        col_t1, col_t2 = st.columns([0.7, 0.3])
+        with col_t1:
+            st.subheader("SQL Translation")
+        with col_t2:
+            # All available dialects
+            all_dialects_map = {"DuckDB": "duckdb", "Spark": "spark", "Azure SQL": "tsql"}
+
+            # Map CURRENT UI selection to key for live translation logic
+            current_input_key = all_dialects_map[input_dialect_ui]
+
+            # Determine target options: everything except the CURRENT input dialect
+            target_options = [
+                ui_name for ui_name, key in all_dialects_map.items() if key != current_input_key
+            ]
+
+            selected_target_ui = st.selectbox(
+                "Target Dialect", options=target_options, label_visibility="collapsed"
+            )
+
+            # Map UI selection to SQLGlot dialect identifiers
+            target_dialect = all_dialects_map[selected_target_ui]
+
+        try:
+            # Translate from the CURRENTLY SELECTED input dialect, not just the last executed one
+            translated_sql = translator.translate(
+                query_text,
+                from_dialect=current_input_key,
+                to_dialect=target_dialect,
+            )
+            with st.expander(f"✨ Translated SQL ({selected_target_ui})", expanded=True):
+                st.code(translated_sql, language="sql")
+        except Exception as e:
+            st.warning(f"Translation failed: {str(e)}")
+
+        m1, m2 = st.columns(2)
+        m1.metric("Rows Returned", f"{result.row_count:,}")
+        m2.metric("Execution Time", f"{result.execution_time:.4f}s")
+
+        st.subheader("Preview")
+        st.dataframe(result.df, width="stretch")
+
+        # --- Export Section ---
+        st.divider()
+        st.subheader("Export Results")
+
+        export_label = f"Download as {export_format}"
+        if export_format == "CSV":
+            data = Exporter.to_csv(result.df)
+            mime = "text/csv"
+            ext = ".csv"
+        elif export_format == "Excel":
+            data = Exporter.to_excel(result.df)
+            mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            ext = ".xlsx"
+        else:
+            data = Exporter.to_parquet(result.df)
+            mime = "application/octet-stream"
+            ext = ".parquet"
+
+        # Derive original filename for the export
+        import os
+
+        orig_filename = os.path.basename(st.session_state.path_input)
+        # Strip extension from original if present
+        base_name = os.path.splitext(orig_filename)[0] or "wherewolf"
+        download_name = f"{base_name}_export{ext}"
+
+        st.download_button(label=export_label, data=data, file_name=download_name, mime=mime)
+
+    else:
+        st.error("Query Failed")
+        with st.expander("Show Details"):
+            st.text(result.error_message)
+
+elif not st.session_state.path_input:
+    st.info("👈 Please provide a dataset path in the sidebar to begin.")

wherewolf/execution/__init__.py

@@ -0,0 +1,5 @@
+from .duckdb_engine import DuckDBEngine
+from .spark_engine import SparkEngine
+from .models import QueryResult
+
+__all__ = ["DuckDBEngine", "SparkEngine", "QueryResult"]

wherewolf/execution/duckdb_engine.py

@@ -0,0 +1,56 @@
+import duckdb
+import time
+from .models import QueryResult
+
+
+class DuckDBEngine:
+    """Execution engine using DuckDB."""
+
+    def __init__(self):
+        self.con = duckdb.connect(database=":memory:")
+
+    def execute(self, query: str, path: str, limit: int = 1000) -> QueryResult:
+        """Executes a SQL query against a local file using DuckDB.
+
+        Args:
+            query: The SQL query to execute.
+            path: The filesystem path to the data file.
+            limit: Maximum number of rows to return in the preview.
+
+        Returns:
+            A QueryResult object.
+        """
+        import os
+
+        abs_path = os.path.abspath(path)
+        start_time = time.time()
+        try:
+            # 1. Register the dataset view
+            # DuckDB automatically detects CSV, Parquet, JSON based on extension or content
+            self.con.execute(f"CREATE OR REPLACE VIEW dataset AS SELECT * FROM '{abs_path}'")
+
+            # 2. Execute the user query
+            # We wrap the user query to handle limits for the preview
+            # Note: The user query must refer to 'dataset'
+            rel = self.con.sql(query)
+
+            # 3. Get total row count (might be expensive for large datasets,
+            # but usually okay for local DuckDB)
+            row_count = rel.count("*").fetchone()[0]
+
+            # 4. Fetch the preview DataFrame
+            df = rel.limit(limit).df()
+
+            execution_time = time.time() - start_time
+            return QueryResult(
+                df=df, execution_time=execution_time, row_count=row_count, success=True
+            )
+        except Exception as e:
+            return QueryResult(
+                success=False, error_message=str(e), execution_time=time.time() - start_time
+            )
+
+    def interrupt(self):
+        """Interrupts the current query execution."""
+        if self.con:
+            self.con.interrupt()

wherewolf/execution/models.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass, field
+import pandas as pd
+
+
+@dataclass
+class QueryResult:
+    """Represents the results of a SQL query execution."""
+
+    df: pd.DataFrame = field(default_factory=pd.DataFrame)
+    execution_time: float = 0.0
+    row_count: int = 0
+    success: bool = True
+    error_message: str = ""

wherewolf/execution/spark_engine.py

@@ -0,0 +1,78 @@
+import time
+from .models import QueryResult
+
+try:
+    from pyspark.sql import SparkSession
+
+    SPARK_AVAILABLE = True
+except ImportError:
+    SPARK_AVAILABLE = False
+
+
+class SparkEngine:
+    """Execution engine using PySpark."""
+
+    def __init__(self):
+        self.spark = None
+        if SPARK_AVAILABLE:
+            # Note: We'll lazily create the session or expect it in the execute
+            pass
+
+    def _get_session(self):
+        if not self.spark:
+            self.spark = SparkSession.builder.appName("Wherewolf").master("local[*]").getOrCreate()
+        return self.spark
+
+    def execute(self, query: str, path: str, limit: int = 1000) -> QueryResult:
+        if not SPARK_AVAILABLE:
+            return QueryResult(success=False, error_message="PySpark not installed")
+
+        import os
+
+        abs_path = os.path.abspath(path)
+        start_time = time.time()
+        try:
+            spark = self._get_session()
+
+            # 1. Read the dataset
+            # Determine format by extension (basic detection)
+            if abs_path.endswith(".csv"):
+                df_spark = (
+                    spark.read.option("header", "true").option("inferSchema", "true").csv(abs_path)
+                )
+            elif abs_path.endswith(".parquet"):
+                df_spark = spark.read.parquet(abs_path)
+            elif abs_path.endswith(".json"):
+                df_spark = spark.read.json(abs_path)
+            else:
+                # Default to automatic detection if supported,
+                # but Spark is less automatic than DuckDB
+                raise ValueError(f"Unsupported file format for path: {abs_path}")
+
+            # 2. Register temp view
+            df_spark.createOrReplaceTempView("dataset")
+
+            # 3. Execute query
+            res_spark = spark.sql(query)
+
+            # 4. Get count
+            row_count = res_spark.count()
+
+            # 5. Preview
+            # Using limit to avoid fetching everything
+            df_preview = res_spark.limit(limit).toPandas()
+
+            execution_time = time.time() - start_time
+            return QueryResult(
+                df=df_preview, execution_time=execution_time, row_count=row_count, success=True
+            )
+        except Exception as e:
+            return QueryResult(
+                success=False, error_message=str(e), execution_time=time.time() - start_time
+            )
+
+    def interrupt(self):
+        """Interrupts current Spark job."""
+        if self.spark:
+            # Spark context interrupt
+            self.spark.sparkContext.cancelAllJobs()

wherewolf/export/__init__.py

@@ -0,0 +1,3 @@
+from .exporter import Exporter
+
+__all__ = ["Exporter"]

wherewolf/export/exporter.py

@@ -0,0 +1,26 @@
+import pandas as pd
+import io
+
+
+class Exporter:
+    """Utility to convert DataFrames to various byte formats for download."""
+
+    @staticmethod
+    def to_csv(df: pd.DataFrame) -> bytes:
+        """Converts DataFrame to CSV bytes."""
+        return df.to_csv(index=False).encode("utf-8")
+
+    @staticmethod
+    def to_excel(df: pd.DataFrame) -> bytes:
+        """Converts DataFrame to Excel bytes."""
+        output = io.BytesIO()
+        with pd.ExcelWriter(output, engine="openpyxl") as writer:
+            df.to_excel(writer, index=False)
+        return output.getvalue()
+
+    @staticmethod
+    def to_parquet(df: pd.DataFrame) -> bytes:
+        """Converts DataFrame to Parquet bytes."""
+        output = io.BytesIO()
+        df.to_parquet(output, index=False)
+        return output.getvalue()

wherewolf/storage/__init__.py

@@ -0,0 +1,3 @@
+from .history import HistoryManager
+
+__all__ = ["HistoryManager"]

wherewolf/storage/history.py

@@ -0,0 +1,63 @@
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Optional
+
+
+class HistoryManager:
+    """Manages local query history persistence."""
+
+    DEFAULT_PATH = Path.home() / ".wherewolf" / "history.json"
+
+    def __init__(self, storage_path: Optional[Path] = None):
+        self.storage_path = storage_path or self.DEFAULT_PATH
+        self._ensure_storage()
+
+    def _ensure_storage(self):
+        """Ensures the storage directory exists."""
+        self.storage_path.parent.mkdir(parents=True, exist_ok=True)
+        if not self.storage_path.exists():
+            with open(self.storage_path, "w") as f:
+                json.dump([], f)
+
+    def add_entry(self, engine: str, query: str, path: str):
+        """Adds a new query to the history.
+
+        Args:
+            engine: The execution engine used (e.g., 'duckdb').
+            query: The SQL query string.
+            path: The dataset path used.
+        """
+        history = self.get_all()
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "engine": engine,
+            "query": query,
+            "path": path,
+        }
+        history.insert(0, entry)  # Add to the beginning
+
+        # Limit history to 100 entries
+        history = history[:100]
+
+        with open(self.storage_path, "w") as f:
+            json.dump(history, f, indent=2)
+
+    def get_all(self) -> List[Dict]:
+        """Returns all history entries.
+
+        Returns:
+            A list of history entry dictionaries.
+        """
+        try:
+            if not self.storage_path.exists():
+                return []
+            with open(self.storage_path, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return []
+
+    def clear(self):
+        """Clears the query history."""
+        with open(self.storage_path, "w") as f:
+            json.dump([], f)

wherewolf/translation/__init__.py

@@ -0,0 +1,3 @@
+from .translator import Translator
+
+__all__ = ["Translator"]

wherewolf/translation/translator.py

@@ -0,0 +1,35 @@
+import sqlglot
+
+
+class Translator:
+    """Handles SQL dialect translation between DuckDB and SparkSQL."""
+
+    VALID_DIALECTS = {"duckdb", "spark", "tsql"}
+
+    def translate(self, query: str, from_dialect: str, to_dialect: str) -> str:
+        """Translates a SQL query from one dialect to another.
+
+        Args:
+            query: The SQL query string.
+            from_dialect: The source dialect (e.g., 'duckdb').
+            to_dialect: The target dialect (e.g., 'spark').
+
+        Returns:
+            The translated SQL query string.
+
+        Raises:
+            ValueError: If the dialect is not supported.
+        """
+        if from_dialect not in self.VALID_DIALECTS:
+            raise ValueError(f"Unsupported source dialect: {from_dialect}")
+        if to_dialect not in self.VALID_DIALECTS:
+            raise ValueError(f"Unsupported target dialect: {to_dialect}")
+
+        try:
+            # sqlglot.transpile returns a list of translated queries
+            translated = sqlglot.transpile(query, read=from_dialect, write=to_dialect, pretty=True)
+            return translated[0] if translated else ""
+        except Exception as e:
+            # In a real app, we might want to warn about imperfect translation
+            # for now, we'll re-raise or handle gracefully.
+            raise ValueError(f"Translation failed: {str(e)}") from e

wherewolf/ui/__init__.py

@@ -0,0 +1,3 @@
+from .file_browser import FileBrowser
+
+__all__ = ["FileBrowser"]

wherewolf/ui/file_browser.py

@@ -0,0 +1,101 @@
+import os
+import streamlit as st
+from pathlib import Path
+from typing import Optional
+
+
+class FileBrowser:
+    """A highly resilient, selectbox-based file explorer."""
+
+    @staticmethod
+    def _update_dir(key: str):
+        """Callback to update the current directory based on selection."""
+        # Use session_state directly to avoid stale variable issues
+        choice = st.session_state[key]
+        curr_dir_key = f"{key}_curr_dir"
+
+        curr_dir = st.session_state[curr_dir_key]
+
+        # Resolve the new path
+        if choice == "..":
+            new_path = os.path.dirname(curr_dir)
+        else:
+            new_path = os.path.join(curr_dir, choice)
+
+        new_path = os.path.normpath(new_path)
+
+        # Only update if the selection is actually a directory
+        if os.path.isdir(new_path):
+            st.session_state[curr_dir_key] = new_path
+
+    @staticmethod
+    def render_explorer(show_hidden: bool = False) -> Optional[str]:
+        """Renders the selectbox-based file explorer.
+
+        Args:
+            show_hidden: Whether to show files/folders starting with '.'.
+
+        Returns:
+            The selected file path if one was clicked, else None.
+        """
+        key = "wherewolf_fs"
+        curr_dir_key = f"{key}_curr_dir"
+        files_key = f"{key}_files"
+
+        # Initialization
+        if curr_dir_key not in st.session_state:
+            base_path = str(Path.home())
+            st.session_state[curr_dir_key] = base_path
+
+        current_path = st.session_state[curr_dir_key]
+
+        # Re-build files list on every render to respect show_hidden toggle
+        try:
+            raw_items = sorted(os.listdir(current_path))
+            if not show_hidden:
+                raw_items = [f for f in raw_items if not f.startswith(".")]
+
+            # Remove '..' if we are at root
+            if current_path == os.path.abspath(os.sep):
+                files = ["Select file/folder..."] + raw_items
+            else:
+                files = ["Select file/folder...", ".."] + raw_items
+
+            st.session_state[files_key] = files
+        except Exception as e:
+            st.error(f"Error reading directory {current_path}: {e}")
+            st.session_state[files_key] = ["Select file/folder...", ".."]
+
+        # --- UI Navigation ---
+        st.write(f"📂 `{current_path}`")
+
+        selected_file = st.selectbox(
+            label="Select file or directory",
+            options=st.session_state[files_key],
+            key=key,
+            on_change=lambda: FileBrowser._update_dir(key),
+            help="Select a directory to enter it, or a file to load it.",
+            index=0,  # Always reset to placeholder after a change triggers rerun
+        )
+
+        if selected_file == "Select file/folder...":
+            return None
+
+        full_path = os.path.normpath(os.path.join(current_path, selected_file))
+
+        # --- Contextual Actions ---
+        if os.path.isdir(full_path):
+            st.caption("📁 *Directory selected. Change selection to enter.*")
+        else:
+            # Display file info
+            valid_exts = {".csv", ".parquet", ".json"}
+            is_valid = Path(full_path).suffix.lower() in valid_exts
+
+            if is_valid:
+                st.success(f"📄 Ready to load: `{selected_file}`")
+                if st.button("🚀 Load This File", use_container_width=True, type="primary"):
+                    return full_path
+            else:
+                st.warning(f"⚠️ `{selected_file}` is not a supported data format.")
+
+        return None

wherewolf-0.1.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: wherewolf
+Version: 0.1.0
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: duckdb>=1.5.0
+Requires-Dist: ibis-framework>=12.0.0
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pyarrow>=23.0.1
+Requires-Dist: pyspark>=4.1.1
+Requires-Dist: sqlglot>=29.0.1
+Requires-Dist: streamlit-ace>=0.1.1
+Requires-Dist: streamlit>=1.55.0

wherewolf-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+wherewolf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wherewolf/app.py,sha256=vAPn8FHkMMGZGzcngihIpqQxjreIvPjRYmbs7gWQMpk,10733
+wherewolf/execution/__init__.py,sha256=3yjgaA0_y8UlkTCxCy5EIYYp9Qd-kBVxZtk1mSm4xQo,168
+wherewolf/execution/duckdb_engine.py,sha256=0pe5sTj8HEZw46-VWMwKl4DJ7RhY8wDqTNw1u5iF_7Q,1898
+wherewolf/execution/models.py,sha256=N1k9X7dcYc4_CHBUHve_whb3KAVpZUFYIdxMca_Nqe0,320
+wherewolf/execution/spark_engine.py,sha256=9TQsG0MJiW93yHo0Ex3KJw0OUEv0vQYCLrDuRKRhmEc,2568
+wherewolf/export/__init__.py,sha256=JTvltZqrSobKnqnKkmsG2L8qVRKza9Vwthjv4eBzXIM,55
+wherewolf/export/exporter.py,sha256=966v3jpHq-r1PdQUPbXJ8H701OIOPwFifn46QpKeWy0,799
+wherewolf/storage/__init__.py,sha256=BBK7GxkyH3AcfZuIXw2nrzrkNn1H4itArhuaRvy7sNw,66
+wherewolf/storage/history.py,sha256=XE0EX-IwB7_I7F6uAVqkucTpJvUO02fgPEtw6zPD2dc,1921
+wherewolf/translation/__init__.py,sha256=wOpBIn18rnlW9afDlX_eDJlYcEv4DBWq591H_dC6b-M,61
+wherewolf/translation/translator.py,sha256=lJPTNa5HLqqi9YbMQSYCiY7jZ5N3PKurquWFompboyc,1357
+wherewolf/ui/__init__.py,sha256=A7GBoutYnNExEPLuEh1XzInpLhGeJc3WeVDrfp6Rj5I,65
+wherewolf/ui/file_browser.py,sha256=a6oS5ZIw3JzMIs9KuXORC0vIHRJ0bU4O09Jg5Y-N0eA,3548
+wherewolf-0.1.0.dist-info/METADATA,sha256=CAX72dFM-wXefn7Q2ezBVfeI6P2BLhnLcBWkZ1JQa8U,387
+wherewolf-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+wherewolf-0.1.0.dist-info/licenses/LICENSE,sha256=NFbGGRQm1k66gWimBacIxXUB0W1yMChaohH6rZLGtiw,1068
+wherewolf-0.1.0.dist-info/RECORD,,

wherewolf-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

wherewolf-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David Beall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.