semvec/pypi-packages huggingface dataset:
lazy-signals 0.2.0
running effects on value updates with dependency discovery - conceptually inspired by Signal in JavaScript
Requires Python: >=3.6
Keywords: reactive, signals, effects, lazy, dependencies


# Lazy Signals 🪢

[![GitHub](https://img.shields.io/github/license/adrian-gallus/lazy-signals-python)](https://github.com/adrian-gallus/lazy-signals-python)
[![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/adrian-gallus/lazy-signals-python/release.yaml)](https://github.com/adrian-gallus/lazy-signals-python)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/lazy-signals)](https://pypi.org/project/lazy-signals/)
[![PyPI - Version](https://img.shields.io/pypi/v/lazy-signals)](https://pypi.org/project/lazy-signals/)

`lazysignals` is a Python library that runs effects whenever state changes. It employs dependency discovery and updates are lazy. The library is conceptually inspired by [signals](https://github.com/tc39/proposal-signals) in JavaScript.

Please checkout our latest [documentation](https://adrian-gallus.github.io/lazy-signals-python/).

## Example

The framework runs relevant effects whenever some state changes:

define a new signal `s`, holding the initial value `1`

    s = Signal(1)

derive a signal that checks the parity of `s`

    p = derived(lambda: s.value % 2 == 0)

log the parity `p` to the console

    effect(lambda: print(f"parity:", "even" if p.value else "odd"))

perform some updates to `s`

    s.value = 1  # no change, no output
    s.value = 2  # output: "parity: even"
    s.value = 3  # output: "parity: odd"
    s.value = 5  # no change, no output
    s.value = 6  # output: "parity: even"

Have a look at `example.py` for more; run with `pipenv install` (to locally install this library) and `pipenv run example`.
pyVinted 0.5.3
Vinted API wrapper for python
Requires Python: >=3.6
Keywords: python, Vinted api, Vinted API wrapper, python vinted

# Vinted-Api-Wrapper
Simple python package that uses the Vinted API to search new posts.

## Install
Simpely install package using pip :
```
pip install pyVinted
```
## Example

```py
from pyVinted import Vinted

vinted = Vinted()

# search(url, number_of_items, page_number)
items = vinted.items.search("https://www.vinted.fr/vetement?order=newest_first&price_to=60&currency=EUR",10,1)
#returns a list of objects: item

```
You can access Item attributes as shown here:
```py
item1 = items[0]
#title
item1.title
#id
item1.id
#photo url
item1.photo
#brand
item1.brand_title
#price
item1.price
#url
item1.url
#currency
item1.currency
```
polars-simed 0.3.4
Fast similarity join for polars DataFrames. Fork by Edwardvaneechoud with fixes.
Requires Python: >=3.10

# polars_simed

## Description

Implements an **approximate join** of two polars dataframes based on string columns.


Right now, we use a fixed vectorization, which is applied on the fly and eventually
used in a sparse matrix multiplication combined with a top-n selection. This produces
the cosine similarities of the individual string pairs.

The `join_sim` function is similar to a left join or `join_asof` but for strings instead of timestamps.

## Installation

```bash
pip install polars_simed
```

## Development

We use [uv](https://docs.astral.sh/uv/) for python package management. Furthermore, you need rust to be installed, see [install rust](https://www.rust-lang.org/tools/install). You won't need to activate an enviroment by yourself at any point. This is handled by uv. To get started, run
```bash
# install python dependencies and compile the rust code
make install 
# run tests
make test
```

## Usage

```python
import polars as pl
import polars_simed as ps

df_left = pl.DataFrame(
    {
        "name": ["alice", "bob", "charlie", "david"],
    }
)

df_right = pl.DataFrame(
    {
        "name": ["ali", "alice in wonderland", "bobby", "tom"],
    }
)

df = ps.join_sim(
    df_left,
    df_right,
    on="name",
    top_n=4,
)

shape: (3, 3)
┌───────┬──────────┬─────────────────────┐
│ name  ┆ sim      ┆ name_right          │
│ ---   ┆ ---      ┆ ---                 │
│ str   ┆ f32      ┆ str                 │
╞═══════╪══════════╪═════════════════════╡
│ alice ┆ 0.57735  ┆ ali                 │
│ alice ┆ 0.522233 ┆ alice in wonderland │
│ bob   ┆ 0.57735  ┆ bobby               │
└───────┴──────────┴─────────────────────┘
```

# Performance

A benchmark can be executed with `make run-bench`. 
In general, the performance heavily depends on the length of the dataframes.
By default, the computation is parallelized over the left dataframe. However, serveral benchmarks 
showed that if the right dataframe is much bigger than the left dataframe and no normalization is applied, it is faster to parallelize over the right dataframe. 

If no normalization is applied, the performance is usually better since the a small uint type will
be used for the sparse matrix multiplication, e.g. u16. Otherwise, all types will be of 32 bit size.

# References

The implementation is based on an algorithm used in [sparse_dot_topn](https://github.com/ing-bank/sparse_dot_topn), which itself is an improvement of the scipy sparse matrix multiplication.
filmlens 0.0.2
SDK Python pour accéder à l’API MovieLens (Data Analysts/Data Scientists friendly)
Requires Python: >=3.12

# MovieLens SDK - `filmlens`

Un SDK Python simple pour interagir avec l’API REST MovieLens. Il est conçu pour les **Data Analysts** et **Data Scientists**, avec une prise en charge native de **Pydantic**, **dictionnaires** et **DataFrames Pandas**.

[![PyPI version](https://badge.fury.io/py/moviesdk.svg)](https://badge.fury.io/py/moviesdk)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

---

## Installation

```bash
pip install filmlens
```

---

## Configuration

```python
from filmlens import MovieClient, MovieConfig

# Configuration avec l’URL de votre API (Render ou locale)
config = MovieConfig(movie_base_url="https://movie-backend-8zzx.onrender.com")
client = MovieClient(config=config)
```

---

## Tester le SDK

### 1. Health check

```python
client.health_check()
# Retourne : {"status": "ok"}
```

### 2. Récupérer un film

```python
movie = client.get_movie(1)
print(movie.title)
```

### 3. Liste de films au format DataFrame

```python
df = client.list_movies(limit=5, output_format="pandas")
print(df.head())
```

---

## Modes de sortie disponibles

Toutes les méthodes de liste (`list_movies`, `list_ratings`, etc.) peuvent retourner :

- des objets **Pydantic** (défaut)
- des **dictionnaires**
- des **DataFrames Pandas**

Exemple :

```python
client.list_movies(limit=10, output_format="dict")
client.list_ratings(limit=10, output_format="pandas")
```

---

## Tester en local

Vous pouvez aussi utiliser une API locale :

```python
config = MovieConfig(movie_base_url="http://localhost:8000")
client = MovieClient(config=config)
```

---

## Public cible

- Data Analysts
- Data Scientists
- Étudiants et curieux en Data
- Développeurs Python

---

## Licence

MIT License

---

## Liens utiles

- API Render : [https://movie-backend-8zzx.onrender.com](https://movie-backend-8zzx.onrender.com)
- PyPI : [https://pypi.org/project/filmlens](https://pypi.org/project/filmlens)