py-maybetype 0.5.0__tar.gz

py_maybetype-0.5.0/.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,75 @@
+name: Publish Python distribution to PyPI and TestPyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v6
+      with:
+        persist-credentials: false
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: "3.x"
+    - name: Install pypa/build
+      run: >-
+        python3 -m 
+        pip install
+        build
+        --user
+    - name: Build binary wheel and source tarball
+      run: python3 -m build
+    - name: Store distributions
+      uses: actions/upload-artifact@v5
+      with:
+        name: python-package-distributions
+        path: dist/
+
+  publish-to-pypi:
+    name: >-
+      Publish Python distribution to PyPI
+    if: startswith(github.ref, 'refs/tags/')
+    needs:
+    - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/maybetype
+    permissions:
+      id-token: write
+    steps:
+    - name: Download all the dists
+      uses: actions/downlad-artifact@v6
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+
+  publish-to-testpypi:
+    name: Publish Python distribution to TestPyPI
+    needs:
+    - build
+    runs-on: ubuntu-latest
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/maybetype
+    permissions:
+      id-token: write
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v6
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution to TestPyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        verbose: true
+        repository-url: https://test.pypi.org/legacy/

py_maybetype-0.5.0/.github/workflows/python-lint-test.yml

@@ -0,0 +1,33 @@
+name: Build project, lint, test
+
+on:
+  push:
+    branches: [ "**" ]
+  pull_request:
+    branches: [ "**" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Lint and test
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.12
+      uses: actions/setup-python@v3
+      with:
+        python-version: "3.12"
+    - name: Install project + dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install .[dev]
+    - name: Lint with ruff
+      run: |
+        ruff check .
+    - name: Test
+      run: |
+        python -m doctest maybetype/*.py
+        pytest -v

py_maybetype-0.5.0/.gitignore

@@ -0,0 +1,16 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Sphinx-generated files
+_build/
+
+# Other
+_*/

py_maybetype-0.5.0/.markdownlint.json

@@ -0,0 +1,6 @@
+{
+    "MD024": false,
+    "line-length": {
+        "line_length": 100
+    }
+}

py_maybetype-0.5.0/.python-version

@@ -0,0 +1 @@
+3.12

py_maybetype-0.5.0/.readthedocs.yaml

@@ -0,0 +1,24 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.12"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: docs/conf.py
+
+python:
+  install:
+    - requirements: docs/requirements.txt
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs

py_maybetype-0.5.0/CHANGELOG.md

@@ -0,0 +1,77 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.5.0] - 2026-01-18
+
+### Added
+
+- Added `__match_args__` attribute to `Maybe` to allow using its value in `match`/`case` pattern matching
+- Added method `Maybe.unwrap_or()`
+- Added classes `Some` and `_Nothing`
+  - `_Nothing` is intended to be used through the `Nothing` singleton instance, rather than
+    constructing new instances of it, since effectively all `_Nothing` instances should behave the
+    same
+  - Instances of `Some` are **always truthy**, and `Nothing` is **always falsy**
+- Added function `maybe()`
+  - Returns either a `Some` instance or the `Nothing` singleton depending on the given value and
+    predicate, similar to the previous functionality of `Maybe.__init__()`
+  - Usage should now replace direct instancing of `Maybe`
+
+### Changed
+
+- `Maybe.__init__()` body moved to `maybe()` function, now simply assigns the passed `val` to its
+  `val` attribute
+  - A warning is now issued if `Maybe`'s constructor is called directly
+- Replaced uses of `NoReturn` with `Never`
+- `Maybe.get()` now directly checks for the `__getitem__` method on the wrapped value instead of
+  checking `Sequence | Mapping`
+- Anywhere `Maybe(None)` would have been returned now returns the `Nothing` singleton
+
+### Fixed
+
+- `Maybe.attr_or()` no longer has a default argument of `None` for its `default` parameter, as the
+  docstring describes
+
+## [0.4.0] - 2026-01-02
+
+### Added
+
+- Added module `const`
+
+### Changed
+
+- Updated all docstrings to use reStructuredText markup for Sphinx docs generation
+
+### Fixed
+
+- Fixed the example in `Maybe.cat`'s docstring incorrectly attempting to use `.cat()` on the list
+  of `Maybe` objects, now correctly shows usage of `Maybe.cat(vals)`
+
+## [0.3.1] - 2025-12-31
+
+### Fixed
+
+- Corrected the docstring of `Maybe.__init__()`'s description of the `just_condition` parameter,
+  which incorrectly stated `just_condition` must return `True` for the constructor to return
+  `Maybe(None)`—the opposite is true, `Maybe(None)` is returned if `just_condition` returns `False`
+
+## [0.3.0] - 2025-12-27
+
+### Added
+
+- Added the `just_condition` argument to `Maybe`'s constructor, a function that takes the
+  to-be-wrapped value as an argument, which allows defining a custom condition in which
+  `Maybe(None)` will be returned if the function returns `False`
+  - e.g. `Maybe(0) == Maybe(0)`, however `Maybe(0, lambda x: x > 0) == Maybe(None)`
+
+## [0.2.0] - 2025-12-08
+
+### Added
+
+- Added test module `tests/test_maybe.py`
+
+## [0.1.0] - 2025-12-07

py_maybetype-0.5.0/LICENSE

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

py_maybetype-0.5.0/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: py-maybetype
+Version: 0.5.0
+Summary: A basic implementation of a maybe/option type in Python, largely inspired by Rust's Option.
+Project-URL: Homepage, https://github.com/svioletg/py-maybetype
+Project-URL: Repository, https://github.com/svioletg/py-maybetype
+Project-URL: Documentation, https://py-maybetype.readthedocs.io/en/latest/
+Project-URL: Changelog, https://github.com/svioletg/py-maybetype/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/svioletg/py-maybetype/issues
+Author: Seth 'Violet' Gibbs
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.12
+Provides-Extra: dev
+Requires-Dist: pytest>=9.0.2; extra == 'dev'
+Requires-Dist: ruff>=0.14.8; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: furo>=2025.12.19; extra == 'docs'
+Requires-Dist: myst-parser>=4.0.1; extra == 'docs'
+Requires-Dist: sphinx-autobuild>=2025.8.25; extra == 'docs'
+Requires-Dist: sphinx<9.0,>=6.0; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# py-maybetype
+
+Documentation: <https://py-maybetype.readthedocs.io/en/latest/>
+
+A basic implementation of a maybe/option type in Python, largely inspired by Rust's `Option`.
+This was created as part of a separate project I had been working on, but I decided to make it into
+its own package as I wanted to use it elsewhere and its scope grew. This is not meant to be a 1:1
+replication or replacement for Rust's `Option` or Haskell's `Maybe`, but rather just an
+interperetation of the idea that I feel works for Python.
+
+## Usage
+
+Install the package with `pip` using the repository link:
+
+```bash
+pip install git+https://github.com/svioletg/py-maybetype
+```
+
+Call the `maybe()` function with a `T | None` value to return a `Maybe[T]`—either a `Some` instance
+containing the wrapped value, or the `Nothing` singleton.
+
+```python
+from maybetype import Maybe, maybe
+
+# Only the maybe() function should be used,
+# the Maybe class is only imported here for type annotations
+
+def try_int(x: str) -> int | None:
+    """Attempts to convert a string of digits into an `int`, returning `None` if not possible."""
+    try:
+        return int(x)
+    except ValueError:
+        return None
+
+num1: Maybe[int] = maybe(try_int('5'))
+num2: Maybe[int] = maybe(try_int('five'))
+
+print(num1.unwrap()) # 5
+print(num2.unwrap()) # (raises ValueError)
+
+# Some() instances are always truthy, Nothing is falsy
+
+assert bool(num1) is True
+assert bool(num2) is False
+```
+
+This example in particular can also be done with `Maybe`'s built-in `int()` class method:
+
+```python
+num1: Maybe[int] = Maybe.int('5')
+num2: Maybe[int] = Maybe.int('five')
+```
+
+The `maybe` constructor can be given an optional predicate argument to specify a custom condition
+for which `Some(value)` is returned. This argument must be a `Callable` that returns `bool`,
+where returning `False` causes the constructor to return `Nothing`.
+
+```python
+import re
+import uuid
+
+from maybetype import maybe
+
+def is_valid_uuid(s: str) -> bool:
+    return re.match(r"[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}|[0-9a-f]{32}", s) is not None
+
+assert maybe('3b1bcc3a-41d5-49a5-8273-10cc605e31f9', is_valid_uuid)
+assert maybe('3b1bcc3a41d549a5827310cc605e31f9', is_valid_uuid)
+assert not maybe('qwertyuiopasdfghjklzxcvbnm', is_valid_uuid)
+assert not maybe('nf0cmmdq-l0gt-rq5a-upry-706trht3ocv9', is_valid_uuid)
+```
+
+`Maybe` instances can also be used in `match`/`case` pattern matching to access the wrapped value,
+like so:
+
+```python
+from maybetype import maybe, Some
+
+match maybe(1):
+    case Some(val):
+        print('Value: ', val)
+    case _:
+        print('No value')
+```
+
+## Other examples
+
+Converting a `str | None` timestamp into a `datetime` object if not `None`, otherwise returning `None`:
+
+```python
+from datetime import datetime
+from maybetype import maybe
+
+date_str = '2025-09-06T030000'
+date = maybe('2025-09-06T030000').then(datetime.fromisoformat)
+# date == datetime.datetime(2025, 9, 6, 3, 0)
+
+date_str = None
+date = maybe(date_str).then(datetime.fromisoformat)
+# date == None
+
+date_str = ''
+date = maybe(date_str or None).then(datetime.fromisoformat)
+# date == None
+# Maybe does not treat falsy values as None, only strictly x-is-None values
+# Without `or None` here, datetime.fromisoformat would have raised a ValueError
+```

py_maybetype-0.5.0/README.md

@@ -0,0 +1,107 @@
+# py-maybetype
+
+Documentation: <https://py-maybetype.readthedocs.io/en/latest/>
+
+A basic implementation of a maybe/option type in Python, largely inspired by Rust's `Option`.
+This was created as part of a separate project I had been working on, but I decided to make it into
+its own package as I wanted to use it elsewhere and its scope grew. This is not meant to be a 1:1
+replication or replacement for Rust's `Option` or Haskell's `Maybe`, but rather just an
+interperetation of the idea that I feel works for Python.
+
+## Usage
+
+Install the package with `pip` using the repository link:
+
+```bash
+pip install git+https://github.com/svioletg/py-maybetype
+```
+
+Call the `maybe()` function with a `T | None` value to return a `Maybe[T]`—either a `Some` instance
+containing the wrapped value, or the `Nothing` singleton.
+
+```python
+from maybetype import Maybe, maybe
+
+# Only the maybe() function should be used,
+# the Maybe class is only imported here for type annotations
+
+def try_int(x: str) -> int | None:
+    """Attempts to convert a string of digits into an `int`, returning `None` if not possible."""
+    try:
+        return int(x)
+    except ValueError:
+        return None
+
+num1: Maybe[int] = maybe(try_int('5'))
+num2: Maybe[int] = maybe(try_int('five'))
+
+print(num1.unwrap()) # 5
+print(num2.unwrap()) # (raises ValueError)
+
+# Some() instances are always truthy, Nothing is falsy
+
+assert bool(num1) is True
+assert bool(num2) is False
+```
+
+This example in particular can also be done with `Maybe`'s built-in `int()` class method:
+
+```python
+num1: Maybe[int] = Maybe.int('5')
+num2: Maybe[int] = Maybe.int('five')
+```
+
+The `maybe` constructor can be given an optional predicate argument to specify a custom condition
+for which `Some(value)` is returned. This argument must be a `Callable` that returns `bool`,
+where returning `False` causes the constructor to return `Nothing`.
+
+```python
+import re
+import uuid
+
+from maybetype import maybe
+
+def is_valid_uuid(s: str) -> bool:
+    return re.match(r"[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}|[0-9a-f]{32}", s) is not None
+
+assert maybe('3b1bcc3a-41d5-49a5-8273-10cc605e31f9', is_valid_uuid)
+assert maybe('3b1bcc3a41d549a5827310cc605e31f9', is_valid_uuid)
+assert not maybe('qwertyuiopasdfghjklzxcvbnm', is_valid_uuid)
+assert not maybe('nf0cmmdq-l0gt-rq5a-upry-706trht3ocv9', is_valid_uuid)
+```
+
+`Maybe` instances can also be used in `match`/`case` pattern matching to access the wrapped value,
+like so:
+
+```python
+from maybetype import maybe, Some
+
+match maybe(1):
+    case Some(val):
+        print('Value: ', val)
+    case _:
+        print('No value')
+```
+
+## Other examples
+
+Converting a `str | None` timestamp into a `datetime` object if not `None`, otherwise returning `None`:
+
+```python
+from datetime import datetime
+from maybetype import maybe
+
+date_str = '2025-09-06T030000'
+date = maybe('2025-09-06T030000').then(datetime.fromisoformat)
+# date == datetime.datetime(2025, 9, 6, 3, 0)
+
+date_str = None
+date = maybe(date_str).then(datetime.fromisoformat)
+# date == None
+
+date_str = ''
+date = maybe(date_str or None).then(datetime.fromisoformat)
+# date == None
+# Maybe does not treat falsy values as None, only strictly x-is-None values
+# Without `or None` here, datetime.fromisoformat would have raised a ValueError
+```

py_maybetype-0.5.0/docs/changelog.rst

@@ -0,0 +1,5 @@
+Changelog
+===========
+
+.. include:: ../CHANGELOG.md
+    :parser: myst_parser.sphinx_

py_maybetype-0.5.0/docs/conf.py

@@ -0,0 +1,30 @@
+from maybetype.const import PROJECT_VERSION
+
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = 'py-maybetype'
+author = 'Seth "Violet" Gibbs'
+release = PROJECT_VERSION
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    'sphinx.ext.autodoc',
+    'myst_parser',
+]
+
+templates_path = ['_templates']
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = 'furo'
+html_static_path = ['_static']

py_maybetype-0.5.0/docs/index.rst

@@ -0,0 +1,16 @@
+py-maybetype documentation
+===============================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   readme.rst
+   changelog.rst
+   reference/index.rst
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`

py_maybetype-0.5.0/docs/readme.rst

@@ -0,0 +1,5 @@
+README
+===========
+
+.. include:: ../README.md
+    :parser: myst_parser.sphinx_

py_maybetype-0.5.0/docs/reference/index.rst

@@ -0,0 +1,9 @@
+.. py:module:: maybetype
+.. py:currentmodule:: maybetype
+
+:py:mod:`~maybetype` module
+========================================
+
+.. automodule:: maybetype
+   :members:
+   :special-members: __init__

py_maybetype-0.5.0/docs/requirements.txt

@@ -0,0 +1,4 @@
+furo>=2025.9.12.19
+myst-parser>=4.0.1
+sphinx>=6.0,<9.0
+sphinx-autobuild>=2025.8.25

py_maybetype-0.5.0/maybetype/__init__.py

@@ -0,0 +1,185 @@
+import warnings
+from collections.abc import Callable, Iterable
+from typing import Any, Never
+
+
+class Maybe[T]:
+    """
+    Wraps a value that may be ``T`` or ``None``, providing methods for conditionally using that value or
+    short-circuiting to ``None`` without longer checks.
+    """
+    __match_args__ = ('val',)
+
+    def __init__(self, val: T | None) -> None:
+        warnings.warn(
+            'Direct instancing of Maybe() is not recommended as of v0.5.0, use the maybe() function instead',
+            stacklevel=2,
+        )
+        self.val = val
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.val!r})'
+
+    def __bool__(self) -> bool:
+        return self.val is not None
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Returns ``False`` if the compared object is not a ``Maybe`` instance, otherwise compares their wrapped values.
+        """
+        if not isinstance(other, Maybe):
+            return False
+        return self.val == other.val
+
+    def __hash__(self) -> int:
+        return self.val.__hash__()
+
+    @staticmethod
+    def cat(vals: 'Iterable[Maybe[T]]') -> list[T]:
+        """
+        Takes an iterable of ``Maybe`` and returns a list of the unwrapped values of all ``Some`` objects.
+
+        >>> vals = [maybe(5), maybe(None), maybe(10), maybe(None)]
+        >>> assert vals == [Some(5), Nothing, Some(10), Nothing]
+        >>> assert Maybe.cat(vals) == [5, 10]
+        """
+        return [i.unwrap() for i in vals if i]
+
+    @staticmethod
+    def int(val: Any) -> 'Maybe[int]':  # noqa: ANN401
+        """
+        Attempts to convert ``val`` to an ``int``, returning a ``Some``-wrapped ``int`` if successful, or
+        ``Nothing`` on failure.
+        """
+        try:
+            i: int = int(val)
+            return Some(i)
+        except ValueError:
+            return Nothing
+
+    @staticmethod
+    def map[A, B](fn: 'Callable[[A], Maybe[B]]', vals: Iterable[A]) -> list[B]:
+        """Maps ``fn`` onto ``vals``, taking the unwrapped values of ``Some``s and discarding ``Nothing``s."""
+        return [i.unwrap() for i in map(fn, vals) if i]
+
+    def attr[V](self, name: str, typ: type[V] | None = None, *, err: bool = False) -> 'Maybe[V]':
+        """
+        Attempts to access an attribute ``name`` on the wrapped object, returning a ``Some`` instance wrapping the
+        the value if it exists, or ``Nothing`` otherwise.
+
+        :param typ: Specifies the generic type of the resulting ``Maybe``. Note that the potential value returned by
+            this method will not be coerced to the given type at runtime; this argument is only for typing purposes.
+        :param err: If ``True``, ``AttributeError`` is raised instead of returning ``Nothing`` if ``name`` does not
+            exist.
+        """
+        return Some(getattr(self.val, name)) if err else maybe(getattr(self.val, name, None))
+
+    def attr_or[V](self, name: str, default: V) -> V:
+        """
+        Similar to the ``attr`` method, but unwraps the result if the attribute exists or returns the required default
+        value otherwise.
+        """
+        try:
+            return self.attr(name, err=True).unwrap()
+        except AttributeError:
+            return default
+
+    def get[V](self,
+            accessor: Any,  # noqa: ANN401
+            _typ: type[V] | None = None,
+            *,
+            err: bool = False,
+            default: V | None = None,
+        ) -> 'Maybe[V]':
+        """
+        Attempts to access an item by ``accessor`` on the wrapped object, assuming the wrapped value implements
+        ``__getitem__``. If it does not, or if the value does not exist (list index out of range, key does not exist on
+        a dictionary, etc.), ``Nothing`` is returned.
+
+        :param typ: Specifies the generic type of the resulting ``Maybe``. Note that the potential value returned by
+            this method will not be coerced to the given type at runtime; this argument is only for typing purposes.
+        :param err: By default, ``IndexError`` and ``KeyError`` are not raised when ``__getitem__`` is called on the
+            wrapped value, and ``Nothing`` is returned instead. Setting ``err`` to ``True`` allows these errors to
+            be raised as they normally would. Note that if ``__getitem__`` did not exist on the wrapped value in the
+            first placed (such as with ``Nothing``), no error is raised, and ``Nothing`` is returned regardless.
+        :param default: Specifies an alternate value to return a ``Some`` of instead of returning ``Nothing``.
+        """
+        if hasattr(self.val, '__getitem__'):
+            try:
+                return Some(self.val.__getitem__(accessor)) # type: ignore
+            except (IndexError, KeyError):
+                if err:
+                    raise
+        return maybe(default)
+
+    def then[R](self, func: Callable[[T], R]) -> R | None:
+        """
+        Calls ``func`` with the wrapped value as the argument and returns its value, or returns ``None`` if the wrapped
+        value is ``None``.
+
+        :param func: A ``Callable`` which takes a type of the possible wrapped value (``T``) and can return any type
+            (``R``).
+        """
+        return func(self.val) if self.val is not None else None
+
+    def this_or(self, other: T) -> 'Maybe[T]':
+        """Returns the original wrapped value if not ``None``, otherwise returns a ``Some``-wrapped ``other``."""
+        return self if self else Some(other)
+
+    def unwrap(self,
+            exc: Exception | Callable[..., Never] | None = None,
+            *exc_args: object,
+        ) -> T:
+        """
+        Returns the wrapped value if it is not ``None``, otherwise raises ``ValueError`` by default.
+
+        :param exc: The exception to raise if the wrapped value is ``None``. Can be either an ``Exception`` object, or a
+            ``Callable`` which takes any arguments and does not return. If given ``None``, the default behavior is to
+            raise a ``ValueError`` with the message ``Maybe[<type>] unwrapped into None``.
+        :param exc_args: Arguments to call ``exc`` with, if ``exc`` is a ``Callable``. Otherwise, this argument is not
+            used.
+        """
+        if self.val is None:
+            if isinstance(exc, Exception):
+                raise exc
+            if isinstance(exc, Callable):
+                exc(*exc_args)
+            raise ValueError(f'Maybe[{T.__name__}] unwrapped into None')
+        return self.val
+
+    def unwrap_or(self, other: T) -> T:
+        """Returns the wrapped value if it is not ``None``, otherwise returns ``other``."""
+        return self.val if self.val is not None else other
+
+class Some[T](Maybe[T]):
+    def __init__(self, val: T) -> None:
+        self.val = val
+
+    def __bool__(self) -> bool:
+        return True
+
+class _Nothing[T](Maybe[T]):
+    __match_args__ = ()
+
+    def __init__(self, _: None = None) -> None:
+        self.val = None
+
+    def __repr__(self) -> str:
+        return 'Nothing'
+
+    def __bool__(self) -> bool:
+        return False
+
+Nothing = _Nothing()
+
+def maybe[T](val: T | None, predicate: Callable[[T], bool] = lambda v: v is not None) -> Maybe[T]:
+    """
+    Returns a ``Some`` instance wrapping ``val`` if either ``val`` is not ``None`` or ``predicate(val)`` is ``True``,
+    otherwise returns the ``Nothing`` singleton.
+
+    :param val: A value to wrap.
+    :param predicate: An optional function that takes ``val`` and, if it returns ``False``, discards ``val``
+        and returns a ``Nothing`` instance. Regardless of the predicate, ``Nothing`` is always returned if
+        ``val`` is ``None``.
+    """
+    return Nothing if (val is None) or not predicate(val) else Some(val)

py_maybetype-0.5.0/maybetype/const.py

@@ -0,0 +1,3 @@
+import importlib.metadata
+
+PROJECT_VERSION: str = importlib.metadata.version('maybetype')

py_maybetype-0.5.0/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "py-maybetype"
+version = "0.5.0"
+description = "A basic implementation of a maybe/option type in Python, largely inspired by Rust's Option."
+authors = [
+    { name = "Seth 'Violet' Gibbs" }
+]
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+[project.urls]
+Homepage = "https://github.com/svioletg/py-maybetype"
+Repository = "https://github.com/svioletg/py-maybetype"
+Documentation = "https://py-maybetype.readthedocs.io/en/latest/"
+Changelog = "https://github.com/svioletg/py-maybetype/blob/main/CHANGELOG.md"
+Issues = "https://github.com/svioletg/py-maybetype/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=9.0.2",
+    "ruff>=0.14.8",
+]
+docs = [
+    "furo>=2025.12.19",
+    "myst-parser>=4.0.1",
+    "sphinx>=6.0,<9.0",
+    "sphinx-autobuild>=2025.8.25",
+]
+
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["maybetype"]

py_maybetype-0.5.0/ruff.toml

@@ -0,0 +1,31 @@
+target-version = "py312"
+output-format = "concise"
+
+line-length = 120
+
+[lint]
+select = [
+    "A", "ANN",
+    "B",
+    "C4", "COM",
+    "DTZ",
+    "E", "ERA",
+    "F", "FBT", "FURB",
+    "I", "ISC",
+    "LOG",
+    "N",
+    "PT", "PIE", "PLC", "PLE", "PLR", "PLW",
+    "RET", "RSE", "RUF",
+    "S", "SIM", "SLF",
+    "T20", "TID", "TRY",
+    "UP",
+    "W",
+]
+fixable = ["COM812", "F401", "I", "UP045", "W292", "W293"]
+ignore = ["ANN003", "PLR0912", "PLR0913", "RET505", "S311", "TRY003", "UP015"]
+
+[lint.flake8-implicit-str-concat]
+allow-multiline = false
+
+[lint.per-file-ignores]
+"tests/*" = ["FBT001", "S101"]

py_maybetype-0.5.0/tests/test_maybe.py

@@ -0,0 +1,178 @@
+import re
+from collections.abc import Callable
+from copy import deepcopy
+from dataclasses import dataclass
+from string import ascii_lowercase
+from types import EllipsisType
+from typing import Any
+
+import pytest
+
+from maybetype import Maybe, Nothing, Some, maybe
+
+ALPHANUMERIC: str = ascii_lowercase + '0123456789'
+MAYBE_UNWRAP_NONE_REGEX: re.Pattern[str] = re.compile(r"Maybe\[.*\] unwrapped into None")
+
+def test_maybe_none_unwrap_error() -> None:
+    m_none: Maybe[Any] = Nothing
+    assert bool(m_none) is False
+    with pytest.raises(ValueError, match=MAYBE_UNWRAP_NONE_REGEX):
+        m_none.unwrap()
+    with pytest.raises(TypeError, match='Custom error message'):
+        m_none.unwrap(exc=TypeError('Custom error message'))
+
+def test_maybe_none_is_nothing() -> None:
+    assert maybe(None) is Nothing
+
+def test_maybe_this_or() -> None:
+    assert Maybe.int('10').this_or(0).unwrap() == 10  # noqa: PLR2004
+    assert Maybe.int('ten').this_or(0).unwrap() == 0
+    with pytest.raises(ValueError, match=MAYBE_UNWRAP_NONE_REGEX):
+        Maybe.int('ten').unwrap()
+
+@pytest.mark.parametrize(('val', 'default'),
+    [
+        (5, 10),
+        (5, None),
+        ('string', 'fallback'),
+        ('string', None),
+    ],
+)
+def test_maybe_unwrap_or(val: object, default: object) -> None:
+    assert maybe(val).unwrap_or(default) == val
+    assert maybe(None).unwrap_or(default) == default
+
+@pytest.mark.parametrize(('val', 'then_fn'),
+    [
+      # (wrapped value, (.then() function, expected return val), expected wrapped value after function)
+        (0,                (lambda i: i * 10, 0, ...)),
+        (1,                (lambda i: i * 10, 10, ...)),
+        ('',               (lambda s: s.upper(), '', ...)),
+        ('string',         (lambda s: s.upper(), 'STRING', ...)),
+        ('a,b,c',          (lambda s: s.split(','), ['a', 'b', 'c'], ...)),
+        ([1, 2, 3],        (lambda l: l.append(4), None, [1, 2, 3, 4])), # noqa: E741
+        ({'a': 1, 'b': 2}, (lambda d: d.get('a'), 1, ...)),
+    ],
+    ids=[
+        'int_zero',
+        'int_one',
+        'str_empty',
+        'str_nonempty',
+        'str_split',
+        'list',
+        'dict',
+    ],
+)
+def test_maybe_then[T, R, A](val: T, then_fn: tuple[Callable[[T], R], R, A | EllipsisType]) -> None:
+    m: Maybe[T] = maybe(val)
+    assert bool(m) is True
+    assert m.unwrap() == val
+    m_before = deepcopy(m.val)
+    assert m.then(then_fn[0]) == then_fn[1]
+    assert m.unwrap() == (then_fn[2] if then_fn[2] is not Ellipsis else m_before)
+    assert maybe(None).then(then_fn[0]) is None
+
+def test_maybe_attr() -> None:
+    @dataclass
+    class A:
+        x: int
+
+    @dataclass
+    class B(A):
+        y: float
+
+    m_none: Maybe[A] = maybe(None)
+    assert m_none.attr('x').val is None
+    assert m_none.attr_or('x', 2) == 2  # noqa: PLR2004
+
+    m_a: Maybe[A] = maybe(A(1))
+    assert m_a.attr('x').unwrap() == 1
+    assert m_a.attr_or('x', 2) == 1
+    assert m_a.attr('y').val is None
+    assert m_a.attr_or('y', 2) == 2  # noqa: PLR2004
+
+    m_b: Maybe[B] = maybe(B(1, 2.0))
+    assert m_b.attr('x').unwrap() == 1
+    assert m_b.attr_or('x', 2) == 1
+    assert m_b.attr('y').unwrap() == 2.0  # noqa: PLR2004
+    assert m_b.attr_or('y', 3) == 2.0  # noqa: PLR2004
+
+@pytest.mark.parametrize(('val', 'accessor', 'result'),
+    [
+        (None,             1,   maybe(None)),
+        ([1, 2, 3],        1,   maybe(2)),
+        ([1, 2, 3],        3,   maybe(None)),
+        ([],               1,   maybe(None)),
+        ({'a': 1, 'b': 2}, 'a', maybe(1)),
+        ({'a': 1, 'b': 2}, 'c', maybe(None)),
+        ({},               'a', maybe(None)),
+    ],
+    ids=[
+        'none',
+        'list_populated',
+        'list_populated_out_of_range',
+        'list_empty',
+        'dict_populated',
+        'dict_populated_no_key',
+        'dict_empty',
+    ],
+)
+def test_maybe_get(val: object, accessor: object, result: object) -> None:
+    m: Maybe = maybe(val)
+    assert m.get(accessor) == result
+
+def test_maybe_cat() -> None:
+    assert Maybe.cat(map(Maybe.int, ALPHANUMERIC)) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+def test_maybe_cat_failure() -> None:
+    with pytest.raises(AttributeError, match='has no attribute \'unwrap\''):
+        Maybe.cat([1, 2, 3]) # type: ignore
+
+def test_maybe_map() -> None:
+    assert Maybe.map(Maybe.int, ALPHANUMERIC) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+def is_valid_uuid(s: str) -> bool:
+    return re.match(r"[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}|[0-9a-f]{32}", s) is not None
+
+@pytest.mark.parametrize(('value', 'predicate', 'expected_bool'),
+    [
+        (0, lambda a: a > 0, False),
+        ([], lambda a: len(a) > 0, False),
+        ([], lambda a: 'x' in a, False),
+        ({}, lambda a: len(a) > 0, False),
+        ({}, lambda a: 'x' in a, False),
+        ('3b1bcc3a-41d5-49a5-8273-10cc605e31f9', is_valid_uuid, True),
+        ('3b1bcc3a41d549a5827310cc605e31f9', is_valid_uuid, True),
+        ('qwertyuiopasdfghjklzxcvbnm', is_valid_uuid, False),
+        ('nf0cmmdq-l0gt-rq5a-upry-706trht3ocv9', is_valid_uuid, False),
+    ],
+)
+def test_maybe_with_predicate[T](value: T, predicate: Callable[[T], bool], expected_bool: bool) -> None:
+    assert bool(maybe(value, predicate)) is expected_bool
+    if expected_bool is False:
+        assert maybe(value, predicate) is Nothing
+
+@pytest.mark.parametrize(('value', 'predicate', 'expected'),
+    [
+        (0, lambda a: a > 0, None),
+        ([], lambda a: len(a) > 0, None),
+        ([], lambda a: 'x' in a, None),
+        ({}, lambda a: len(a) > 0, None),
+        ({}, lambda a: 'x' in a, None),
+        ('3b1bcc3a-41d5-49a5-8273-10cc605e31f9', is_valid_uuid, ...),
+        ('3b1bcc3a41d549a5827310cc605e31f9', is_valid_uuid, ...),
+        ('qwertyuiopasdfghjklzxcvbnm', is_valid_uuid, None),
+        ('nf0cmmdq-l0gt-rq5a-upry-706trht3ocv9', is_valid_uuid, None),
+    ],
+)
+def test_maybe_pattern_matching[T](value: T, predicate: Callable[[T], bool], expected: T | None) -> None:
+    if expected is Ellipsis:
+        expected = value
+
+    match maybe(value, predicate):
+        case Some(value):
+            result = value
+        case _:
+            result = None
+
+    assert result == expected

py_maybetype-0.5.0/uv.lock

@@ -0,0 +1,108 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "maybetype"
+version = "0.1.0"
+source = { virtual = "." }
+
+[package.optional-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "pytest", marker = "extra == 'dev'", specifier = ">=9.0.2" },
+    { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.14.8" },
+]
+provides-extras = ["dev"]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.14.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ed/d9/f7a0c4b3a2bf2556cd5d99b05372c29980249ef71e8e32669ba77428c82c/ruff-0.14.8.tar.gz", hash = "sha256:774ed0dd87d6ce925e3b8496feb3a00ac564bea52b9feb551ecd17e0a23d1eed", size = 5765385, upload-time = "2025-12-04T15:06:17.669Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/48/b8/9537b52010134b1d2b72870cc3f92d5fb759394094741b09ceccae183fbe/ruff-0.14.8-py3-none-linux_armv6l.whl", hash = "sha256:ec071e9c82eca417f6111fd39f7043acb53cd3fde9b1f95bbed745962e345afb", size = 13441540, upload-time = "2025-12-04T15:06:14.896Z" },
+    { url = "https://files.pythonhosted.org/packages/24/00/99031684efb025829713682012b6dd37279b1f695ed1b01725f85fd94b38/ruff-0.14.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:8cdb162a7159f4ca36ce980a18c43d8f036966e7f73f866ac8f493b75e0c27e9", size = 13669384, upload-time = "2025-12-04T15:06:51.809Z" },
+    { url = "https://files.pythonhosted.org/packages/72/64/3eb5949169fc19c50c04f28ece2c189d3b6edd57e5b533649dae6ca484fe/ruff-0.14.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:2e2fcbefe91f9fad0916850edf0854530c15bd1926b6b779de47e9ab619ea38f", size = 12806917, upload-time = "2025-12-04T15:06:08.925Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/08/5250babb0b1b11910f470370ec0cbc67470231f7cdc033cee57d4976f941/ruff-0.14.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9d70721066a296f45786ec31916dc287b44040f553da21564de0ab4d45a869b", size = 13256112, upload-time = "2025-12-04T15:06:23.498Z" },
+    { url = "https://files.pythonhosted.org/packages/78/4c/6c588e97a8e8c2d4b522c31a579e1df2b4d003eddfbe23d1f262b1a431ff/ruff-0.14.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c87e09b3cd9d126fc67a9ecd3b5b1d3ded2b9c7fce3f16e315346b9d05cfb52", size = 13227559, upload-time = "2025-12-04T15:06:33.432Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ce/5f78cea13eda8eceac71b5f6fa6e9223df9b87bb2c1891c166d1f0dce9f1/ruff-0.14.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d62cb310c4fbcb9ee4ac023fe17f984ae1e12b8a4a02e3d21489f9a2a5f730c", size = 13896379, upload-time = "2025-12-04T15:06:02.687Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/79/13de4517c4dadce9218a20035b21212a4c180e009507731f0d3b3f5df85a/ruff-0.14.8-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1af35c2d62633d4da0521178e8a2641c636d2a7153da0bac1b30cfd4ccd91344", size = 15372786, upload-time = "2025-12-04T15:06:29.828Z" },
+    { url = "https://files.pythonhosted.org/packages/00/06/33df72b3bb42be8a1c3815fd4fae83fa2945fc725a25d87ba3e42d1cc108/ruff-0.14.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:25add4575ffecc53d60eed3f24b1e934493631b48ebbc6ebaf9d8517924aca4b", size = 14990029, upload-time = "2025-12-04T15:06:36.812Z" },
+    { url = "https://files.pythonhosted.org/packages/64/61/0f34927bd90925880394de0e081ce1afab66d7b3525336f5771dcf0cb46c/ruff-0.14.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4c943d847b7f02f7db4201a0600ea7d244d8a404fbb639b439e987edcf2baf9a", size = 14407037, upload-time = "2025-12-04T15:06:39.979Z" },
+    { url = "https://files.pythonhosted.org/packages/96/bc/058fe0aefc0fbf0d19614cb6d1a3e2c048f7dc77ca64957f33b12cfdc5ef/ruff-0.14.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb6e8bf7b4f627548daa1b69283dac5a296bfe9ce856703b03130732e20ddfe2", size = 14102390, upload-time = "2025-12-04T15:06:46.372Z" },
+    { url = "https://files.pythonhosted.org/packages/af/a4/e4f77b02b804546f4c17e8b37a524c27012dd6ff05855d2243b49a7d3cb9/ruff-0.14.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:7aaf2974f378e6b01d1e257c6948207aec6a9b5ba53fab23d0182efb887a0e4a", size = 14230793, upload-time = "2025-12-04T15:06:20.497Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/52/bb8c02373f79552e8d087cedaffad76b8892033d2876c2498a2582f09dcf/ruff-0.14.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e5758ca513c43ad8a4ef13f0f081f80f08008f410790f3611a21a92421ab045b", size = 13160039, upload-time = "2025-12-04T15:06:49.06Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/ad/b69d6962e477842e25c0b11622548df746290cc6d76f9e0f4ed7456c2c31/ruff-0.14.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f74f7ba163b6e85a8d81a590363bf71618847e5078d90827749bfda1d88c9cdf", size = 13205158, upload-time = "2025-12-04T15:06:54.574Z" },
+    { url = "https://files.pythonhosted.org/packages/06/63/54f23da1315c0b3dfc1bc03fbc34e10378918a20c0b0f086418734e57e74/ruff-0.14.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:eed28f6fafcc9591994c42254f5a5c5ca40e69a30721d2ab18bb0bb3baac3ab6", size = 13469550, upload-time = "2025-12-04T15:05:59.209Z" },
+    { url = "https://files.pythonhosted.org/packages/70/7d/a4d7b1961e4903bc37fffb7ddcfaa7beb250f67d97cfd1ee1d5cddb1ec90/ruff-0.14.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:21d48fa744c9d1cb8d71eb0a740c4dd02751a5de9db9a730a8ef75ca34cf138e", size = 14211332, upload-time = "2025-12-04T15:06:06.027Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/93/2a5063341fa17054e5c86582136e9895db773e3c2ffb770dde50a09f35f0/ruff-0.14.8-py3-none-win32.whl", hash = "sha256:15f04cb45c051159baebb0f0037f404f1dc2f15a927418f29730f411a79bc4e7", size = 13151890, upload-time = "2025-12-04T15:06:11.668Z" },
+    { url = "https://files.pythonhosted.org/packages/02/1c/65c61a0859c0add13a3e1cbb6024b42de587456a43006ca2d4fd3d1618fe/ruff-0.14.8-py3-none-win_amd64.whl", hash = "sha256:9eeb0b24242b5bbff3011409a739929f497f3fb5fe3b5698aba5e77e8c833097", size = 14537826, upload-time = "2025-12-04T15:06:26.409Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/63/8b41cea3afd7f58eb64ac9251668ee0073789a3bc9ac6f816c8c6fef986d/ruff-0.14.8-py3-none-win_arm64.whl", hash = "sha256:965a582c93c63fe715fd3e3f8aa37c4b776777203d8e1d8aa3cc0c14424a4b99", size = 13634522, upload-time = "2025-12-04T15:06:43.212Z" },
+]