rust-py-cache 0.2.0__tar.gz → 0.2.2__tar.gz

rust_py_cache-0.2.2/.github/workflows/ci.yml

@@ -0,0 +1,47 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  test:
+    name: cargo test + pytest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.10", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Set up Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@v2
+
+      # --no-default-features desliga extension-module, que manda o linker
+      # deixar os símbolos da libpython indefinidos. Isso é correto para a
+      # wheel, mas produz um binário de teste que não linka no Linux.
+      - name: cargo test
+        env:
+          PYO3_PYTHON: python
+        run: cargo test --no-default-features --lib
+
+      # `pip install` aciona o backend maturin, que compila a extensão e a
+      # instala no Python do runner — sem exigir virtualenv, ao contrário do
+      # `maturin develop`, que aborta quando não encontra um.
+      - name: Build, install the extension and run the Python tests
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install ".[dev]"
+          python -m pytest -q

rust_py_cache-0.2.2/.github/workflows/release.yml

@@ -0,0 +1,232 @@
+name: Release
+
+# Dispara ao publicar uma tag de versão (ex.: v0.1.0). Constrói as wheels para
+# todas as plataformas + sdist e publica no PyPI via Trusted Publishing (OIDC),
+# sem precisar guardar um token no repositório.
+#
+# O `ci.yml` roda em push/PR, mas é um workflow *separado*: um push de tag ia
+# direto para build e publicação sem depender dele. O job `test` abaixo é o que
+# torna a publicação condicionada a uma suíte verde — publicar no PyPI é
+# irreversível, então não pode acontecer sobre código não verificado.
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch: {}
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test (Rust + Python)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: cargo test
+        env:
+          PYO3_PYTHON: python
+        run: cargo test --no-default-features --lib
+      - name: Build, install the extension and run the Python tests
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install ".[dev]"
+          python -m pytest -q
+
+  # A matriz abaixo substitui um job `build` que rodava em ubuntu/macos/windows
+  # com `maturin build` puro. Aquilo publicava 3 wheels e o de Linux herdava a
+  # glibc do runner, em vez de passar pelo container manylinux. Quem estava em
+  # aarch64, em musl ou em Mac Intel caía no sdist — que exige toolchain Rust.
+  linux:
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: test
+    strategy:
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          # `auto` constrói dentro do container manylinux, então a wheel
+          # declara um piso de glibc portável em vez do da máquina de build.
+          manylinux: auto
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-linux-${{ matrix.target }}
+          path: dist
+
+  musllinux:
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: test
+    strategy:
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          manylinux: musllinux_1_2
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-musllinux-${{ matrix.target }}
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: test
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          architecture: x64
+      - uses: PyO3/maturin-action@v1
+        with:
+          target: x64
+          args: --release --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-windows-x64
+          path: dist
+
+  macos:
+    runs-on: macos-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: test
+    strategy:
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-macos-${{ matrix.target }}
+          path: dist
+
+  sdist:
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: test
+    steps:
+      - uses: actions/checkout@v4
+      - uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-sdist
+          path: dist
+
+  publish:
+    name: publish to PyPI
+    # Guarda além do gatilho: sem ela, um `workflow_dispatch` a partir de um
+    # branch publicaria no PyPI.
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: [test, linux, musllinux, windows, macos, sdist]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write   # necessário para o Trusted Publishing (OIDC)
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          merge-multiple: true
+          path: dist
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      # Conferência antes de qualquer coisa sair do runner: publicar um
+      # conjunto incompleto é pior que não publicar, porque o PyPI nunca deixa
+      # reusar um nome de arquivo — uma versão meio-publicada só pode ser
+      # completada, nunca substituída.
+      - name: Verify the artifact set is complete
+        run: |
+          set -euo pipefail
+          ls -la dist/
+          test -n "$(find dist -name '*.tar.gz' -print -quit)" \
+            || { echo "::error::sdist ausente — abortando antes de publicar"; exit 1; }
+          wheels=$(find dist -name '*.whl' | wc -l)
+          echo "wheels: $wheels"
+          test "$wheels" -ge 7 \
+            || { echo "::error::só $wheels wheels; esperado >= 7 (2 linux, 2 musl, 1 win, 2 macos)"; exit 1; }
+
+      # O PyPI devolve 500 transitório com frequência suficiente para importar,
+      # e o upload é arquivo por arquivo: uma falha no meio deixa a versão
+      # publicada pela metade. `skip-existing` é o que torna a segunda
+      # tentativa segura — sem ele, ela morre nos arquivos que já subiram.
+      #
+      # São dois passos explícitos em vez de um wrapper de retry porque o
+      # trusted publishing (OIDC) exige a action oficial, que não dá para
+      # acionar por linha de comando.
+      - name: Publish to PyPI (attempt 1)
+        id: publish1
+        continue-on-error: true
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist
+          skip-existing: true
+
+      - name: Wait before retrying
+        if: steps.publish1.outcome == 'failure'
+        run: sleep 45
+
+      - name: Publish to PyPI (attempt 2)
+        if: steps.publish1.outcome == 'failure'
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist
+          skip-existing: true
+
+      # Prova que a release está completa, em vez de confiar num código de
+      # saída que uma publicação parcial também produz.
+      - name: Verify every file reached PyPI
+        run: |
+          set -euo pipefail
+          python -m pip install --quiet requests
+          python - <<'PY'
+          import os, sys, glob, time, requests
+          version = os.environ["GITHUB_REF_NAME"].lstrip("v")
+          # Só .whl e .tar.gz: são os únicos tipos de arquivo que o PyPI hospeda.
+          # `pypa/gh-action-pypi-publish` deixa um .publish.attestation por
+          # distribuição em dist/ depois de publicar (atestados PEP 740, que
+          # sobem junto do arquivo, não como arquivo próprio). Um glob amplo os
+          # conta como "faltando no PyPI" e reprova uma release que deu certo.
+          local = {
+              os.path.basename(p)
+              for pattern in ("dist/*.whl", "dist/*.tar.gz")
+              for p in glob.glob(pattern)
+          }
+          url = f"https://pypi.org/pypi/rust-py-cache/{version}/json"
+          for attempt in range(6):          # a API JSON do PyPI é cacheada
+              response = requests.get(url, timeout=30)
+              if response.status_code == 200:
+                  remote = {f["filename"] for f in response.json()["urls"]}
+                  missing = local - remote
+                  if not missing:
+                      print(f"OK: {len(remote)} arquivos publicados na {version}")
+                      sys.exit(0)
+              else:
+                  missing = local
+              print(f"tentativa {attempt + 1}: faltam {len(missing)}")
+              time.sleep(20)
+          print("::error::faltaram arquivos no PyPI:")
+          for name in sorted(missing):
+              print(f"  - {name}")
+          sys.exit(1)
+          PY

rust_py_cache-0.2.2/CHANGELOG.md

@@ -0,0 +1,78 @@
+# Changelog
+
+Todas as mudanças relevantes deste projeto são registradas aqui.
+
+O formato segue [Keep a Changelog](https://keepachangelog.com/pt-BR/1.1.0/),
+e o versionamento segue [SemVer](https://semver.org/lang/pt-BR/).
+
+## [0.2.2] - 2026-08-11
+
+Release de infraestrutura: nada muda no comportamento da biblioteca, mas muda
+quem consegue instalá-la sem compilar.
+
+### Corrigido
+
+- **A publicação não roda mais sem teste.** O `ci.yml` roda em push/PR, mas é
+  um workflow **separado**: um push de tag ia direto para build e publicação
+  sem depender dele. O `release.yml` agora tem o seu próprio job `test` e todos
+  os demais declaram `needs: test`. O job `publish` também ganhou
+  `if: startsWith(github.ref, 'refs/tags/')` — sem essa guarda, um
+  `workflow_dispatch` a partir de um branch publicaria no PyPI.
+  (BACKLOG2 P1-1)
+- **Cobertura de plataformas.** A 0.2.1 publicou 3 wheels — uma por runner
+  (ubuntu, macos, windows) — e a de Linux herdava a glibc da máquina de build
+  em vez de passar pelo container manylinux. Caíam no sdist, ou seja,
+  precisavam de toolchain Rust: Linux aarch64, Alpine/musl e Mac Intel. Agora
+  são 7 wheels (2 manylinux, 2 musllinux, 1 Windows, 2 macOS) mais o sdist.
+- **O upload aguenta o 500 do PyPI.** O upload é arquivo por arquivo e sem
+  transação — uma falha no meio deixa a versão publicada pela metade, e o PyPI
+  nunca permite reusar um nome de arquivo. Agora há `skip-existing` (que é o
+  que torna a segunda tentativa segura), uma segunda tentativa explícita,
+  conferência do conjunto de artefatos **antes** de publicar e validação contra
+  a API do PyPI **depois**. (BACKLOG2 P1-9)
+
+### Alterado
+
+- `crate-type` ganhou `rlib` além de `cdylib`, e `extension-module` virou
+  feature opcional ligada por padrão. Assim
+  `cargo test --no-default-features --lib` produz um binário de teste que linka
+  no Linux, em vez de depender da tolerância do linker do macOS. É o mesmo
+  arranjo dos outros quatro projetos. (BACKLOG2 P1-8)
+- O `ci.yml` deixou de criar um virtualenv à mão para rodar `maturin develop`;
+  agora usa `pip install ".[dev]"`, que aciona o mesmo backend maturin sem
+  exigir virtualenv.
+
+### Adicionado
+
+- Extra `[project.optional-dependencies] dev`. Este era o único dos cinco
+  projetos sem um. (BACKLOG2 P2-9)
+
+## [0.2.1] - 2026-08-11
+
+### Corrigido
+
+- `@cache.cached` sobre função `async def` guardava no cache o objeto coroutine
+  em vez do resultado do `await`, quebrando o decorator já na primeira chamada
+  com `TypeError: cannot pickle 'coroutine' object`. O decorator agora detecta
+  `inspect.iscoroutinefunction` e gera um wrapper `async` que faz o `await`
+  antes do `set`. (BACKLOG2 P0-2)
+
+## [0.2.0]
+
+### Adicionado
+
+- Expiração em background via `Sweeper` (thread dedicada com `Weak<T>`,
+  encerramento limpo no `Drop`).
+- Evicção por `max_size` com política LRU.
+- Exemplos para FastAPI e Django.
+
+## [0.1.x]
+
+### Adicionado
+
+- `Cache` com `set` / `get(default=...)` / `delete` / `exists` / `keys` /
+  `len` / `clear` / `cleanup_expired` / `stats`.
+- TTL por entrada com expiração preguiçosa.
+- `stats()` cumulativo baseado em `AtomicU64`.
+- Decorator de memoização `@cache.cached(ttl=..., key=...)`.
+- Core em Rust sobre `DashMap`, valores serializados com `pickle`.

{rust_py_cache-0.2.0 → rust_py_cache-0.2.2}/Cargo.lock

@@ -202,7 +202,7 @@ dependencies = [
 
 [[package]]
 name = "rust_py_cache"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "dashmap",
  "pyo3",

{rust_py_cache-0.2.0 → rust_py_cache-0.2.2}/Cargo.toml

@@ -1,21 +1,29 @@
 [package]
 name = "rust_py_cache"
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 readme = "README.md"
 
 # Biblioteca de extensão para Python:
-#   - crate-type = ["cdylib"]  -> gera um .so/.dylib carregável pelo Python
+#   - cdylib -> gera o .so/.dylib carregável pelo Python
+#   - rlib   -> alvo de biblioteca normal, que o `cargo test` usa para montar
+#               o harness de teste
 #   - name = "_rust_py_cache"  -> nome do módulo nativo (importado pelo __init__.py)
 [lib]
 name = "_rust_py_cache"
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 # abi3-py310: compila contra a Stable ABI do CPython 3.10+, gerando uma única
 # wheel compatível com 3.10, 3.11, 3.12, 3.13...
-# extension-module: não linka o binário do Python (o interpretador resolve em runtime).
-pyo3 = { version = "0.24", features = ["abi3-py310", "extension-module"] }
+#
+# extension-module NÃO fica aqui: ele manda o linker deixar os símbolos da
+# libpython indefinidos, o que é correto para a wheel mas frágil para o binário
+# de teste no Linux (o macOS tolera com -undefined dynamic_lookup). Vive em
+# [features] no fim do arquivo, ligado por padrão, para que
+# `cargo test --no-default-features` possa desligá-lo. É o mesmo arranjo dos
+# outros quatro projetos.
+pyo3 = { version = "0.24", features = ["abi3-py310"] }
 
 # DashMap: HashMap concorrente (lock por shard). Permite get/set de várias threads
 # Python sem um Mutex global no caminho crítico. Usado pelo RustCache (Etapa 4).
@@ -30,3 +38,10 @@ thiserror = "2"
 # serde_json  = "1"                                         # serializer JSON
 # No MVP o TTL usa std::time::SystemTime (epoch em ms), então o crate `time`
 # também não é necessário ainda.
+
+[features]
+# maturin constrói com as features default (a wheel ganha extension-module);
+# a CI roda `cargo test --no-default-features --lib` para obter um binário de
+# teste que consegue linkar contra a libpython.
+extension-module = ["pyo3/extension-module"]
+default = ["extension-module"]

{rust_py_cache-0.2.0 → rust_py_cache-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rust-py-cache
-Version: 0.2.0
+Version: 0.2.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
@@ -8,6 +8,9 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Database
 Classifier: Topic :: System :: Distributed Computing
+Requires-Dist: pytest>=7.0 ; extra == 'dev'
+Requires-Dist: maturin>=1.7 ; extra == 'dev'
+Provides-Extra: dev
 Summary: An ultra-fast local cache for Python, powered by Rust.
 Keywords: cache,rust,pyo3,ttl,performance
 Author-email: Roberto Lima <robertolima.izphera@gmail.com>

{rust_py_cache-0.2.0 → rust_py_cache-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rust-py-cache"
-version = "0.2.0"
+version = "0.2.2"
 description = "An ultra-fast local cache for Python, powered by Rust."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -21,6 +21,9 @@ classifiers = [
     "Topic :: System :: Distributed Computing",
 ]
 
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "maturin>=1.7"]
+
 [project.urls]
 Homepage = "https://github.com/robertolima/rust-py-cache"
 
@@ -29,5 +32,6 @@ Homepage = "https://github.com/robertolima/rust-py-cache"
 python-source = "python"
 # Compila o .so como submódulo nativo dentro do pacote Python.
 module-name = "rust_py_cache._rust_py_cache"
-# Gera wheel abi3 (uma wheel para 3.10+).
-features = ["pyo3/extension-module"]
+# extension-module vem das features default do crate (ver Cargo.toml), então
+# não precisa ser repetido aqui — e repetir reativaria a feature mesmo num
+# build que pediu --no-default-features de propósito.

{rust_py_cache-0.2.0 → rust_py_cache-0.2.2}/python/rust_py_cache/__init__.py

@@ -19,4 +19,4 @@ class Cache(_RustCache):
 
 
 __all__ = ["Cache", "hello"]
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{rust_py_cache-0.2.0 → rust_py_cache-0.2.2}/python/rust_py_cache/decorators.py

@@ -6,6 +6,7 @@ chave e `functools.wraps` — tudo muito mais natural aqui.
 """
 
 import functools
+import inspect
 
 # Sentinela para distinguir "ausente no cache" de "valor None legítimo".
 # `cache.get(key, _MISSING)` devolve `_MISSING` só quando a chave não existe.
@@ -37,25 +38,52 @@ def cached(self, ttl=None, key=None):
         @cache.cached(ttl=60)
         def soma(a, b):
             return a + b
+
+        @cache.cached(ttl=60)
+        async def busca(id):
+            return await api.get(id)
+
+    Funções `async def` são detectadas e recebem um wrapper `async`, que guarda
+    no cache o resultado do `await` — não o objeto coroutine. Cachear a coroutine
+    faria a segunda chamada levantar `RuntimeError: cannot reuse already awaited
+    coroutine`.
     """
 
+    def _resolve_key(func, args, kwargs):
+        if key is None:
+            return _default_key(func, args, kwargs)
+        if callable(key):
+            return key(*args, **kwargs)
+        return key
+
     def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            if key is None:
-                cache_key = _default_key(func, args, kwargs)
-            elif callable(key):
-                cache_key = key(*args, **kwargs)
-            else:
-                cache_key = key
-
-            hit = self.get(cache_key, _MISSING)
-            if hit is not _MISSING:
-                return hit
-
-            result = func(*args, **kwargs)
-            self.set(cache_key, result, ttl=ttl)
-            return result
+        if inspect.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def wrapper(*args, **kwargs):
+                cache_key = _resolve_key(func, args, kwargs)
+
+                hit = self.get(cache_key, _MISSING)
+                if hit is not _MISSING:
+                    return hit
+
+                result = await func(*args, **kwargs)
+                self.set(cache_key, result, ttl=ttl)
+                return result
+
+        else:
+
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                cache_key = _resolve_key(func, args, kwargs)
+
+                hit = self.get(cache_key, _MISSING)
+                if hit is not _MISSING:
+                    return hit
+
+                result = func(*args, **kwargs)
+                self.set(cache_key, result, ttl=ttl)
+                return result
 
         # Expõe a chave-base para inspeção/invalidação manual em testes.
         wrapper.__wrapped__ = func

{rust_py_cache-0.2.0 → rust_py_cache-0.2.2}/tests/test_features.py

@@ -1,5 +1,6 @@
 """Testes de exists/keys/stats/cleanup_expired/clear e decorator — Etapas 8-17."""
 
+import asyncio
 import time
 
 from rust_py_cache import Cache
@@ -110,3 +111,63 @@ def test_decorator_caches_none_result():
     assert returns_none() is None
     assert returns_none() is None
     assert calls["n"] == 1  # None foi cacheado, não recomputou
+
+
+def test_decorator_caches_async_function():
+    """P0-2: `@cached` sobre `async def` deve cachear o RESULTADO do await.
+
+    Antes da correção, o wrapper síncrono guardava o objeto coroutine: a
+    primeira chamada devolvia o valor certo e a segunda levantava
+    `RuntimeError: cannot reuse already awaited coroutine`.
+    """
+    cache = Cache()
+    calls = {"n": 0}
+
+    @cache.cached(ttl=60)
+    async def busca(x):
+        calls["n"] += 1
+        return x * 2
+
+    async def cenario():
+        # Duas chamadas no mesmo event loop — é aqui que o bug aparecia.
+        primeira = await busca(21)
+        segunda = await busca(21)
+        terceira = await busca(10)  # args diferentes -> recomputa
+        return primeira, segunda, terceira
+
+    primeira, segunda, terceira = asyncio.run(cenario())
+
+    assert primeira == 42
+    assert segunda == 42
+    assert terceira == 20
+    assert calls["n"] == 2  # busca(21) rodou uma vez só
+
+
+def test_decorator_async_keeps_coroutine_function():
+    """O wrapper de uma `async def` continua sendo uma coroutine function."""
+    cache = Cache()
+
+    @cache.cached()
+    async def f():
+        return 1
+
+    assert asyncio.iscoroutinefunction(f)
+    assert f.__name__ == "f"
+
+
+def test_decorator_async_caches_none_result():
+    cache = Cache()
+    calls = {"n": 0}
+
+    @cache.cached()
+    async def returns_none():
+        calls["n"] += 1
+        return None
+
+    async def cenario():
+        return await returns_none(), await returns_none()
+
+    a, b = asyncio.run(cenario())
+    assert a is None
+    assert b is None
+    assert calls["n"] == 1

rust_py_cache-0.2.0/.github/workflows/ci.yml

@@ -1,77 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-jobs:
-  test:
-    name: cargo test + pytest
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-        python-version: ["3.10", "3.12", "3.13"]
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Set up Rust
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Cache cargo
-        uses: Swatinem/rust-cache@v2
-
-      # Testes do core Rust (puro, sem Python).
-      - name: cargo test
-        run: cargo test --verbose
-
-      # maturin develop exige um virtualenv ativo. O setup-python não cria um,
-      # então criamos o .venv e o exportamos para os próximos steps via
-      # GITHUB_ENV/GITHUB_PATH (cada step roda num shell novo).
-      - name: Create virtualenv
-        run: |
-          python -m venv .venv
-          echo "VIRTUAL_ENV=$PWD/.venv" >> "$GITHUB_ENV"
-          echo "$PWD/.venv/bin" >> "$GITHUB_PATH"
-
-      - name: Install Python deps
-        run: |
-          python -m pip install --upgrade pip
-          pip install maturin pytest
-
-      # Compila a extensão e instala no .venv.
-      - name: maturin develop
-        run: maturin develop
-
-      - name: pytest
-        run: pytest -q
-
-  build-wheels:
-    name: build wheels (abi3)
-    runs-on: ${{ matrix.os }}
-    needs: test
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          command: build
-          args: --release --out dist
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ matrix.os }}
-          path: dist

rust_py_cache-0.2.0/.github/workflows/release.yml

@@ -1,57 +0,0 @@
-name: Release
-
-# Dispara ao publicar uma tag de versão (ex.: v0.1.0). Constrói as wheels para
-# todas as plataformas + sdist e publica no PyPI via Trusted Publishing (OIDC),
-# sem precisar guardar um token no repositório.
-on:
-  push:
-    tags: ["v*"]
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    name: build (${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          command: build
-          args: --release --out dist
-      - name: Build sdist
-        if: matrix.os == 'ubuntu-latest'
-        uses: PyO3/maturin-action@v1
-        with:
-          command: sdist
-          args: --out dist
-      - uses: actions/upload-artifact@v4
-        with:
-          name: dist-${{ matrix.os }}
-          path: dist
-
-  publish:
-    name: publish to PyPI
-    needs: build
-    runs-on: ubuntu-latest
-    environment: pypi
-    permissions:
-      id-token: write   # necessário para o Trusted Publishing (OIDC)
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: dist-*
-          merge-multiple: true
-          path: dist
-      - name: Publish
-        uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          packages-dir: dist