vcti-array-display 1.1.0__tar.gz

vcti_array_display-1.1.0/CHANGELOG.md

@@ -0,0 +1,70 @@
+# Changelog
+
+All notable changes to `vcti-array-display` are documented here.
+
+## [1.1.0] — 2026-03-29
+
+### Fixed
+- `column_list=[]` was treated as `None` (showed all columns instead of none).
+- `set_view_columns()` now copies the input list defensively — external
+  mutation of the passed list no longer corrupts internal state.
+- `assert` statements replaced with proper `TypeError`/`ValueError` raises —
+  safe under `python -O`.
+- `pd.get_option("display.max_rows")` returning `0` no longer falls through
+  to default.
+- Stale zero-copy claims removed from README and performance guide (pandas
+  copies structured arrays into DataFrames).
+
+### Added
+- **Read-only properties** — `view_columns`, `name_columns`, `field_components`
+  return defensive copies / `MappingProxyType` to prevent accidental mutation.
+- **`copy()`** — shallow copy with shared array and independent configuration.
+- **`to_slice()` conflict detection** — raises `ValueError` when incompatible
+  parameters are combined (e.g. `mask` with `head`/`tail`).
+- **`ColumnExclusion`** exported from top-level `__init__.py` for typed
+  consumer code.
+- **`__repr__`** now shows active features: flattened field count and enum
+  mapping count alongside rows/cols.
+- **`extending.md`** — contributor guide for adding adapters, patterns, and
+  integrating with vcti-array-tree (including ecosystem diagram).
+- **`examples/full_pipeline.py`** — complete end-to-end script demonstrating
+  all five pillars.
+- **`array_display.pyi`** — type stub file for improved IDE support.
+- **Sphinx `conf.py`** — enables doc builds with autodoc and MyST-Parser.
+- **`MANIFEST.in`** — controls sdist contents, excludes tests/docs/.claude.
+- **`tests/bench_array_display.py`** — performance regression benchmarks
+  verifying O(displayed rows) on 10M-row arrays (marked `@pytest.mark.benchmark`).
+- **Python 3.14** added to CI test matrix.
+- Parametrized exclusion pattern tests.
+- Tests for empty column list, to_slice conflicts, read-only properties, copy().
+- Troubleshooting entries: empty `field_components`, enum debugging,
+  `_column_aliases` tracking.
+- Performance guide: O() complexity table and bounded-vs-full guidance.
+- Source guide: `_column_aliases` lifecycle documentation with examples.
+- Design guide: copy-vs-mutation guidance, strict slicing parameters.
+
+### Changed
+- `import_pandas()` return type narrowed from `Any` to `types.ModuleType`.
+- `math.prod()` replaces manual loop in `_flattening.py`.
+- `to_dataframe()` docstring no longer claims zero-copy.
+- `CONTRIBUTING.md` includes `mypy` and `typecheck` dependency group.
+
+### Removed
+- Unused `conftest.py` fixtures (tests use inline helpers).
+
+## [1.0.0] — 2026-03-28
+
+### Added
+- Initial release.
+- **Column filtering** — `exclude_columns` with str, regex, or callable rules.
+  Pre-built patterns: `FILLER_COLUMNS` (C++ alignment) and `LENGTH_COLUMNS`
+  (internal string lengths).
+- **Dtype flattening** — `flatten_dtype` expands vector/matrix fields.
+  `component_names` and `set_component_names()` for custom suffixes.
+  `field_components` tracks the grouping for consumer use.
+- **Enum mapping** — `add_name_columns()` with lazy resolution on bounded slices.
+- **Array slicing** — `to_slice()` returns index arrays (head, tail, mask, indices).
+- **Adapters** — `to_table()` (pure numpy text table), `to_dataframe()`
+  (pandas with `pd.Categorical`), `_repr_html_()` (Jupyter).
+- Optional `pandas` dependency for DataFrame and Jupyter features.
+- Structured array validation in `set_array()`.

vcti_array_display-1.1.0/CONTRIBUTING.md

@@ -0,0 +1,57 @@
+# Contributing to vcti-array-display
+
+## Development Setup
+
+```bash
+python -m venv .venv
+source .venv/bin/activate   # Windows: .venv\Scripts\activate
+pip install -e ".[test,lint,typecheck]"
+```
+
+## Running Tests
+
+```bash
+pytest
+```
+
+Coverage is enforced at 95% via `pyproject.toml`.
+
+## Type Checking
+
+```bash
+mypy src/
+```
+
+## Linting and Formatting
+
+```bash
+ruff check src/ tests/          # lint
+ruff format --check src/ tests/ # format check
+ruff check --fix src/ tests/    # auto-fix
+ruff format src/ tests/         # apply formatting
+```
+
+## Project Layout
+
+```
+src/vcti/arraydisplay/   # Source code
+tests/                 # Tests (test_<module>.py)
+docs/                  # Documentation
+```
+
+## Architecture
+
+The source code is organized around five pillars:
+
+1. **Column filtering** — name, regex, and dtype-based exclusion
+2. **Dtype flattening** — vector/matrix expansion with component tracking
+3. **Enum mapping** — lazy integer-to-name resolution
+4. **Array slicing** — lightweight index arrays for bounded access
+5. **Adapters** — text table and pandas DataFrame rendering
+
+See [docs/source-guide.md](docs/source-guide.md) for a detailed walkthrough.
+
+## Guidelines
+
+- Follow Google-style docstrings and PEP 585/604 type annotations.
+- See [docs/design.md](docs/design.md) for design decisions and boundaries.

vcti_array_display-1.1.0/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2018-2026 Visual Collaboration Technologies Inc.
+All Rights Reserved.
+
+This software is proprietary and confidential. Unauthorized copying,
+distribution, or use of this software, via any medium, is strictly
+prohibited. Access is granted only to authorized VCollab developers
+and individuals explicitly authorized by Visual Collaboration
+Technologies Inc.

vcti_array_display-1.1.0/MANIFEST.in

@@ -0,0 +1,12 @@
+include LICENSE
+include README.md
+include CHANGELOG.md
+include CONTRIBUTING.md
+include SECURITY.md
+
+recursive-include src/vcti *.py py.typed
+
+prune tests
+prune docs
+prune .claude
+prune .github

vcti_array_display-1.1.0/PKG-INFO

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: vcti-array-display
+Version: 1.1.0
+Summary: Presentation layer for NumPy structured arrays — column filtering, dtype flattening, enum mapping, array slicing, and adapters
+Author: Visual Collaboration Technologies Inc.
+Requires-Python: <3.15,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: vcti-nputils>=1.0.0
+Provides-Extra: pandas
+Requires-Dist: pandas>=2.0; extra == "pandas"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pandas>=2.0; extra == "test"
+Provides-Extra: lint
+Requires-Dist: ruff; extra == "lint"
+Provides-Extra: typecheck
+Requires-Dist: mypy; extra == "typecheck"
+Requires-Dist: pandas-stubs; extra == "typecheck"
+Dynamic: license-file
+
+# Array Display
+
+Presentation layer for NumPy structured arrays.
+
+ArrayDisplay wraps a structured NumPy array reference (no copy) and provides
+five capabilities for controlling how the data is presented:
+
+1. **Column filtering** — hide columns by name, regex, or predicate
+2. **Dtype flattening** — expand vector/matrix fields into scalar columns with custom component names
+3. **Enum mapping** — lazily map integer ID columns to human-readable names
+4. **Array slicing** — create lightweight index arrays for bounded access
+5. **Adapters** — render as text table or pandas DataFrame on bounded slices
+
+## Installation
+
+```bash
+pip install vcti-array-display>=1.1.0
+```
+
+With pandas support (optional):
+
+```bash
+pip install vcti-array-display[pandas]>=1.1.0
+```
+
+---
+
+## 1. Column Filtering
+
+Hide unwanted columns using any combination of exact names, regex patterns,
+and callable predicates.
+
+```python
+import re
+import numpy as np
+from vcti.arraydisplay import ArrayDisplay, FILLER_COLUMNS, LENGTH_COLUMNS, VOID_COLUMNS
+
+dt = np.dtype([
+    ('id', 'i4'), ('f0', 'V4'), ('label', 'U20'),
+    ('label_len', 'i4'), ('value', 'f8'), ('f3', 'V8'),
+])
+arr = np.zeros(10, dtype=dt)
+
+# Pre-built patterns for C++ interop noise
+view = ArrayDisplay(arr, exclude_columns=[FILLER_COLUMNS, LENGTH_COLUMNS])
+view.view_columns  # ['id', 'label', 'value']
+
+# Or exclude by dtype — catches all void padding regardless of name
+view = ArrayDisplay(arr, exclude_columns=[VOID_COLUMNS, LENGTH_COLUMNS])
+
+# Mix exact names, regex, and callables
+view = ArrayDisplay(arr, exclude_columns=[
+    FILLER_COLUMNS,                        # regex: ^f\d+$
+    LENGTH_COLUMNS,                        # regex: _len$
+    "debug_flag",                          # exact name
+    re.compile(r"^tmp_"),                  # custom regex
+    lambda name, dtype: dtype.kind == 'V', # by dtype
+])
+```
+
+No magic defaults — `ArrayDisplay(arr)` shows all columns.  Pre-built patterns
+`FILLER_COLUMNS`, `LENGTH_COLUMNS`, and `VOID_COLUMNS` are opt-in.
+Callables receive `(name, dtype)` for filtering by type, shape, or both.
+
+## 2. Dtype Flattening
+
+Expand vector and matrix fields into individual scalar columns, with
+optional user-defined component names.
+
+```python
+dt = np.dtype([('id', 'i4'), ('position', 'f8', (3,))])
+arr = np.zeros(5, dtype=dt)
+
+# Default numeric suffixes
+view = ArrayDisplay(arr, flatten_dtype=True)
+view.view_columns  # ['id', 'position_0', 'position_1', 'position_2']
+
+# Custom component names
+view = ArrayDisplay(arr, flatten_dtype=True,
+                 component_names={'position': ['x', 'y', 'z']})
+view.view_columns  # ['id', 'position_x', 'position_y', 'position_z']
+
+# Component grouping is tracked for consumers (e.g., header spanning)
+view.field_components
+# {'position': ['position_x', 'position_y', 'position_z']}
+
+# Rename after construction
+view.set_component_names('position', ['lat', 'lon', 'alt'])
+```
+
+> **Note:** Default flattened names (e.g., `position_0`) are generated by
+> `vcti-nputils` and may truncate long field names.  Use `component_names`
+> to ensure predictable, readable column names regardless of the defaults.
+
+## 3. Enum Mapping
+
+Map integer ID columns to human-readable names.  The mapping is stored as
+a recipe and resolved lazily — only when presenting a bounded slice.
+
+```python
+dt = np.dtype([('id', 'i4'), ('element_type', 'i4'), ('value', 'f8')])
+arr = np.array([(1, 1, 10.5), (2, 2, 20.3), (3, 1, 15.0)], dtype=dt)
+view = ArrayDisplay(arr)
+
+view.add_name_columns({
+    'element_type_name': ('element_type', {1: 'QUAD', 2: 'HEX'}),
+})
+view.view_columns  # ['id', 'element_type_name', 'value']
+
+# The mapping is NOT materialized yet — it's a recipe:
+view.name_columns
+# {'element_type_name': ('element_type', {1: 'QUAD', 2: 'HEX'})}
+```
+
+## 4. Array Slicing
+
+Create lightweight index arrays for bounded access.  The index array is
+tiny regardless of the underlying array size.
+
+```python
+idx = view.to_slice(head=20)                       # first 20 rows
+idx = view.to_slice(tail=10)                       # last 10 rows
+idx = view.to_slice(head=10, tail=5)               # first 10 + last 5
+idx = view.to_slice(mask=arr['value'] > 50)        # boolean filter
+idx = view.to_slice(indices=np.array([0, 100, 999]))  # explicit
+
+view.array[idx]                                    # sliced data
+```
+
+## 5. Adapters
+
+### Text table (pure numpy — no extra dependencies)
+
+```python
+print(view.to_table(head=10, tail=5))
+# id | element_type_name | value
+# ---+-------------------+------
+#  1 | QUAD              |  10.5
+#  2 | HEX               |  20.3
+# ...
+# [1000 rows x 3 columns]
+```
+
+### pandas DataFrame (optional dependency)
+
+```python
+df = view.to_dataframe()                   # full array
+df = view.to_dataframe(head=100)           # first 100 rows
+df = view.to_dataframe(resolve_names=False)  # raw ID columns
+```
+
+Enum names are materialized using `pd.Categorical` for memory efficiency.
+
+### Jupyter notebooks
+
+ArrayDisplay provides `_repr_html_()` — displays a bounded row window with
+enum names resolved automatically.
+
+---
+
+## Performance
+
+Designed for large CAE arrays (millions of rows, GBs of data):
+
+- **No array copy** — wraps a reference to the original numpy array
+- **Lazy enum resolution** — resolved only on the displayed slice
+- **Index arrays** — `to_slice()` returns kilobytes regardless of array size
+- **Bounded presentation** — `to_table()` and `to_dataframe(head=N)` never touch the full array
+- **`pd.Categorical`** — ~100x less memory than string columns for enum values
+
+---
+
+## API Summary
+
+| Method | Pillar | Description |
+|--------|--------|-------------|
+| `set_view_columns(...)` | Filtering | Configure visible columns |
+| `include_view_columns(cols)` | Filtering | Add columns to the view |
+| `exclude_view_columns(cols)` | Filtering | Remove columns from the view |
+| `replace_view_columns(mapping)` | Filtering | Rename columns in the view |
+| `set_array(arr, ...)` | Flattening | Set array with optional flattening |
+| `set_component_names(field, names)` | Flattening | Rename flattened components |
+| `add_name_columns(mappings)` | Enum mapping | Register lazy enum mappings |
+| `to_slice(...)` | Slicing | Create index array for bounded access |
+| `to_table(...)` | Adapter | Render text table (pure numpy) |
+| `to_dataframe(...)` | Adapter | Convert to pandas DataFrame |
+| `copy()` | Misc | Shallow copy with independent config |
+| `append_columns(cols)` | Misc | Join additional structured columns |
+
+## Examples
+
+See [examples/full_pipeline.py](examples/full_pipeline.py) for a complete
+end-to-end script demonstrating all five pillars.
+
+## Dependencies
+
+- [numpy](https://numpy.org/) (>=1.24) — required
+- [vcti-nputils](https://pypi.org/project/vcti-nputils/) (>=1.0.0) — required
+- [pandas](https://pandas.pydata.org/) (>=2.0) — optional, for `to_dataframe()` and Jupyter display

vcti_array_display-1.1.0/README.md

@@ -0,0 +1,199 @@
+# Array Display
+
+Presentation layer for NumPy structured arrays.
+
+ArrayDisplay wraps a structured NumPy array reference (no copy) and provides
+five capabilities for controlling how the data is presented:
+
+1. **Column filtering** — hide columns by name, regex, or predicate
+2. **Dtype flattening** — expand vector/matrix fields into scalar columns with custom component names
+3. **Enum mapping** — lazily map integer ID columns to human-readable names
+4. **Array slicing** — create lightweight index arrays for bounded access
+5. **Adapters** — render as text table or pandas DataFrame on bounded slices
+
+## Installation
+
+```bash
+pip install vcti-array-display>=1.1.0
+```
+
+With pandas support (optional):
+
+```bash
+pip install vcti-array-display[pandas]>=1.1.0
+```
+
+---
+
+## 1. Column Filtering
+
+Hide unwanted columns using any combination of exact names, regex patterns,
+and callable predicates.
+
+```python
+import re
+import numpy as np
+from vcti.arraydisplay import ArrayDisplay, FILLER_COLUMNS, LENGTH_COLUMNS, VOID_COLUMNS
+
+dt = np.dtype([
+    ('id', 'i4'), ('f0', 'V4'), ('label', 'U20'),
+    ('label_len', 'i4'), ('value', 'f8'), ('f3', 'V8'),
+])
+arr = np.zeros(10, dtype=dt)
+
+# Pre-built patterns for C++ interop noise
+view = ArrayDisplay(arr, exclude_columns=[FILLER_COLUMNS, LENGTH_COLUMNS])
+view.view_columns  # ['id', 'label', 'value']
+
+# Or exclude by dtype — catches all void padding regardless of name
+view = ArrayDisplay(arr, exclude_columns=[VOID_COLUMNS, LENGTH_COLUMNS])
+
+# Mix exact names, regex, and callables
+view = ArrayDisplay(arr, exclude_columns=[
+    FILLER_COLUMNS,                        # regex: ^f\d+$
+    LENGTH_COLUMNS,                        # regex: _len$
+    "debug_flag",                          # exact name
+    re.compile(r"^tmp_"),                  # custom regex
+    lambda name, dtype: dtype.kind == 'V', # by dtype
+])
+```
+
+No magic defaults — `ArrayDisplay(arr)` shows all columns.  Pre-built patterns
+`FILLER_COLUMNS`, `LENGTH_COLUMNS`, and `VOID_COLUMNS` are opt-in.
+Callables receive `(name, dtype)` for filtering by type, shape, or both.
+
+## 2. Dtype Flattening
+
+Expand vector and matrix fields into individual scalar columns, with
+optional user-defined component names.
+
+```python
+dt = np.dtype([('id', 'i4'), ('position', 'f8', (3,))])
+arr = np.zeros(5, dtype=dt)
+
+# Default numeric suffixes
+view = ArrayDisplay(arr, flatten_dtype=True)
+view.view_columns  # ['id', 'position_0', 'position_1', 'position_2']
+
+# Custom component names
+view = ArrayDisplay(arr, flatten_dtype=True,
+                 component_names={'position': ['x', 'y', 'z']})
+view.view_columns  # ['id', 'position_x', 'position_y', 'position_z']
+
+# Component grouping is tracked for consumers (e.g., header spanning)
+view.field_components
+# {'position': ['position_x', 'position_y', 'position_z']}
+
+# Rename after construction
+view.set_component_names('position', ['lat', 'lon', 'alt'])
+```
+
+> **Note:** Default flattened names (e.g., `position_0`) are generated by
+> `vcti-nputils` and may truncate long field names.  Use `component_names`
+> to ensure predictable, readable column names regardless of the defaults.
+
+## 3. Enum Mapping
+
+Map integer ID columns to human-readable names.  The mapping is stored as
+a recipe and resolved lazily — only when presenting a bounded slice.
+
+```python
+dt = np.dtype([('id', 'i4'), ('element_type', 'i4'), ('value', 'f8')])
+arr = np.array([(1, 1, 10.5), (2, 2, 20.3), (3, 1, 15.0)], dtype=dt)
+view = ArrayDisplay(arr)
+
+view.add_name_columns({
+    'element_type_name': ('element_type', {1: 'QUAD', 2: 'HEX'}),
+})
+view.view_columns  # ['id', 'element_type_name', 'value']
+
+# The mapping is NOT materialized yet — it's a recipe:
+view.name_columns
+# {'element_type_name': ('element_type', {1: 'QUAD', 2: 'HEX'})}
+```
+
+## 4. Array Slicing
+
+Create lightweight index arrays for bounded access.  The index array is
+tiny regardless of the underlying array size.
+
+```python
+idx = view.to_slice(head=20)                       # first 20 rows
+idx = view.to_slice(tail=10)                       # last 10 rows
+idx = view.to_slice(head=10, tail=5)               # first 10 + last 5
+idx = view.to_slice(mask=arr['value'] > 50)        # boolean filter
+idx = view.to_slice(indices=np.array([0, 100, 999]))  # explicit
+
+view.array[idx]                                    # sliced data
+```
+
+## 5. Adapters
+
+### Text table (pure numpy — no extra dependencies)
+
+```python
+print(view.to_table(head=10, tail=5))
+# id | element_type_name | value
+# ---+-------------------+------
+#  1 | QUAD              |  10.5
+#  2 | HEX               |  20.3
+# ...
+# [1000 rows x 3 columns]
+```
+
+### pandas DataFrame (optional dependency)
+
+```python
+df = view.to_dataframe()                   # full array
+df = view.to_dataframe(head=100)           # first 100 rows
+df = view.to_dataframe(resolve_names=False)  # raw ID columns
+```
+
+Enum names are materialized using `pd.Categorical` for memory efficiency.
+
+### Jupyter notebooks
+
+ArrayDisplay provides `_repr_html_()` — displays a bounded row window with
+enum names resolved automatically.
+
+---
+
+## Performance
+
+Designed for large CAE arrays (millions of rows, GBs of data):
+
+- **No array copy** — wraps a reference to the original numpy array
+- **Lazy enum resolution** — resolved only on the displayed slice
+- **Index arrays** — `to_slice()` returns kilobytes regardless of array size
+- **Bounded presentation** — `to_table()` and `to_dataframe(head=N)` never touch the full array
+- **`pd.Categorical`** — ~100x less memory than string columns for enum values
+
+---
+
+## API Summary
+
+| Method | Pillar | Description |
+|--------|--------|-------------|
+| `set_view_columns(...)` | Filtering | Configure visible columns |
+| `include_view_columns(cols)` | Filtering | Add columns to the view |
+| `exclude_view_columns(cols)` | Filtering | Remove columns from the view |
+| `replace_view_columns(mapping)` | Filtering | Rename columns in the view |
+| `set_array(arr, ...)` | Flattening | Set array with optional flattening |
+| `set_component_names(field, names)` | Flattening | Rename flattened components |
+| `add_name_columns(mappings)` | Enum mapping | Register lazy enum mappings |
+| `to_slice(...)` | Slicing | Create index array for bounded access |
+| `to_table(...)` | Adapter | Render text table (pure numpy) |
+| `to_dataframe(...)` | Adapter | Convert to pandas DataFrame |
+| `copy()` | Misc | Shallow copy with independent config |
+| `append_columns(cols)` | Misc | Join additional structured columns |
+
+## Examples
+
+See [examples/full_pipeline.py](examples/full_pipeline.py) for a complete
+end-to-end script demonstrating all five pillars.
+
+## Dependencies
+
+- [numpy](https://numpy.org/) (>=1.24) — required
+- [vcti-nputils](https://pypi.org/project/vcti-nputils/) (>=1.0.0) — required
+- [pandas](https://pandas.pydata.org/) (>=2.0) — optional, for `to_dataframe()` and Jupyter display

vcti_array_display-1.1.0/SECURITY.md

@@ -0,0 +1,28 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability in any vcti package, please report
+it responsibly using one of the following channels:
+
+- **Public repositories:** Open an issue on the GitHub repository, or email
+  security@vcollab.com if the vulnerability should not be disclosed publicly
+  before a fix is available.
+- **Private repositories:** Email security@vcollab.com directly.
+
+Please include:
+
+- Description of the vulnerability
+- Steps to reproduce
+- Affected versions
+- Any potential impact assessment
+
+## Scope
+
+vcti-array-display is a pure data presentation library that operates on
+in-memory NumPy arrays only. It does not handle network I/O, file I/O,
+user authentication, or external service calls. Security concerns are
+limited to:
+
+- Processing untrusted structured array data (malformed dtypes)
+- Memory safety when working with numpy array views

vcti_array_display-1.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vcti-array-display"
+version = "1.1.0"
+description = "Presentation layer for NumPy structured arrays — column filtering, dtype flattening, enum mapping, array slicing, and adapters"
+readme = "README.md"
+authors = [
+    {name = "Visual Collaboration Technologies Inc."}
+]
+requires-python = ">=3.12,<3.15"
+dependencies = [
+    "numpy>=1.24",
+    "vcti-nputils>=1.0.0",
+]
+
+[project.optional-dependencies]
+pandas = ["pandas>=2.0"]
+test = ["pytest", "pytest-cov", "pandas>=2.0"]
+lint = ["ruff"]
+typecheck = ["mypy", "pandas-stubs"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["vcti.arraydisplay", "vcti.arraydisplay.*"]
+
+[tool.setuptools.package-data]
+"vcti.arraydisplay" = ["py.typed", "*.pyi"]
+
+[tool.setuptools]
+zip-safe = true
+
+[tool.pytest.ini_options]
+addopts = "--cov=vcti.arraydisplay --cov-report=term-missing --cov-fail-under=95"
+markers = ["benchmark: performance regression benchmarks (may allocate large arrays)"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 99
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP"]

vcti_array_display-1.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vcti_array_display-1.1.0/src/vcti/arraydisplay/__init__.py

@@ -0,0 +1,19 @@
+# Copyright Visual Collaboration Technologies Inc. All Rights Reserved.
+# See LICENSE for details.
+"""vcti.arraydisplay — Presentation layer for NumPy structured arrays."""
+
+from importlib.metadata import version
+
+from ._exclusion import FILLER_COLUMNS, LENGTH_COLUMNS, VOID_COLUMNS, ColumnExclusion
+from .array_display import ArrayDisplay
+
+__version__ = version("vcti-array-display")
+
+__all__ = [
+    "__version__",
+    "ArrayDisplay",
+    "ColumnExclusion",
+    "FILLER_COLUMNS",
+    "LENGTH_COLUMNS",
+    "VOID_COLUMNS",
+]