semvec/pypi-packages huggingface dataset:
harvest-utils 0.1.0
Utilities extracted from the Harvest project
License: MIT
Requires Python: >=3.8

# harvest-utils

Reusable utilities extracted from the Harvest project.

Quick start:

```bash
pip install harvest-utils==0.1.0
```

Example usage:

```python
from harvest_utils import example_util, iso_now

print(example_util())
print(iso_now())
```

Publishing:
- Build: `python -m build`
- Test upload to TestPyPI: `python -m twine upload --repository-url https://test.pypi.org/legacy/ dist/*`
- Production upload: `python -m twine upload dist/*` (use CI on protected branch)

See CHANGELOG.md for releases.
silvanus 0.1.1b1
A simple library for routing with a tree-like structure
License: MIT
Requires Python: <4.0,>=3.9

# SILVANUS
The simple library for different routing with a tree-like structure

# Implementation example
Silvanus is created as a **low-level library that 
simplifies the construction** of productive, user-friendly, functional 
and customizable frameworks on top of. These can be different options 
(data buses, web, etc.), therefore, for an example of how it might look, 
there is **[silvahttp](https://github.com/Sethis/silvahttp)**.

# Paradigms:
- Each element is changeable almost beyond recognition, 
but a combination of them is possible due to common protocols 
that are well described out of the box.
- Many things are done out of the box 
(for example, the almost universal
[SimpleRouter](https://github.com/Sethis/silvanus/blob/master/silvanus/routing/simple.py)
and its two RouterIterators, which implement both the
[data queue interface with filters](https://github.com/Sethis/silvanus/blob/master/silvanus/strategy/routers/first.py)
and the 
[data bus interface with filters](https://github.com/Sethis/silvanus/blob/master/silvanus/strategy/routers/all.py)
)
- The most universal protocols, which is why it is recommended 
to write small wrappers on top of routing for frameworks.

# Usage

**First:**
```commandline
pip install silvanus
```

**Later:**

data queue interface with filters using FirstTrueRouterIterator, and
data bus interface with filters using AllTrueRouterIterator
```python
import asyncio
from dataclasses import dataclass

from silvanus.routing.simple import SimpleRouter
from silvanus.strategy.routers import FirstTrueRouterIterator, AllTrueRouterIterator
from silvanus.structures import RoutingData


@dataclass(frozen=True)
class SimpleFilter: # Our custom simple filter
    value: int
    
    async def __call__(self, data: RoutingData) -> bool:
        return data.request_data.get("value", None) == self.value
    
    
# silvanus supports all data types as a result of routing, 
# but the most useful for frameworks will be the return of functions.
def some_handler(text: str) -> str:
    return text * 2


router = SimpleRouter()

router1 = SimpleRouter([SimpleFilter(value=10)], data="wrong")

router2 = SimpleRouter([SimpleFilter(value=15), ], data=some_handler)
router3 = SimpleRouter([SimpleFilter(value=15), ], data="yes!")

router.add_routers([router1, router2, router3])

async def main():
    result = await router.route(
        data=RoutingData(
            request_data={"value": 15}
        ),
        iterator=FirstTrueRouterIterator() # get only first True result 
    )
    
    assert result("silvanus-") == "silvanus-silvanus-" # our some_handler
    
    result_2 = await router.route(
        data=RoutingData(
            request_data={"value": 15}
        ),
        iterator=AllTrueRouterIterator() # get all True result 
    )
    
    assert result_2[0](result_2[1]) == "yes!yes!" # our some_handler and text from second data 

asyncio.run(main())

```


# Examples:
  - ### [html integration example](https://github.com/Sethis/silvanus/blob/master/examples/http.py)
shieldforge 0.2.0
Scanner éthique pour projets open source: code, dépendances, rapports et alertes.
License: MIT
Requires Python: >=3.8



cat > README.md << 'EOF'
# ShieldForge

Scanner éthique pour l'open source : **Bandit**, **pip-audit**, **OSV-Scanner** (optionnel), rapports JSON, email d'alerte.

## Utilisation rapide
```bash
pip install -e .
shieldforge scan ./tests/demo_project --bandit --deps


---

## ÉTAPE 5 — `src/shieldforge/__init__.py`

```bash
cat > src/shieldforge/__init__.py << 'EOF'
__version__ = "0.1.0"

## Badges
![PyPI](https://img.shields.io/pypi/v/shieldforge)
![CI](https://github.com/tonuser/ShieldForge/actions/workflows/ci.yml/badge.svg)
pycuda-gml 2025.1.2.post1
Python wrapper for Nvidia CUDA
License: MIT
Requires Python: ~=3.8

PyCUDA: Pythonic Access to CUDA, with Arrays and Algorithms
=============================================================

.. image:: https://gitlab.tiker.net/inducer/pycuda/badges/main/pipeline.svg
    :alt: Gitlab Build Status
    :target: https://gitlab.tiker.net/inducer/pycuda/commits/main
.. image:: https://badge.fury.io/py/pycuda.png
    :target: https://pypi.org/project/pycuda
.. image:: https://zenodo.org/badge/1575319.svg
    :alt: Zenodo DOI for latest release
    :target: https://zenodo.org/badge/latestdoi/1575319

PyCUDA lets you access `Nvidia <https://nvidia.com>`_'s `CUDA
<https://nvidia.com/cuda/>`_ parallel computation API from Python.
Several wrappers of the CUDA API already exist-so what's so special
about PyCUDA?

* Object cleanup tied to lifetime of objects. This idiom, often
  called
  `RAII <https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization>`_
  in C++, makes it much easier to write correct, leak- and
  crash-free code. PyCUDA knows about dependencies, too, so (for
  example) it won't detach from a context before all memory
  allocated in it is also freed.

* Convenience. Abstractions like pycuda.driver.SourceModule and
  pycuda.gpuarray.GPUArray make CUDA programming even more
  convenient than with Nvidia's C-based runtime.

* Completeness. PyCUDA puts the full power of CUDA's driver API at
  your disposal, if you wish. It also includes code for
  interoperability with OpenGL.

* Automatic Error Checking. All CUDA errors are automatically
  translated into Python exceptions.

* Speed. PyCUDA's base layer is written in C++, so all the niceties
  above are virtually free.

* Helpful `Documentation <https://documen.tician.de/pycuda>`_.

Relatedly, like-minded computing goodness for `OpenCL <https://www.khronos.org/registry/OpenCL/>`_
is provided by PyCUDA's sister project `PyOpenCL <https://pypi.org/project/pyopencl>`_.