semvec/pypi-packages huggingface dataset:
networkz 1.0.6
NetworkX plus plus
License: MIT
Requires Python: >=3.8
Keywords: optimization,graphs

# NetworkZ

NetworkZ is a library of graph algorithms in Python. It is an extension of the [NetworkX](https://github.com/networkx/networkx). It contains (by import) everything that is in NetworkX, plus some additional algorithms that were submitted into NetworkX but not merged yet. Currently, NetworkZ contains the following additional algorithms:

* [Rank-maximal matching](networkz/algorithms/bipartite/rank_maximal_matching.py): by Oriya Alperin, Liel Vaknin and Amiel Lejzor.
* [Social-aware coalition formation](networkz/algorithms/approximation/coalition_formation.py) - by Victor Kushnir.

## Installation

```
pip install networkz
```

This installs the latest version of networkx, and the new algorithms added in networkz.


## Usage

### Rank Maximal Matching Algorithm
A rank-maximal matching is a matching that maximizes the number of agents who are matched to their 1st priority; subject to that, it maximizes the number of agents matched to their 2nd priority; and so on.

```
import networkz as nx
G = nx.Graph()
G.add_nodes_from(["agent1", "agent2"], bipartite=0)
G.add_nodes_from(["product1", "product2"], bipartite=1)
G.add_weighted_edges_from([("agent1", "product1", 1), ("agent1", "product2", 1), ("agent2", "product2", 2)])
matching = nx.rank_maximal_matching(G, rank="weight")
print(matching)
```

See [demo website](https://rmm.csariel.xyz/) for more information.

### Social-aware coalition formation

(TODO)


## Contribution

Any additions or bug-fixes to `networkx` should first be submitted there, according to the [NetworkX Contributor Guide](https://github.com/networkx/networkx/blob/main/CONTRIBUTING.rst).

If the pull-request is not handled, you are welcome to submit it here too.
pyrdp 0.1.6
Simple Rammer-Douglas-Peuker algorithm implementation.
License: MIT
Requires Python: >=3.8

# Ramer-Douglas-Peucker

Ramer-Douglas-Peucker python implementation.

## Installation

```commandline
pip install pyrdp
```

## Usage

The rdp function supports both lists and numpy arrays of arbitrary dimensions.

```python
>>> from pyrdp import rdp
>>> rdp([[0,0],[1,1],[2,0]], epsilon=1)
[[0,0],[2,0]]
```

```python
>>> import numpy as np
>>> from pyrdp import rdp
>>> rdp(np.array([[0,0],[1,1],[2,0]]), epsilon=1)
array([[0,0],[2,0]])
```

If you specify `return_mask=True` the function will return a mask of the points
that were kept.

```python
>>> import numpy as np
>>> from pyrdp import rdp
>>> rdp(np.array([[0,0],[1,1],[2,0]]), epsilon=1)
array([True, False, True])
```
streamlit-ydata-profiling 0.2.1
YData Profiling component for Streamlit.
License: MIT
Requires Python: >=3.10,<3.12

# 📈 Streamlit ydata Profiling

[![GitHub][github_badge]][github_link] [![PyPI][pypi_badge]][pypi_link]

## Installation

```sh
pip install streamlit-ydata-profiling
```

## Getting started

Checkout this [example/main.py](example/main.py) code.

```python
import numpy as np
import pandas as pd
from ydata_profiling import ProfileReport
import streamlit as st

from streamlit_ydata_profiling import st_profile_report

df = pd.DataFrame(np.random.rand(100, 5), columns=["a", "b", "c", "d", "e"])
pr = ProfileReport(df, minimal=True, orange_mode=True, explorative=True)

st_profile_report(pr, navbar=True)
```

To view dashboard execute following command:

```bash
streamlit run example/main.py
```

## Demo

[![Open in Streamlit][share_badge]][share_link]

[![Preview](https://raw.githubusercontent.com/pejmans21/streamlit-ydata-profiling/main/demo.png)][share_link]

[share_badge]: https://static.streamlit.io/badges/streamlit_badge_black_white.svg
[share_link]: https://share.streamlit.io/okld/streamlit-gallery/main?p=ydata-profiling
[share_img]: https://raw.githubusercontent.com/okld/streamlit-ydata-profiling/main/preview.png

[github_badge]: https://badgen.net/badge/icon/GitHub?icon=github&color=black&label
[github_link]: https://github.com/okld/streamlit-ydata-profiling

[pypi_badge]: https://badgen.net/pypi/v/streamlit-ydata-profiling?icon=pypi&color=black&label
[pypi_link]: https://pypi.org/project/streamlit-ydata-profiling
biogemeutilities 1.0.5
Add features to the biogeme package
License: MIT
Requires Python: >=3.8.18
Keywords: biogeme,discrete choice models,confidence interval,calibrate

The `biogemeUtilities` is intended to add some quality-of-life features to the biogeme package. 
It inherit the features from biogeme, while adding some new functionality. 
The simplest way to use it, is to create a biogemeObject using the biogemeUtilities package, 
but it can also be used in existing script using biogemeObjects created directly in the biogeme package.
Examples of how to use this package are included below the relevant functions.

The full credit for the awesome biogeme package goes to Prof. Michel Bierlaire. 
Please visit the biogeme website for at full documentation of biogeme: https://biogeme.epfl.ch/

Version 1.0.5
2023-10-29
- First (beta) release on PyPI
- Compatible with biogeme 3.2.12
- Package renamed from "biogemeUtility" to "biogemeutility" to be aligned with the all lower case naming scheme in pip-install.


Version 1.0.1
2023-10-28
- First (beta) release on PyPI
- Compatible with biogeme 3.2.12
- v1.0.0 had an error in the package structure, which is corrected in v1.0.1


Version 1.0.0b1
2023-10-28
- First (beta) release on PyPI
- Compatible with biogeme 3.2.12
ratelimit_requests_cache 2023.10.30
Ratelimit Python requests, but only if they're not served from the cache
License: MIT
Requires Python: >=3.8

# ratelimit_requests_cache
*Ratelimit requests in Python, but only if they're not served from the cache*

This package combines the best bits of the [`ratelimit`](https://pypi.org/project/ratelimit) module and the [`requests_cache`](https://pypi.org/project/requests_cache) module.
It will rate limit outgoing requests, but not count invocations if a request can be served from the cache.

## Usage

```python
import requests
import requests_cache
from ratelimit import sleep_and_retry
from ratelimit_requests_cache import limits_if_not_cached


@sleep_and_retry
@limits_if_not_cached(calls=1, period=1)
def get_from_httpbin(i):
    return requests.get(f'https://httpbin.org/anything?i={i}')


# Enable requests caching
requests_cache.install_cache()

# Notice that only the first ten requests will be ratelimited to 1 request / second
# After that, it's a lot quicker since requests can be served from the cache
# and the ratelimiter does not engage
for i in range(100):
    get_from_httpbin(i % 10)
    print(i)
```

## Installation
```bash
python3 -m pip install ratelimit_requests_cache
```