ramtable 0.3.1__tar.gz → 0.3.3__tar.gz

{ramtable-0.3.1 → ramtable-0.3.3}/.github/workflows/tests.yml

@@ -26,10 +26,11 @@ jobs:
       fail-fast: false
       matrix:
         python-version:
-          - "3.10"
           - "3.11"
           - "3.12"
           - "3.13"
+          - "3.14"
+          - "3.15"
 
     steps:
       - name: Check out repository

{ramtable-0.3.1 → ramtable-0.3.3}/CHANGELOG.md

@@ -3,6 +3,37 @@
 Notable changes to RAMTable are documented in this file. The history starts
 with the project's first version.
 
+## [0.3.3]
+
+Adds contribution guidelines for the project.
+
+### Added
+
+- `CONTRIBUTING.md` covering contribution scope, the prior-approval policy
+  for new features, single-maintainer review expectations, branch naming,
+  development setup, testing expectations, and pull request guidelines.
+
+### Changed
+
+- `rows.py` changed `indices` to `indexes` in `get()` methods.
+
+## [0.3.2]
+
+Raises the minimum supported Python version, expands the tested versions,
+and centralizes the package version.
+
+### Added
+
+- `ramtable.__version__` exposes the installed distribution version, read
+  from package metadata.
+
+### Changed
+
+- Python 3.11 or later is now required; support for Python 3.10 was removed.
+- Added Python 3.14 and 3.15 to the test matrix and package classifiers.
+- `pyproject.toml` is the single source of truth for the version; the README
+  uses a dynamic PyPI badge instead of a hardcoded number.
+
 ## [0.3.1]
 
 Publishes RAMTable to the official PyPI index alongside TestPyPI.
@@ -19,7 +50,6 @@ Publishes RAMTable to the official PyPI index alongside TestPyPI.
 
 - Installation documentation covers stable releases from PyPI and
   pre-releases from TestPyPI.
-- `pyproject.toml` reports version `0.3.1rc0`.
 
 ## [0.3.0]
 

ramtable-0.3.3/CONTRIBUTING.md

@@ -0,0 +1,281 @@
+# Contributing to RAMTable
+
+Thank you for considering a contribution to RAMTable. Bug fixes,
+documentation improvements, tests, refactorings, performance work, and
+approved new features are all welcome. This guide explains how the project is
+maintained and how to prepare a contribution that is easy to review.
+
+## Contents
+
+- [Ways to contribute](#ways-to-contribute)
+- [New features require approval](#new-features-require-approval)
+- [Maintenance and review expectations](#maintenance-and-review-expectations)
+- [Branch workflow](#branch-workflow)
+- [Development setup](#development-setup)
+- [Checks, testing, and supported Python versions](#checks-testing-and-supported-python-versions)
+- [Code style and documentation](#code-style-and-documentation)
+- [Changelog and versioning](#changelog-and-versioning)
+- [Pull request guidelines](#pull-request-guidelines)
+- [Reporting bugs](#reporting-bugs)
+- [License](#license)
+
+## Ways to contribute
+
+Contributions of all sizes are appreciated:
+
+- bug fixes;
+- documentation improvements;
+- tests and test coverage;
+- code refactoring;
+- performance improvements;
+- new features, after prior approval;
+- other improvements that fit the project's goals.
+
+## New features require approval
+
+To keep the project's direction coherent and avoid work that may not fit its
+goals, **new features must be approved before implementation**.
+
+Before writing code for a new feature:
+
+1. Open a GitHub Issue describing the proposed functionality.
+2. Explain the problem it solves and why it would be useful.
+3. Wait for a maintainer to approve the proposal.
+
+Pull requests that introduce unapproved features may be closed without being
+merged. If you are unsure whether your idea counts as a new feature, open an
+Issue and ask before starting.
+
+Small fixes, documentation updates, and refactorings that do not change
+behavior do not need prior approval.
+
+## Maintenance and review expectations
+
+**RAMTable is currently maintained by a single developer.** There is no
+dedicated team handling Issues or reviewing pull requests.
+
+As a result:
+
+- Issue responses may take some time.
+- Pull request reviews may be delayed.
+- A contribution may remain pending for a while before receiving feedback.
+- Immediate responses and merges should not be expected.
+- The maintainer reviews contributions as time and availability allow.
+
+This does not mean contributions are unwelcome. Every report and pull request
+is appreciated, and a polite follow-up after a reasonable waiting period is
+fine. Clear, focused contributions are easier to review and more likely to
+move forward.
+
+## Branch workflow
+
+The development branch is **`dev`**. Open contributions as pull requests
+against `dev`.
+
+Maintainers promote releases through the permanent branches:
+
+```text
+dev → test_pypi → main
+```
+
+`test_pypi` and `main` are release branches. Unless a maintainer asks you
+otherwise, do not open contribution pull requests against them.
+
+Create a branch from an up-to-date `dev` and use one of these prefixes:
+
+| Prefix | Purpose | Example |
+|---|---|---|
+| `feat/` | New features approved through an Issue | `feat/bulk-insert` |
+| `fix/` | Bug fixes | `fix/column-validation` |
+| `docs/` | Documentation changes | `docs/api-reference` |
+| `refactor/` | Code refactoring | `refactor/row-storage` |
+| `test/` | Test-related changes | `test/column-edge-cases` |
+
+For example:
+
+```bash
+git switch dev
+git pull upstream dev
+git switch -c fix/column-validation
+```
+
+These commands assume the `upstream` remote added in
+[Development setup](#development-setup).
+
+## Development setup
+
+RAMTable requires **Python 3.11 or later**.
+
+1. Fork the repository on GitHub.
+2. Clone your fork and add the upstream repository:
+
+   ```bash
+   git clone https://github.com/<your-user>/ramtable_py.git
+   cd ramtable_py
+   git remote add upstream https://github.com/thiagostilo2121/ramtable_py.git
+   ```
+
+3. Create and activate a virtual environment:
+
+   ```bash
+   python3 -m venv .venv
+   source .venv/bin/activate
+   ```
+
+   On Windows, use `python` instead of `python3` and activate with:
+
+   ```powershell
+   .venv\Scripts\activate
+   ```
+
+4. Install the project in editable mode:
+
+   ```bash
+   python -m pip install --upgrade pip
+   python -m pip install --editable .
+   ```
+
+RAMTable has no runtime dependencies, and the repository does not define
+development dependencies or extras. If you need to build distributions, install
+the build tools separately:
+
+```bash
+python -m pip install build twine
+```
+
+## Checks, testing, and supported Python versions
+
+The repository does not currently include an automated test suite, and no
+linter, formatter, or static type checker is configured. Contributions should
+still be verified locally.
+
+The CI workflow installs the package, byte-compiles it, and checks the public
+imports. You can run the same checks from the repository root:
+
+```bash
+python -m compileall -q src/ramtable
+python -c "from ramtable import Columns, Rows, Table"
+```
+
+If you build distributions, validate them with:
+
+```bash
+python -m build
+python -m twine check dist/*
+```
+
+GitHub Actions runs these checks on Python **3.11, 3.12, 3.13, 3.14, and
+3.15** for pushes to `dev` and for pull requests targeting `dev`, `test_pypi`,
+and `main`. Pull requests targeting `test_pypi` and `main` also run the
+release validation and build; publication happens only after a pull request is
+merged. Keep every change compatible with all supported versions.
+
+### What to test
+
+- **Bug fixes:** include a regression test that fails before the fix and
+  passes afterwards, once a test framework is available. Until then, describe
+  the reproduction steps and the verification you performed in the pull
+  request.
+- **New functionality:** include tests with the implementation. Because the
+  project does not yet have a configured test framework, discuss the proposed
+  testing approach in the feature Issue first.
+- **Documentation and refactorings:** confirm that the existing examples and
+  public imports still work.
+
+Do not claim that a check is passing if you did not run it.
+
+## Code style and documentation
+
+Follow the style and structure already used in `src/ramtable`:
+
+- use four-space indentation and keep lines close to 79 characters;
+- add type hints to functions and methods;
+- write docstrings in the existing style, with `Args`, `Returns`, and
+  `Raises` sections where applicable;
+- raise standard exceptions with clear messages, such as `ValueError`,
+  `TypeError`, or `IndexError`;
+- preserve the library's validate-then-write behavior: validate a request
+  completely before modifying stored rows;
+- keep the public API consistent, and expose new public symbols through
+  `src/ramtable/__init__.py` and `__all__`;
+- avoid adding runtime dependencies unless they are discussed and approved in
+  an Issue;
+- keep changes focused on the problem described in the Issue or pull request.
+
+When behavior changes, update the relevant documentation in `docs/`:
+
+- `docs/guide.md` for user-facing workflows;
+- `docs/api.md` for signatures, arguments, returns, and exceptions;
+- `docs/types-and-validation.md` for validation rules.
+
+The repository history uses Conventional Commits-style messages, such as
+`fix: ...`, `docs: ...`, and `feat: ...`. Following that style is appreciated,
+but clear and descriptive commit messages matter most.
+
+## Changelog and versioning
+
+`CHANGELOG.md` records notable changes under version headings, with sections
+such as `Added`, `Changed`, and `Fixed`. User-visible changes should be
+reflected there when appropriate. Internal refactorings and trivial changes do
+not need an entry. If you are unsure, mention the change in your pull request
+and ask.
+
+Do not modify `project.version` in `pyproject.toml`, create release headings,
+or hardcode the current version in the README or documentation.
+`pyproject.toml` is the single source of truth for the version, and version
+bumps are part of the maintainer's release process.
+
+## Pull request guidelines
+
+Pull requests should:
+
+- have a clear, descriptive title;
+- explain what changed and why;
+- reference the related Issue when one exists;
+- include tests for relevant changes, following the guidance above;
+- update documentation when behavior or the public API changes;
+- avoid unrelated changes;
+- stay focused and reasonably small whenever possible.
+
+For a new feature, link the Issue where the feature was approved. Pull
+requests without that approval may be closed.
+
+Opening a pull request does not guarantee acceptance or an immediate review.
+The maintainer may request changes, ask for the branch to be updated, or
+decide that a contribution does not fit the project's direction.
+
+Before opening a pull request:
+
+```bash
+git fetch upstream
+git switch dev
+git pull upstream dev
+git switch your-branch-name
+git rebase upstream/dev
+```
+
+Then run the checks described above and make sure the diff contains only the
+intended changes.
+
+## Reporting bugs
+
+When reporting a bug, include:
+
+- the RAMTable version:
+
+  ```bash
+  python -c "import ramtable; print(ramtable.__version__)"
+  ```
+
+- your Python version and operating system;
+- a minimal, reproducible example;
+- the expected result and the actual result;
+- the complete traceback, if one was raised.
+
+Search existing Issues first to avoid duplicates.
+
+## License
+
+RAMTable is released under the MIT License. See [LICENSE](LICENSE) for the
+full text. By contributing, you agree that your contributions may be
+distributed under the same license.

{ramtable-0.3.1 → ramtable-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ramtable
-Version: 0.3.1
+Version: 0.3.3
 Summary: A lightweight in-memory table library for Python.
 Author: Thiago Valentín Stilo Limarino
 License-Expression: MIT
@@ -10,19 +10,20 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 
 # RAMTable
 
-![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![Python](https://img.shields.io/badge/python-3.11%2B-blue)
 ![License](https://img.shields.io/badge/license-MIT-green)
-[![PyPI](https://img.shields.io/badge/PyPI-ramtable-blue)](https://pypi.org/project/ramtable/)
-[![TestPyPI](https://img.shields.io/badge/TestPyPI-ramtable-orange)](https://test.pypi.org/project/ramtable/)
+[![PyPI](https://img.shields.io/pypi/v/ramtable)](https://pypi.org/project/ramtable/)
+[![TestPyPI](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Ftest.pypi.org%2Fpypi%2Framtable%2Fjson&label=TestPyPI&query=%24.info.version&color=blue)](https://test.pypi.org/project/ramtable/)
 
 RAMTable provides typed in-memory tables for data that only needs to live
 while a program is running. It gives records an explicit schema and common
@@ -62,7 +63,7 @@ temporary storage, not analytics.
 
 ## Installation
 
-RAMTable requires Python 3.10 or later.
+RAMTable requires Python 3.11 or later.
 
 Install the latest stable release from PyPI:
 
@@ -218,10 +219,12 @@ writes to disk: records disappear when the process ends.
 
 ## Project status
 
-The current development version is **0.3.1rc0**. RAMTable is published as
-`ramtable` on both [PyPI](https://pypi.org/project/ramtable/) and
+RAMTable is published as `ramtable` on
+[PyPI](https://pypi.org/project/ramtable/) and
 [TestPyPI](https://test.pypi.org/project/ramtable/). Use PyPI for stable
-releases and TestPyPI to try release candidates and other pre-releases.
+releases and TestPyPI to try release candidates and other pre-releases. The
+PyPI badge above shows the latest published version; the
+[CHANGELOG](CHANGELOG.md) records the full release history.
 
 The project is at an early stage and will continue to evolve. See the
 [CHANGELOG](CHANGELOG.md) for release history.

{ramtable-0.3.1 → ramtable-0.3.3}/README.md

@@ -1,9 +1,9 @@
 # RAMTable
 
-![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![Python](https://img.shields.io/badge/python-3.11%2B-blue)
 ![License](https://img.shields.io/badge/license-MIT-green)
-[![PyPI](https://img.shields.io/badge/PyPI-ramtable-blue)](https://pypi.org/project/ramtable/)
-[![TestPyPI](https://img.shields.io/badge/TestPyPI-ramtable-orange)](https://test.pypi.org/project/ramtable/)
+[![PyPI](https://img.shields.io/pypi/v/ramtable)](https://pypi.org/project/ramtable/)
+[![TestPyPI](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Ftest.pypi.org%2Fpypi%2Framtable%2Fjson&label=TestPyPI&query=%24.info.version&color=blue)](https://test.pypi.org/project/ramtable/)
 
 RAMTable provides typed in-memory tables for data that only needs to live
 while a program is running. It gives records an explicit schema and common
@@ -43,7 +43,7 @@ temporary storage, not analytics.
 
 ## Installation
 
-RAMTable requires Python 3.10 or later.
+RAMTable requires Python 3.11 or later.
 
 Install the latest stable release from PyPI:
 
@@ -199,10 +199,12 @@ writes to disk: records disappear when the process ends.
 
 ## Project status
 
-The current development version is **0.3.1rc0**. RAMTable is published as
-`ramtable` on both [PyPI](https://pypi.org/project/ramtable/) and
+RAMTable is published as `ramtable` on
+[PyPI](https://pypi.org/project/ramtable/) and
 [TestPyPI](https://test.pypi.org/project/ramtable/). Use PyPI for stable
-releases and TestPyPI to try release candidates and other pre-releases.
+releases and TestPyPI to try release candidates and other pre-releases. The
+PyPI badge above shows the latest published version; the
+[CHANGELOG](CHANGELOG.md) records the full release history.
 
 The project is at an early stage and will continue to evolve. See the
 [CHANGELOG](CHANGELOG.md) for release history.

{ramtable-0.3.1 → ramtable-0.3.3}/docs/api.md

@@ -1,11 +1,12 @@
 # API reference
 
 This reference covers every public symbol RAMTable exposes: the `Table`,
-`Columns`, and `Rows` classes, and the optional `TypeValidator`. For an
-example-driven introduction, read the [user guide](guide.md) first.
+`Columns`, and `Rows` classes, the optional `TypeValidator`, and the package
+version. For an example-driven introduction, read the
+[user guide](guide.md) first.
 
 ```python
-from ramtable import Columns, Rows, Table
+from ramtable import Columns, Rows, Table, __version__
 from ramtable.types import TypeValidator
 ```
 
@@ -18,9 +19,21 @@ In normal use you only create a `Table`; it constructs the coordinated
 - [`Columns`](#columns)
 - [`Rows`](#rows)
 - [`TypeValidator`](#typevalidator)
+- [Package version](#package-version)
 - [Internal helpers](#internal-helpers)
 - [Copying behavior](#copying-behavior)
 
+## Package version
+
+```python
+from ramtable import __version__
+```
+
+`__version__` is the version of the installed distribution, read from its
+package metadata. It matches `project.version` in `pyproject.toml` and the
+artifact built from it. In a source checkout that has not been installed,
+it is `"0+unknown"`.
+
 ## `Table`
 
 ```python

{ramtable-0.3.1 → ramtable-0.3.3}/docs/development.md

@@ -47,7 +47,7 @@ how to prepare a release. It does not change or extend the RAMTable API.
 
 ## Set up a local environment
 
-Python 3.10 or later is required. Install the project in editable mode:
+Python 3.11 or later is required. Install the project in editable mode:
 
 ```bash
 python -m pip install --editable .
@@ -91,7 +91,7 @@ the branch:
 
 | Branch | Version form | Example | Published to |
 |---|---|---|---|
-| `dev` | `X.Y.Z.devN` | `0.3.1.dev1` | nothing |
+| `dev` | `X.Y.Z.devN` | `0.3.2.dev0` | nothing |
 | `test_pypi` | `X.Y.ZrcN` or `X.Y.Z` | `0.3.1rc0`, `0.3.1` | TestPyPI |
 | `main` | `X.Y.Z` | `0.3.1` | PyPI |
 
@@ -101,15 +101,24 @@ the branch:
 - `MINOR` for compatible functionality;
 - `MAJOR` for breaking API or behavior changes.
 
+`pyproject.toml` is the single source of truth for the current version. The
+build backend reads it, the GitHub Actions workflows read it, and the
+installed package exposes it as `ramtable.__version__` through its
+distribution metadata. The README uses a dynamic PyPI badge instead of a
+hardcoded number. `CHANGELOG.md` is the only other file with version
+numbers, because it is a historical record of releases.
+
 Development versions are never published. TestPyPI accepts release
 candidates and stable versions, so the final stable release can be tested
 there before it reaches PyPI. PyPI accepts stable versions only.
 
 ## Preparing a release
 
-1. On `dev`, update `project.version` in `pyproject.toml` and add the
-   corresponding section to `CHANGELOG.md`.
-2. Check that the README and documentation describe current behavior.
+1. On `dev`, update `project.version` in `pyproject.toml`. This is the only
+   place where the current version is defined. Add the corresponding
+   section to `CHANGELOG.md`.
+2. Check that the README and documentation describe current behavior. The
+   README must not contain a hardcoded version.
 3. Run the example and all available build/test checks.
 4. Build and inspect the wheel and source distribution.
 5. Open a pull request from `dev` to `test_pypi`. The pull request validates

{ramtable-0.3.1 → ramtable-0.3.3}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ramtable"
-version = "0.3.1"
+version = "0.3.3"
 description = "A lightweight in-memory table library for Python."
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "MIT"
 authors = [
     { name = "Thiago Valentín Stilo Limarino" }
@@ -22,10 +22,11 @@ classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "License :: OSI Approved :: MIT License",
 ]
 

ramtable-0.3.3/src/ramtable/__init__.py

@@ -0,0 +1,24 @@
+"""Public RAMTable API.
+
+Expose :class:`Columns`, :class:`Rows`, and :class:`Table` from the
+``ramtable`` package as a concise, stable import path, along with the
+installed package version.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .columns import Columns
+from .rows import Rows
+from .table import Table
+
+try:
+    __version__ = version("ramtable")
+except PackageNotFoundError:  # pragma: no cover - source checkout without install
+    __version__ = "0+unknown"
+
+__all__ = [
+    "__version__",
+    "Columns",
+    "Rows",
+    "Table",
+]

{ramtable-0.3.1 → ramtable-0.3.3}/src/ramtable/rows.py

@@ -286,7 +286,7 @@ class Rows:
         """Remove all rows without changing the schema."""
         self._storage.clear()
 
-    def get(self, *indices: int) -> list[dict[str, Any]]:
+    def get(self, *indexes: int) -> list[dict[str, Any]]:
         """Return all rows or copies of the requested positions.
 
         With no arguments, return all rows. Indexes support negative values as
@@ -298,14 +298,14 @@ class Rows:
             IndexError: If an index is out of range.
         """
 
-        if not indices:
+        if not indexes:
             return self.get_all()
 
         selected = []
 
-        for index in indices:
+        for index in indexes:
             if isinstance(index, bool) or not isinstance(index, int):
-                raise TypeError("Row indices must be integers.")
+                raise TypeError("Row indexes must be integers.")
 
             try:
                 selected.append(self._storage[index].copy())

ramtable-0.3.1/src/ramtable/__init__.py

@@ -1,15 +0,0 @@
-"""Public RAMTable API.
-
-Expose :class:`Columns`, :class:`Rows`, and :class:`Table` from the
-``ramtable`` package as a concise, stable import path.
-"""
-
-from .columns import Columns
-from .rows import Rows
-from .table import Table
-
-__all__ = [
-    "Columns",
-    "Rows",
-    "Table",
-]