svc-processing 0.1.1__py3-none-any.whl

pipeline/sig_processor.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+from pathlib import Path
+from typing import Any
+
+
+class SigFileProcessor:
+    """Process .sig files with configurable correction types."""
+
+    DEFAULT_CORRECTION_TYPES = {
+        'bronze': "2520.4",
+        'silver': "2517.9"
+    }
+
+    DEFAULT_INSTRUMENT_NUMBERS = {
+        'bronze': "2212118",
+        'silver': "1202103"
+    }
+
+    @staticmethod
+    def parse_correction_types_file(config_path: str | Path) -> dict[str, str]:
+        """Parse a sensor-calibration JSON file into a correction_type -> end_line mapping.
+
+        Pure — does not touch ``DEFAULT_CORRECTION_TYPES``. Used by
+        :meth:`load_default_correction_types` and by callers (such as
+        ``RunConfig``) that want a resolved calibration table for a single
+        instance without changing the class-wide defaults.
+        """
+        path_obj = Path(config_path).expanduser().resolve()
+        if not path_obj.exists():
+            raise FileNotFoundError(f"Correction-types config file not found: {path_obj}")
+
+        with path_obj.open("r") as f:
+            data = json.load(f)
+
+        if not isinstance(data, dict):
+            raise ValueError(
+                "Correction-types config JSON must be an object mapping correction_type -> end_line string."
+            )
+
+        normalized: dict[str, str] = {}
+        for key, value in data.items():
+            if key is None:
+                continue
+            correction_type = str(key).strip().lower()
+            if not correction_type:
+                continue
+            end_line_value = str(value).strip()
+            if not end_line_value:
+                raise ValueError(f"End-line value for correction type '{correction_type}' is empty in {path_obj}")
+            normalized[correction_type] = end_line_value
+
+        if not normalized:
+            raise ValueError(f"No correction types found in {path_obj}")
+
+        return normalized
+
+    @classmethod
+    def load_default_correction_types(cls, config_path: str | Path) -> dict[str, str]:
+        """Load correction-type end-line values from a JSON file and update DEFAULT_CORRECTION_TYPES."""
+        cls.DEFAULT_CORRECTION_TYPES = cls.parse_correction_types_file(config_path)
+        return cls.DEFAULT_CORRECTION_TYPES
+
+    def __init__(self, correction_value: str | None = None, instrument_number: str | None = None,
+                 correction_type: str | None = None, correction_config: dict | None = None,
+                 correction_types: dict[str, str] | None = None,
+                 instrument_numbers: dict[str, str] | None = None,
+                 logger: logging.Logger | None = None):
+        self._logger = logger
+        # Instance-level calibration tables, defaulting to the class-wide
+        # defaults. Passing these explicitly lets a caller (e.g. RunConfig)
+        # resolve per-run calibration without mutating DEFAULT_CORRECTION_TYPES /
+        # DEFAULT_INSTRUMENT_NUMBERS, which are shared, process-wide state.
+        self._correction_types = correction_types if correction_types is not None else self.DEFAULT_CORRECTION_TYPES
+        self._instrument_numbers = (
+            instrument_numbers if instrument_numbers is not None else self.DEFAULT_INSTRUMENT_NUMBERS
+        )
+
+        if correction_config:
+            self.end_line_value = correction_config.get('end_line')
+            self.instrument_number = correction_config.get('instrument_number')
+            self.correction_type = correction_config.get('name', 'custom')
+
+        elif correction_value is not None:
+            self.end_line_value = correction_value
+            self.instrument_number = instrument_number
+            self.correction_type = 'custom'
+
+        elif correction_type:
+            if correction_type not in self._correction_types:
+                raise ValueError(f"Invalid correction_type specified. Use 'bronze' or 'silver'. Got: {correction_type}")
+
+            self.correction_type = correction_type
+            self.end_line_value = self._correction_types[correction_type]
+            self.instrument_number = self._instrument_numbers[correction_type]
+
+        else:
+            raise ValueError("Must provide either correction_value, correction_type, or correction_config")
+
+        if not self.end_line_value or self.end_line_value.strip() == "":
+            raise ValueError("correction_value must be provided and cannot be empty")
+
+    def _log_info(self, message: str) -> None:
+        """Route info-level messages through a logger if one was supplied, else print."""
+        if self._logger is not None:
+            self._logger.info(message)
+        else:
+            print(message)
+
+    def _log_error(self, message: str) -> None:
+        """Route error-level messages through a logger if one was supplied, else print."""
+        if self._logger is not None:
+            self._logger.error(message)
+        else:
+            print(message)
+
+    def process_sig_files(self, input_folder: str, output_folder: str, verbose: bool = False) -> None:
+        """Process all .sig files in input_folder and write truncated copies to output_folder."""
+        end_line_start = self.end_line_value
+
+        input_dir = Path(input_folder).expanduser().resolve()
+        output_dir = Path(output_folder).expanduser().resolve()
+
+        if not output_dir.exists():
+            output_dir.mkdir(parents=True)
+            if verbose:
+                self._log_info(f"Created output folder: {output_dir}")
+
+        processed_count = 0
+
+        for entry in sorted(input_dir.iterdir()):
+            if entry.suffix == '.sig':
+                output_file_path = output_dir / entry.name
+
+                try:
+                    if verbose:
+                        self._log_info(f"Processing: {entry.name}")
+                    self._process_single_file(entry, output_file_path, end_line_start)
+                    processed_count += 1
+                    if verbose:
+                        self._log_info(f"Processed: {entry.name}")
+                except Exception as e:
+                    self._log_error(f"Error processing {entry.name}: {e}")
+
+        if verbose:
+            self._log_info(f"Processing complete. {processed_count} files processed.")
+
+    def _process_single_file(self, input_file_path: Path, output_file_path: Path, end_line_start: str) -> None:
+        with input_file_path.open('r') as input_file, output_file_path.open('w') as output_file:
+            target_found = True
+            for line in input_file:
+                if target_found:
+                    output_file.write(line)
+                if line.startswith(end_line_start):
+                    target_found = False
+
+    def get_supported_correction_types(self) -> list:
+        """Correction-type names this instance knows about (e.g. 'bronze', 'silver')."""
+        return list(self._correction_types.keys())
+
+    def extract_instrument_from_file(self, file_path: str) -> str | None:
+        try:
+            with Path(file_path).expanduser().resolve().open('r') as f:
+                for line in f:
+                    if line.startswith('instrument='):
+                        return line.split('=', 1)[1].strip()
+        except (FileNotFoundError, IOError, IndexError):
+            pass
+        return None
+
+    def get_file_metadata(self, file_path: str) -> dict:
+        metadata = {}
+        try:
+            with Path(file_path).expanduser().resolve().open('r') as f:
+                for line in f:
+                    if '=' in line and not line.startswith('data='):
+                        parts = line.strip().split('=', 1)
+                        if len(parts) == 2:
+                            metadata[parts[0].strip()] = parts[1].strip()
+        except (FileNotFoundError, IOError):
+            pass
+        return metadata
+
+    def _extract_instrument_name(self, instrument: str) -> str:
+        if not instrument:
+            return "Unknown"
+        match = re.search(r'(\d{7})', instrument)
+        if match:
+            instrument_number = match.group(1)
+            if instrument_number == self._instrument_numbers['silver']:
+                return 'Silver'
+            elif instrument_number == self._instrument_numbers['bronze']:
+                return 'Bronze'
+            elif self.instrument_number and instrument_number == self.instrument_number:
+                return 'Custom'
+        return 'Unknown'
+
+    def check_instrument_consistency(self, folder_path: str) -> dict[str, Any]:
+        """Check that all .sig files in folder_path share the same instrument."""
+        folder = Path(folder_path).expanduser().resolve()
+
+        if not folder.exists():
+            return {
+                'consistent': False,
+                'instrument': None,
+                'instrument_name': 'Unknown',
+                'files_by_instrument': {},
+                'total_files': 0,
+                'warnings': [f"Folder does not exist: {folder}"]
+            }
+
+        files_by_instrument = {}
+        warnings = []
+        total_files = 0
+
+        for entry in sorted(folder.iterdir()):
+            if entry.suffix == '.sig':
+                instrument = self.extract_instrument_from_file(str(entry))
+                total_files += 1
+
+                if instrument is None:
+                    warnings.append(f"Could not extract instrument from: {entry.name}")
+                    instrument = "Unknown"
+
+                if instrument not in files_by_instrument:
+                    files_by_instrument[instrument] = []
+                files_by_instrument[instrument].append(entry.name)
+
+        unique_instruments = list(files_by_instrument.keys())
+        is_consistent = len(unique_instruments) == 1
+
+        if is_consistent:
+            instrument_value = unique_instruments[0]
+            if instrument_value == "Unknown":
+                warnings.append("All files have unknown instrument values")
+                instrument_name = "Unknown"
+            else:
+                instrument_name = self._extract_instrument_name(instrument_value)
+        else:
+            instrument_value = None
+            instrument_name = "Mixed"
+            for instrument, files in files_by_instrument.items():
+                if len(files) > 1:
+                    warnings.append(f"Files with instrument '{instrument}': {', '.join(files)}")
+                else:
+                    warnings.append(f"File with instrument '{instrument}': {files[0]}")
+
+        return {
+            'consistent': is_consistent,
+            'instrument': instrument_value,
+            'instrument_name': instrument_name,
+            'files_by_instrument': files_by_instrument,
+            'total_files': total_files,
+            'warnings': warnings
+        }

svc_processing-0.1.1.dist-info/METADATA

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: svc-processing
+Version: 0.1.1
+Summary: Pure-Python SVC HR-1024i hyperspectral .sig processing pipeline
+Author: Gold Lab (GrapeSPEC project), Cornell University
+Author-email: Cole Regnier <nr466@cornell.edu>
+License-Expression: GPL-3.0-only
+Project-URL: Repository, https://github.com/regs08/SVCProcessingPipeline
+Keywords: hyperspectral,spectroscopy,SVC,HR-1024i,remote-sensing,reflectance
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Provides-Extra: demo
+Requires-Dist: matplotlib; extra == "demo"
+Requires-Dist: nbclient; extra == "demo"
+Requires-Dist: nbconvert; extra == "demo"
+Requires-Dist: nbformat; extra == "demo"
+Provides-Extra: dev
+Requires-Dist: pyflakes; extra == "dev"
+Requires-Dist: pytest>=8.3.0; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: vulture; extra == "dev"
+Dynamic: license-file
+
+# SIG Processing Pipeline
+
+A pure-Python pipeline for processing SVC HR-1024i field hyperspectral `.sig` files. Reads raw multi-detector spectra, performs sensor stitching and radiometric correction, applies resolution-matched Gaussian smoothing, and resamples onto a uniform 1 nm grid from 400–2500 nm. Numerically verified against the legacy R/`spectrolab` reference to better than 1 × 10⁻⁶ absolute reflectance.
+
+> **This README is the canonical entry point for both humans and LLMs.** Every directory in the repo has its own `README.md` describing its contents in detail. Follow the links below — do not assume anything that is not stated here or in the linked docs.
+
+---
+
+## Repository map
+
+| Path | Purpose | Read me first |
+|---|---|---|
+| [`TUTORIAL.md`](TUTORIAL.md) | Beginner walkthrough — starts in the Jupyter notebook (gentle path), with an advanced CLI track. | Start here if new |
+| [`pyproject.toml`](pyproject.toml) | Package metadata and `svc-pipeline` console script. | This file ↓ |
+| [`pipeline/`](pipeline/) | Core Python package: CLI, `SigFileProcessor`, `resample_spectra`, `SVCDataProcessor`. | [`pipeline/README.md`](pipeline/README.md) |
+| [`tests/`](tests/) | Pytest suite, including the R-vs-Python parity test. | [`tests/README.md`](tests/README.md) |
+| [`config/`](config/) | Run configs + instrument calibration JSONs. | [`config/README.md`](config/README.md) |
+| [`docs/`](docs/) | Manuscript-grade methods, parity reports, LLM re-test prompt. | [`docs/README.md`](docs/README.md) |
+| [`archived_r_scripts/`](archived_r_scripts/) | Frozen R/`spectrolab` reference (Pipeline A) — kept only for parity verification. | [`archived_r_scripts/README.md`](archived_r_scripts/README.md) |
+| [`notebooks/`](notebooks/) | Demo and visualization notebooks (not on the production path). | [`notebooks/README.md`](notebooks/README.md) |
+| [`naming_ids/`](naming_ids/) | Private CSV lookup tables for grouping scans into samples; only the schema README is tracked. | [`naming_ids/README.md`](naming_ids/README.md) |
+| [`FOLDER_STRUCTURE.md`](FOLDER_STRUCTURE.md) | Authoritative tree + reading order. | — |
+| [`ACKNOWLEDGMENTS.md`](ACKNOWLEDGMENTS.md) | Attribution, third-party licenses, and citation. | — |
+| [`LICENSE`](LICENSE) | GNU General Public License v3.0. | — |
+
+Generated outputs (gitignored): `pipeline_outputs/sig_processed/<run>/`, `pipeline_outputs/sig_resampled/<run>/`.
+
+---
+
+## Quick start
+
+> New to the pipeline? [`TUTORIAL.md`](TUTORIAL.md) starts with the interactive
+> Jupyter notebook (the gentle path) and has an advanced track for the CLI below.
+
+```bash
+python3.11 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e ".[dev,demo]"
+
+# Edit config/config.json — replace "<PATH_TO_SIG_INPUT_ROOT>" with your data path.
+svc-pipeline config.json
+```
+
+Outputs land under `pipeline_outputs/` by default. See [`config/README.md`](config/README.md) for every supported key.
+
+---
+
+## Pipeline architecture
+
+```
+   raw *.sig files (sig_input_dir)
+            │
+            ▼
+   ┌────────────────────────────────────┐
+   │ Stage 1: SigFileProcessor          │  pipeline/sig_processor.py
+   │   - instrument-consistency check   │
+   │   - truncate at calibration        │
+   │     end-line wavelength            │
+   │   - write summary CSV              │
+   └────────────────────────────────────┘
+            │
+            ▼  processed *.sig + *_processed_sig_summary.csv
+   ┌────────────────────────────────────┐
+   │ Stage 2: resample_spectra()        │  pipeline/resampler.py
+   │   - detect sensor segments         │
+   │   - guess_splice_at + trim         │
+   │   - match_sensors (iter = 1)       │
+   │   - smooth_fwhm (k=3 kmeans)       │
+   │   - Gaussian resample fwhm=10      │
+   │     onto 400–2500 nm @ 1 nm        │
+   └────────────────────────────────────┘
+            │
+            ▼  <run>_merged_spectra.csv
+   ┌────────────────────────────────────┐
+   │ Stage 3 (post-hoc, optional):      │  pipeline/processor.py
+   │   SVCDataProcessor /               │  + notebooks/
+   │   SigSpectraAverager — group &     │
+   │   average scans into samples.      │
+   └────────────────────────────────────┘
+```
+
+The `svc-pipeline` console script glues Stages 1 and 2 together through
+`pipeline.cli`; Stage 3 is invoked from notebooks against the Stage 2 output.
+The pipeline is **single-pass and idempotent per input directory** — previous
+processed `.sig` files in the target directory are deleted at the start of each
+run.
+
+For the formal algorithmic spec (every constant, every formula), read [`docs/supplementary_methods.md`](docs/supplementary_methods.md). That document — not this README — is the source of truth for *what* the code does.
+
+---
+
+## Running the pipeline
+
+```bash
+svc-pipeline [config] [options]
+```
+
+| Argument | Meaning |
+|---|---|
+| `config` | Run-config JSON (positional, optional; default `config/config.json`). Bare names resolve under `config/`, so `config.json`, `config`, and `config/config.json` are equivalent. See [`config/README.md`](config/README.md) for schema. |
+| `--input-dir <path>` | Override `sig_input_dir` and process only this directory. |
+| `--step {1,2,all}` | `1` = process + summary CSV only; `2` = resample only (requires Stage 1 to have been run); `all` = both (default). |
+| `--verbose` | Print INFO/DEBUG logs before and after each stage. |
+
+### Expected output layout
+
+```
+pipeline_outputs/
+├── sig_processed/<input_dir_name>/
+│   ├── <truncated *.sig files>
+│   └── <input_dir_name>_processed_sig_summary.csv
+└── sig_resampled/<input_dir_name>/
+    └── <input_dir_name>_merged_spectra.csv     # 2101 columns (400–2500 nm)
+```
+
+`summary_csv_name` and `merged_csv_name` in the run config are suffixes; the real filenames are prefixed with the input directory name. Verify your config in [`config/README.md`](config/README.md).
+
+---
+
+## Verification (R-vs-Python parity)
+
+The Python resampler is verified against the legacy R/`spectrolab` script ([`archived_r_scripts/merge_resample_sig.R`](archived_r_scripts/merge_resample_sig.R)). Acceptance threshold: **1 × 10⁻³ absolute reflectance** (0.1 %, well below the HR-1024i radiometric noise floor). Historical results:
+
+| Dataset | Samples | Max abs diff | Mean abs diff |
+|---|---|---|---|
+| Silver instrument (Serial 1202103) | 66 | 1.10 × 10⁻⁶ | 4.0 × 10⁻⁸ |
+| Bronze instrument (Serial 2212118), `a4any_sb_2025-cn_ch-svc-aviris_bottom` | 15 | 9.4 × 10⁻⁷ | 3.4 × 10⁻⁸ |
+
+Run the parity test (skipped automatically without reference data):
+
+```bash
+pytest tests/test_resampler_parity.py \
+    --r-reference-csv=/path/to/r_output/merged_spectra.csv \
+    --r-input-dir=/path/to/processed_sig_files/
+```
+
+To re-run parity on a new dataset, hand the prompt at [`docs/parity_retest_prompt.md`](docs/parity_retest_prompt.md) to any capable coding LLM. Full details in [`tests/README.md`](tests/README.md) and [`docs/README.md`](docs/README.md).
+
+---
+
+## Public Python API
+
+The most-used entry points (all importable from their concrete modules — `pipeline/__init__.py` is intentionally empty):
+
+```python
+from pipeline.sig_processor import SigFileProcessor   # truncation + instrument inspection
+from pipeline.resampler      import process_sig_file, resample_spectra
+from pipeline.processor      import (
+    SVCDataProcessor,      # chainable load/group/average
+    SigSpectraAverager,    # facade — pass a DataFrame, get aggregated DataFrame back
+    GroupSpec,             # GroupSpec.from_csv("naming_ids/<file>.csv")
+    find_spectra_by_name,  # cross-DataFrame name search
+)
+```
+
+Detailed signatures and behavioural notes in [`pipeline/README.md`](pipeline/README.md).
+
+---
+
+## For LLMs working in this repo
+
+1. **Read [`FOLDER_STRUCTURE.md`](FOLDER_STRUCTURE.md) first** — it lists every directory and the reading order.
+2. **Before modifying [`pipeline/resampler.py`](pipeline/resampler.py), re-read [`docs/supplementary_methods.md`](docs/supplementary_methods.md).** The constants `_FWHM_NM`, `_SIGMA_NM`, `_INTERP_WVL`, `_FIXED_SENSOR`, `_BAND_MIN`, `_BAND_MAX`, and the algorithm steps are load-bearing for the parity claim. Changing any of them requires re-running the parity test and writing a new `docs/parity_<dataset>_<date>.md`.
+3. **The R script at [`archived_r_scripts/merge_resample_sig.R`](archived_r_scripts/merge_resample_sig.R) is frozen.** Treat it as a behavioural reference, not as live code to edit.
+4. **Never commit machine paths or private data.** Use the placeholders already present in [`config/config.json`](config/config.json) and the notebooks.
+5. **Run `pytest` after any change to `pipeline/`.** The parity test will skip if reference data is unavailable; the rest of the suite still runs.
+
+---
+
+## Demo Notebook
+
+The demo notebook uses an external 15-file `.sig` artifact because raw headers
+contain GPS/location metadata. Prepare local demo data with:
+
+```bash
+python3 scripts/prepare_demo_data.py \
+  --source-dir data/a4any_sb_2025-cn_ch-svc-aviris_bottom
+```
+
+The notebook is config-driven: edit the settings cell (`DATA_FOLDER`,
+`OUTPUT_FOLDER`, `INSTRUMENT`) to run it on your own data and instrument. See
+[`notebooks/pipeline_demo/README.md`](notebooks/pipeline_demo/README.md).
+
+---
+
+## Requirements
+
+Python 3.11 is the supported runtime. Runtime, demo, and development
+dependencies are declared in [`pyproject.toml`](pyproject.toml).
+
+- `numpy`, `scipy`, `pandas` — numerical core.
+- `matplotlib` — demo notebook plotting.
+- `pytest>=8.3.0` — test runner for local verification.
+
+Install with `python -m pip install -e ".[dev,demo]"` for local development and
+use `svc-pipeline = "pipeline.cli:main"` as the command-line entry point.
+
+R is **not** required for the production pipeline. It is needed only to regenerate Pipeline A parity references; see [`archived_r_scripts/README.md`](archived_r_scripts/README.md).
+
+---
+
+## License
+
+Released under the [GNU General Public License v3.0](LICENSE) © 2026 Cole
+Regnier ([regs08](https://github.com/regs08), nr466@cornell.edu), Gold Lab
+(GrapeSPEC project), Cornell University. The package uses the SPDX expression
+`GPL-3.0-only`, chosen for compatibility with the GPL-3 `spectrolab` reference
+implementation.
+
+---
+
+## Acknowledgments & Citation
+
+This project is an independent reimplementation of the **spectrolab** algorithm
+(no source copied) and builds on prior field-spectroscopy work. See
+[`ACKNOWLEDGMENTS.md`](ACKNOWLEDGMENTS.md) for full attribution, third-party
+licenses, and how to cite this software and spectrolab.

svc_processing-0.1.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pipeline/cli.py,sha256=jYlIKIVWuMWgHvQjpWuinz58xyqSOJwBXyDM1Nv5lBw,3185
+pipeline/processor.py,sha256=-STrqx-jqY0ax0xQAZxkqGZ1AJEtsw0DkwzCAaKv1vA,23150
+pipeline/resampler.py,sha256=6EAWs7gvxtM4hoLraZ-s1jiTt7Jl1nCxm23mR5kfR1w,19917
+pipeline/run_config.py,sha256=P2wzjJ-6Kbx3pP37klQo-11r6tCVRCDQ-UGJo91eYqs,13207
+pipeline/runner.py,sha256=mJtHZckn25rA6F_bDPu2sp5XMcRrr3IiMXS7Roholmk,8345
+pipeline/sig_processor.py,sha256=EQZhQxAxnviCYFdEDPZ278OnyVVvl1MQlbFnat5EeqY,10739
+svc_processing-0.1.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+svc_processing-0.1.1.dist-info/METADATA,sha256=8Cye5PSZMVU7xemjtj7PWGrwbEIYQB4GU1kTjUyBUkw,12356
+svc_processing-0.1.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+svc_processing-0.1.1.dist-info/entry_points.txt,sha256=kBXIcL7fl8QtSFslLKnuB57jPn50rywWc-0uCNLZan8,51
+svc_processing-0.1.1.dist-info/top_level.txt,sha256=Qdc1eKrvhKK_o9CPbdooOdDt7g3ZSXZDrNXHmUGl94Q,9
+svc_processing-0.1.1.dist-info/RECORD,,

svc_processing-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

svc_processing-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+svc-pipeline = pipeline.cli:main