csvai 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

csvai/cli.py

@@ -25,6 +25,20 @@ def main() -> None:
     )
     parser.add_argument("--limit", type=int, help="Limit number of new rows to process")
     parser.add_argument("--model", default=settings.default_model, help="Model to use")
+    # Image processing options (Option A)
+    parser.add_argument(
+        "--process-image",
+        action="store_true",
+        help="Enable image processing; attaches image from column (default 'image') or URL",
+    )
+    parser.add_argument(
+        "--image-col",
+        help="Name of the image column (default: 'image')",
+    )
+    parser.add_argument(
+        "--image-root",
+        help="Directory to resolve local image filenames (default: ./images)",
+    )
     args = parser.parse_args()
 
     config = ProcessorConfig(
@@ -34,6 +48,9 @@ def main() -> None:
         schema=args.schema,
         limit=args.limit,
         model=args.model,
+        process_image=args.process_image,
+        image_col=args.image_col,
+        image_root=args.image_root,
     )
     processor = CSVAIProcessor(config, settings=settings)
 

csvai/processor.py

@@ -7,6 +7,8 @@ import json
 import logging
 import re
 from dataclasses import dataclass
+import base64
+import mimetypes
 from pathlib import Path
 from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
 
@@ -101,7 +103,7 @@ def _pick_text_from_response(resp: Any) -> str:
 
 
 async def call_openai_responses(
-    prompt: str,
+    input_payload: Any,
     client: AsyncOpenAI,
     model: str,
     schema: Optional[Dict[str, Any]],
@@ -123,7 +125,7 @@ async def call_openai_responses(
                 text_cfg = {"format": {"type": "json_object"}}
             resp = await client.responses.create(
                 model=model,
-                input=prompt,
+                input=input_payload,
                 temperature=settings.temperature,
                 max_output_tokens=settings.max_output_tokens,
                 text=text_cfg,
@@ -217,6 +219,9 @@ async def process_row(
     model: str,
     schema: Optional[Dict[str, Any]],
     settings: Settings,
+    process_image: bool,
+    image_col: Optional[str],
+    image_root: Optional[str],
 ) -> RowResult:
     row_id = (raw_row.get("id") or str(row_idx)).strip()
     sanitized = sanitize_keys(raw_row)
@@ -225,7 +230,70 @@ async def process_row(
         prompt = render_prompt(prompt_template, sanitized, raw_row)
     except Exception as e:
         return RowResult(id=row_id, error=f"prompt_error: {e}")
-    raw = await call_openai_responses(prompt, client, model, schema, settings)
+    # Build input for Responses API (text-only by default; multimodal if enabled and available)
+    input_payload: Any
+
+    if process_image:
+        col = (image_col or "image").strip()
+        val = (raw_row.get(col) or "").strip() if col else ""
+
+        def _resolve_image_part(v: str) -> Optional[Dict[str, Any]]:
+            if not v:
+                return None
+            lv = v.lower()
+            if lv.startswith("http://") or lv.startswith("https://"):
+                return {
+                    "type": "input_image",
+                    "image_url": v,
+                }
+            # Local file resolution: absolute/relative or under image_root
+            p = Path(v)
+            if not p.is_absolute():
+                # try relative to CWD first
+                p = Path.cwd() / v
+            if not p.exists():
+                root = Path(image_root) if image_root else (Path.cwd() / "images")
+                cand = root / v
+                if cand.exists():
+                    p = cand
+            if not p.exists():
+                logging.warning("Row %s: image not found '%s' → proceeding text-only", row_id, v)
+                return None
+            try:
+                data = p.read_bytes()
+                b64 = base64.b64encode(data).decode("ascii")
+                mime = mimetypes.guess_type(str(p))[0] or "image/jpeg"
+                data_url = f"data:{mime};base64,{b64}"
+                return {
+                    "type": "input_image",
+                    "image_url": data_url,
+                }
+            except Exception as e:
+                logging.warning(
+                    "Row %s: failed to read image '%s' (%s) → proceeding text-only",
+                    row_id,
+                    v,
+                    e,
+                )
+                return None
+
+        img_part = _resolve_image_part(val)
+        if img_part is not None:
+            input_payload = [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "input_text", "text": prompt},
+                        img_part,
+                    ],
+                }
+            ]
+        else:
+            input_payload = prompt
+    else:
+        input_payload = prompt
+
+    raw = await call_openai_responses(input_payload, client, model, schema, settings)
     if not raw:
         return RowResult(id=row_id, error="api_empty")
     try:
@@ -254,6 +322,10 @@ class ProcessorConfig:
     schema: Optional[str] = None
     limit: Optional[int] = None
     model: Optional[str] = None
+    # Image options (Option A)
+    process_image: bool = False
+    image_col: Optional[str] = None  # default to 'image' when None
+    image_root: Optional[str] = None  # default to CWD/images when None
 
 
 class CSVAIProcessor:
@@ -348,7 +420,18 @@ class CSVAIProcessor:
 
                 async def run_one(idx: int, raw: Dict[str, Any]) -> RowResult:
                     async with sem:
-                        return await process_row(idx, raw, client, prompt_template, args.model, schema, self.settings)
+                        return await process_row(
+                            idx,
+                            raw,
+                            client,
+                            prompt_template,
+                            args.model,
+                            schema,
+                            self.settings,
+                            process_image=self.config.process_image,
+                            image_col=(self.config.image_col or "image"),
+                            image_root=self.config.image_root,
+                        )
 
                 results = await asyncio.gather(
                     *(run_one(idx, raw) for idx, raw in batch), return_exceptions=True
@@ -417,4 +500,3 @@ class CSVAIProcessor:
             if writer is not None:
                 writer.close()
             await client.close()
-

csvai/settings.py

@@ -22,7 +22,7 @@ class Settings:
     backoff_factor: float = 1.7
 
     def __post_init__(self) -> None:
-        load_dotenv(find_dotenv())
+        load_dotenv(find_dotenv(usecwd=True), override=True)
         self.openai_api_key = os.getenv("OPENAI_API_KEY", self.openai_api_key)
         self.default_model = os.getenv("DEFAULT_MODEL", self.default_model)
         self.max_output_tokens = int(

csvai/ui.py

@@ -80,6 +80,18 @@ schema_file = st.file_uploader("Schema (optional, .json)", type=["json"], key="s
 model = st.text_input("Model", value=settings.default_model, key="model")
 limit = st.number_input("Row limit (0 = all new)", min_value=0, value=0, step=1, key="limit")
 
+# Image processing options
+process_image = st.toggle("Process images", value=False, key="process_image")
+image_col = None
+image_root = None
+if process_image:
+    image_col = st.text_input("Image column", value="image", key="image_col")
+    image_root = st.text_input(
+        "Image root (for local filenames)",
+        value=str(Path.cwd() / "images"),
+        key="image_root",
+    )
+
 c1, c2 = st.columns(2)
 with c1:
     run_clicked = st.button("▶ Run", use_container_width=True, key="run_btn")
@@ -148,6 +160,9 @@ if run_clicked:
             schema=str(schema_path) if schema_path else None,
             limit=int(limit) if limit > 0 else None,
             model=model,
+            process_image=bool(process_image),
+            image_col=str(image_col) if image_col else None,
+            image_root=str(image_root) if image_root else None,
         )
         processor = CSVAIProcessor(cfg, settings=settings)
 

csvai-0.2.0.dist-info/METADATA

@@ -0,0 +1,453 @@
+Metadata-Version: 2.4
+Name: csvai
+Version: 0.2.0
+Summary: Enrich CSV or Excel rows using OpenAI models (text or image analysis).
+Author: Zyxware Technologies, Vimal Joseph
+License-Expression: GPL-2.0-only
+Project-URL: Homepage, https://www.zyxware.com/article/6935/csvai-automate-data-enrichment-any-csv-or-excel-file-generative-ai
+Project-URL: Bug Tracker, https://github.com/zyxware/csvai/issues
+Project-URL: Source, https://github.com/zyxware/csvai
+Project-URL: Contact, https://www.zyxware.com/contact-us
+Keywords: csv,excel,ai,openai,data enrichment,llm,automation,vision,image analysis
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.99.0
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: openpyxl>=3.1.0
+Provides-Extra: ui
+Requires-Dist: streamlit; extra == "ui"
+Dynamic: license-file
+
+# CSVAI — Apply an AI prompt to each row in a CSV or Excel file and write enriched results
+
+The `csvai` library reads an input CSV or Excel file, renders a prompt for each row (you can use raw column names like `{{ Address }}`), calls an **OpenAI model via the Responses API**, and writes the original columns plus AI-generated fields to an output CSV or Excel file. It also support **image analysis** (vision) when enabled.
+
+The tool is **async + concurrent**, **resumable**, and **crash-safe**. It supports **Structured Outputs** with a **JSON Schema** for reliable JSON, or **JSON mode** (without a schema) if you prefer a lighter setup.
+
+We also have a **CSV AI Prompt Builder** (a Custom GPT) to help you generate prompts and JSON Schemas tailored to your CSVs.
+
+---
+
+## Features
+
+* **Structured Outputs**: enforce exact JSON with a schema for consistent, validated results.
+* **JSON mode**: force a single JSON object without defining a schema.
+* **Async & concurrent**: process many rows in parallel for faster throughput.
+* **Resumable**: rows already written (by `id`) are skipped on re-run.
+* **CSV or Excel**: handle `.csv` and `.xlsx` inputs and outputs.
+* **image analysis**: add `--process-image` to attach an image per row (via URL or local file) to multimodal models like `gpt-4o-mini`.
+
+---
+
+## Installation
+
+Requires Python **3.9+**.
+OpenAI API Key: Create a key - https://platform.openai.com/api-keys and use it in the .env file with OPENAI_API_KEY=
+See example.env in the [project repo](https://github.com/zyxware/csvai).
+
+### From PyPI
+
+```bash
+pip install csvai
+# Include Streamlit UI dependencies
+pip install "csvai[ui]"
+```
+
+### From GitHub
+
+```bash
+# Install directly from the repository
+pip install git+https://github.com/zyxware/csvai.git
+# With Streamlit UI dependencies
+pip install "csvai[ui] @ git+https://github.com/zyxware/csvai.git"
+```
+
+### For local development
+
+```bash
+git clone https://github.com/zyxware/csvai
+cd csvai
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+pip install -e .
+cp example.env .env
+# Edit .env and set OPENAI_API_KEY=sk-...
+```
+
+Installing the package exposes the `csvai` CLI and the `csvai-ui` command.
+
+---
+
+## Usage
+
+### CLI
+
+#### Auto-discovery
+
+If you name your files like this:
+
+```
+input.csv      # or input.xlsx
+input.prompt.txt
+input.schema.json   # optional
+```
+
+Run:
+
+```bash
+csvai input.csv      # or input.xlsx
+```
+
+#### Or specify prompt & schema explicitly
+
+```bash
+# With a prompt and a strict schema (best reliability)
+csvai address.xlsx --prompt address.prompt.txt --schema address.schema.json
+
+# Or JSON mode (no schema; still a single JSON object)
+csvai address.xlsx --prompt address.prompt.txt
+```
+
+Sample datasets (`address.csv` and `address.xlsx`) with the matching prompt and schema live in the `example/` directory.
+
+### Streamlit UI
+
+After installing with the `ui` extra, launch the web interface:
+
+```bash
+csvai-ui
+```
+
+The UI lets you upload a CSV/Excel file, provide a prompt and optional schema.
+A "Process images" toggle is available to attach an image per row; you can set the image column (default `image`) and the image root directory (default `./images`).
+
+---
+
+## Example Prompt & Schema
+
+### Prompt (`address.prompt.txt`)
+
+```text
+Extract city, state, and country from the given address.
+
+Rules:
+- city: city/town/locality (preserve accents, proper case)
+- state: ISO-standard name of the state/region/province or "" if none
+- country: ISO 3166 English short name of the country; infer if obvious, else ""
+- Ignore descriptors like "(EU)"
+- Do not guess street-level info
+
+Inputs:
+Address: {{Address}}
+```
+
+### Schema (`address.schema.json`)
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "city": {
+      "type": "string",
+      "description": "City, town, or locality name with correct casing and accents preserved"
+    },
+    "state": {
+      "type": "string",
+      "description": "ISO-standard name of the state, region, or province, or empty string if none"
+    },
+    "country": {
+      "type": "string",
+      "description": "ISO 3166 English short name of the country, inferred if obvious, else empty string"
+    }
+  },
+  "required": ["city", "state", "country"],
+  "additionalProperties": false
+}
+```
+---
+
+## Creating Prompts & Schemas with the CSV AI Prompt Builder
+
+You can use the **[CSV AI Prompt Builder](https://chat.openai.com/g/g-689d8067bd888191a896d2cfdab27a39-csv-ai-prompt-builder)** custom GPT to:
+
+* Quickly design a **prompt** tailored to your CSV data.
+* Generate a **JSON Schema** that matches your desired structured output.
+
+**Example input to the builder:**
+
+```
+File: reviews.csv. Inputs: title,body,stars. Output: sentiment,summary.
+```
+
+**Example result:**
+
+**Prompt**
+
+```
+Analyze each review and produce sentiment and a concise summary.
+
+Rules:
+- sentiment: one of positive, neutral, negative.
+- Star mapping: stars ≤ 2 ⇒ negative; 3 ⇒ neutral; ≥ 4 ⇒ positive. If stars is blank or invalid, infer from tone.
+- summary: 1–2 sentences, factual, include key pros/cons, no emojis, no first person, no marketing fluff.
+- Use the same language as the Body.
+- Return only the fields required by the tool schema.
+
+Inputs:
+Title: {{title}}
+Body: {{body}}
+Stars: {{stars}}
+```
+
+**Schema**
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "sentiment": {
+      "type": "string",
+      "description": "Overall sentiment derived from stars and/or tone; one of positive, neutral, negative",
+      "enum": ["positive", "neutral", "negative"]
+    },
+    "summary": {
+      "type": "string",
+      "description": "Concise 1–2 sentence summary capturing key pros/cons without opinionated fluff"
+    }
+  },
+  "required": ["sentiment", "summary"],
+  "additionalProperties": false
+}
+```
+
+**Command to execute**
+
+```bash
+python -m csvai.cli reviews.csv --prompt reviews.prompt.txt --schema reviews.schema.json
+```
+**Tip — have the builder generate a schema for you**
+* **I have `products.csv` with Product Title, Product Description, Category, and Sub Category. Help me enrich with SEO meta fields.**
+* **I have `reviews.csv` with Title, Body, and Stars. Help me extract sentiment and generate a short summary.**
+* **I have `address.csv` with an Address field. Help me extract City, State, and Country using ISO-standard names.**
+* **I have `tickets.csv` with Subject and Description. Help me classify each ticket into predefined support categories.**
+* **I have `posts.csv` with Title, Body, URL, Image URL, Brand, and Platform. Help me generate social media captions, hashtags, emojis, CTAs, and alt text.**
+* **I have `jobs.csv` with Job Title and Description. Help me categorize jobs into sectors and identify the level of seniority.**
+
+
+---
+
+## CLI
+
+```bash
+csvai INPUT.csv [--prompt PROMPT_FILE] [--output OUTPUT_FILE]
+                          [--limit N] [--model MODEL] [--schema SCHEMA_FILE]
+                          [--process-image] [--image-col COL] [--image-root DIR]
+```
+
+**Flags**
+
+* `--prompt, -p` — path to a plaintext prompt file (Jinja template).
+* `--output, -o` — output CSV path (default: `<input>_enriched.csv`).
+* `--limit` — process only the first `N` new/pending rows.
+* `--model` — model name (default from `.env`, falls back to `gpt-4o-mini`).
+* `--schema` — path to a JSON Schema for structured outputs (optional).
+* `--process-image` — enable image analysis; when set, attaches an image per row if available.
+* `--image-col` — name of the image column (default: `image`).
+* `--image-root` — directory to resolve local image filenames (default: `./images`).
+
+Notes on images:
+- If the image cell is blank, the row is processed as text-only.
+- If the cell is a full URL (`http(s)://...`), the model fetches it.
+- Otherwise the value is treated as a filename: resolved as an absolute/relative path first, then `./images/<filename>`.
+- If a referenced file is missing/unreadable, the tool logs a warning and proceeds text-only.
+
+---
+
+## Environment Variables (`.env`)
+
+See [`example.env`](example.env) for all configurable variables.
+
+```ini
+OPENAI_API_KEY=sk-...
+DEFAULT_MODEL=gpt-4o-mini
+MAX_OUTPUT_TOKENS=600
+TEMPERATURE=0.2
+MAX_CONCURRENT_REQUESTS=12
+PROCESSING_BATCH_SIZE=100
+REQUEST_TIMEOUT=45
+ALT_PROMPT_SUFFIX=.prompt.txt
+OUTPUT_FILE_SUFFIX=_enriched.csv
+```
+
+---
+
+## Input/Output Behavior
+
+* **Input CSV**: the script reads all rows. If an `id` column exists, it’s used to resume. If not, rows are indexed `0..N-1` internally for this run.
+* **Prompt rendering**: every row is sanitized so `{{ Raw Header }}` becomes `{{ Raw_Header }}`. You can also reference the raw values as `{{ raw["Raw Header"] }}` if needed.
+* **Output CSV**: contains the original columns plus AI-generated fields. The **header is fixed** after the first successful batch; later rows are written with the same header order.
+* **Resume**: rerunning skips rows whose `id` is already present in the output file.
+
+---
+
+## Image Analysis Example
+
+Files in `examples/`:
+
+- `image.csv` — demo rows with an image URL, a local filename, and a blank image.
+- `image.prompt.txt` — prompt to produce a one-sentence `description`.
+- `image.schema.json` — schema requiring the `description` field.
+
+Local image (for row 2): place a file at `./images/sample.jpg` (relative to your current working directory). For convenience you can download a sample image, for example:
+
+```bash
+mkdir -p images
+curl -L -o images/sample.jpg https://upload.wikimedia.org/wikipedia/commons/3/3f/JPEG_example_flower.jpg
+```
+
+Run the example (multimodal enabled):
+
+```bash
+csvai examples/image.csv \
+  --prompt examples/image.prompt.txt \
+  --schema examples/image.schema.json \
+  --process-image
+```
+
+Notes:
+- The image column defaults to `image`; override with `--image-col` if needed.
+- Local filenames are resolved as-is first; if not found, `./images/<filename>` is tried.
+- If an image is missing or unreadable, the row is processed as text-only and a warning is logged.
+
+
+## Structured Outputs vs JSON Mode
+
+### Structured Outputs (recommended)
+
+When you pass `--schema`, the request includes:
+
+```python
+text={
+  "format": {
+    "type": "json_schema",
+    "name": "row_schema",
+    "schema": schema,
+    "strict": true
+  }
+}
+```
+
+This guarantees the model returns **exactly** the keys/types you expect.
+
+### JSON Mode (no schema)
+
+When no schema is provided, the request includes:
+
+```python
+text={"format": {"type": "json_object"}}
+```
+
+The model must still return a single JSON object, but no exact schema is enforced.
+
+> **Prompting tip:** mention the word **JSON** in your prompt and explicitly list the expected fields to improve compliance in JSON mode.
+
+---
+
+## Performance & Concurrency
+
+* Concurrency is controlled by `MAX_CONCURRENT_REQUESTS`.
+* Increase gradually; too high can trigger API rate limits.
+* `PROCESSING_BATCH_SIZE` controls how many results are written per batch.
+* `REQUEST_TIMEOUT` guards slow requests; the script retries with backoff.
+
+---
+
+## Troubleshooting
+
+**“Missing required parameter: `text.format.name`”**
+You used structured outputs but didn’t include `name` **alongside** `type` and `schema`. The script already sends this correctly; ensure you’re on the latest version and that `--schema` points to the right file.
+
+**“Invalid schema … `required` must include every key”**
+The Responses structured-outputs path expects `required` to include **all** keys in `properties`. Either (a) add them all to `required`, (b) remove non-required keys from `properties`, or (c) use JSON mode.
+
+**Rows not resuming**
+Ensure there’s an `id` column in both input and output. If not present, the script uses positional IDs for the current run only.
+
+---
+
+## FAQ
+
+**Q: Does it run concurrently?**
+Yes. Concurrency is controlled via `MAX_CONCURRENT_REQUESTS` (default 10).
+
+**Q: Can I rely on an `id` column?**
+Yes. If present in the input CSV, it’s used for resumability. Otherwise rows are indexed for the session.
+
+**Q: Can I output nested JSON?**
+The schema can be nested, but CSV is flat. If you want nested data, extend the script with a flattener (e.g., convert `address.street` → `address_street`).
+
+**Q: Which models work?**
+Recent `gpt-4o*` models support Responses + Structured Outputs. If a model doesn’t support it, use JSON mode.
+
+**Q: Do I need a JSON schema?**
+No, but it’s strongly recommended for stable columns and fewer parse failures.
+
+---
+
+## Support
+
+This application was developed as an internal tool and we will continue to improve and optimize it as long as we use it. If you would like us to customize this or build a similar or related system to automate your tasks with AI, we are available for **commercial support**.
+
+---
+
+### About Zyxware Technologies
+
+At **Zyxware Technologies**, our mission is to help organizations harness the power of technology to solve real-world problems. Guided by our founding values of honesty and fairness, we are committed to delivering genuine value to our clients and the free and open-source community.
+
+**CSVAI** is a direct result of this philosophy. We originally developed it to automate and streamline our own internal data-enrichment tasks. Realizing its potential to help others, we are sharing it as a free tool in the spirit of our commitment to Free Software.
+
+Our expertise is centered around our **AI & Automation Services**. We specialize in building intelligent solutions that reduce manual effort, streamline business operations, and unlock data-driven insights. While we provide powerful free tools like this one, we also offer **custom development and commercial support** for businesses that require tailored AI solutions.
+
+If you're looking to automate a unique business process or build a similar system, we invite you to [**reach out to us**](https://www.zyxware.com/contact-us) to schedule a free discovery call.
+
+---
+
+## Updates
+
+For updates and new versions, visit: [Project Page @ Zyxware](https://www.zyxware.com/article/6935/csvai-automate-data-enrichment-any-csv-or-excel-file-generative-ai)
+
+---
+
+## Contact
+
+[https://www.zyxware.com/contact-us](https://www.zyxware.com/contact-us)
+
+---
+
+## Source Repository
+
+[https://github.com/zyxware/csvai](https://github.com/zyxware/csvai)
+
+---
+
+## Reporting Issues
+
+[https://github.com/zyxware/csvai/issues](https://github.com/zyxware/csvai/issues)
+
+---
+
+## License and Disclaimer
+
+**GPL v2** – Free to use & modify. Use it at your own risk. We are not collecting any user data.
+
+---
+
+## Need Help or Commercial Support?
+
+If you have any questions, feel free to [contact us](https://www.zyxware.com/contact-us).

csvai-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+csvai/__init__.py,sha256=e-mhAI44n21eES-x_va8ek_V-kGjq66Av6qezPnEu7s,238
+csvai/__main__.py,sha256=n2wYQ4W8MNAIZ8jldmLYMqNGc-fPtRTasUfK2l_TBHM,92
+csvai/cli.py,sha256=g8rGMGShjs-ND24rrSds1zg6DgTO5t5jsldEmB0cuAw,2258
+csvai/io_utils.py,sha256=zVQtJlDp3C-qCrMmgV721TrFAPaMMJfBvMMXYkdMAsE,4499
+csvai/launch.py,sha256=vScv6J1wyp-VSU1z5ghauINODgQGPt-9sd0uPTwkHKU,356
+csvai/processor.py,sha256=l4QvqkxSQo6s6nnQlLleQzd00DbxVYY8M6v2PyYaTd0,17516
+csvai/settings.py,sha256=-Jf7z90xugPCkK39NzHbVrMKQFmCpqQJ2XXSccm8gWY,1819
+csvai/ui.py,sha256=7NpJ4blUnBqM-gwP7ecBq566DWnbaqRuimmTox-435I,9003
+csvai-0.2.0.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+csvai-0.2.0.dist-info/METADATA,sha256=ywVQi2q7cLxpAKZYK9CUMKSC-pEiAwM5pGGBkLUR-PI,15579
+csvai-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+csvai-0.2.0.dist-info/entry_points.txt,sha256=FPtxQaCmYAivxE5mCR7xZ4qRHql0WkR5zFGsa6uzNtU,70
+csvai-0.2.0.dist-info/top_level.txt,sha256=5zoOsPtoSVx3vJiHHobEuEe2oFoEBpX3w6FIvLLU0xg,6
+csvai-0.2.0.dist-info/RECORD,,