semvec/pypi-packages huggingface dataset:
cjrh-scalable-cuckoo-filter 0.3.2
Scalable Cuckoo Filter implemented in Rust with Python bindings
Requires Python: >=3.10
Keywords: cuckoo-filter, probabilistic, data-structure, bloom-filter

# scalable-cuckoo-filter-py

Python wrapper for [sile/scalable_cuckoo_filter](https://github.com/sile/scalable_cuckoo_filter)

See the crate that this wraps: https://docs.rs/scalable_cuckoo_filter/

This can be used as a probabilistic data structure for set membership tests. 
A cuckoo filter is similar to a Bloom filter, but it supports deletions.

This implementation is scalable, meaning that it can grow and shrink 
dynamically while maintinaing a low false positive rate.

## Install

> **The package name is different to the import name**. The install name is `cjrh-scalable-cuckoo-filter` but the import name is `scf`. This is because the package name must be unique on PyPI, and `scalable-cuckoo-filter` was already taken.

Install:

```bash
$ pip install cjrh-scalable-cuckoo-filter
```

Import:

```
import scf
from scf import PyScalableCuckooFilter
```

## Usage

Create the filter and add a few strings:

```python
from scf import PyScalableCuckooFilter


scf = PyScalableCuckooFilter(1000, 0.001)
scf.insert("hello")
scf.insert("world")
```

Now we can do membership tests:

```python
assert scf.might_contain("hello")
assert scf.might_contain("world")
assert not scf.might_contain("foo")
```

We can remove entries:

```python 
scf.remove("hello")
assert not scf.might_contain("hello")
```

We can save the filter to a file:

```python 
scf.write_to_file("filter.bin")
```

And load it back:

```python 
scf = PyScalableCuckooFilter.read_from_file("filter.bin")
assert scf.might_contain("world")
```

## Types

These are the the types that can be used with the filter:
- `str`
- `bytes`
- `bytearray`
- `int`
- `float`
- `bool`
- Iterables of the above types, with nesting.

For example, you can insert a list of integers:

```python
scf = PyScalableCuckooFilter(1000, 0.001)
scf.insert([1, 2, 3])  # list
scf.insert([1, (2, [3])])  # list(tuple(list)))
```

However, note that all iterables will hash the same as each other. For example, 
`["foo", "bar"]` and `("foo", "bar")` will be regarded as the same key.
In fact, any iterable with the same elements will hash the same.

```python
scf = PyScalableCuckooFilter(1000, 0.001)
scf.insert(range(3))  # iterable
assert scf.might_contain((0, 1, 2))  # tuple
```
relife 2.5.2
ReLife is an open source Python library for asset management based on reliability theory.
Requires Python: >=3.11

<h1 align="center">
  <img src="doc/source/_static/small_relife.gif" />
</h1></br>

An open-source Python library for asset management

- **Documentation:** http://opensource.rte-france.com/relife/
- **Source code:** https://github.com/rte-france/relife
- **Contributing:** http://opensource.rte-france.com/relife/developper/index.html
- **Bug reports:** https://github.com/rte-france/relife/issues

Some explanations might be missing until we finish the documentation properly, so do not hesitate to open an issue.

## Installation

**From PyPi**

```bash
$ pip install relife
```

**From source**

```bash
$ git clone https://github.com/rte-france/relife.git
$ cd relife
$ pip install .
```

**For developpers**

```bash
$ git clone https://github.com/rte-france/relife.git
$ cd relife
$ pip install -e ".[dev]"
```

## Citing

```
@misc{relife,
    author = {T. Guillon},
    title = {ReLife: a Python package for asset management based on reliability theory and lifetime data analysis.},
    year = {2022},
    journal = {GitHub},
    howpublished = {\url{https://github.com/rte-france/relife}},
}
```

## Credits

- The documentation uses [pydata-sphinx-theme](https://github.com/pydata/pydata-sphinx-theme) project. Original license
  is [here](doc/LICENSE.txt)
- Some parts of the documentation are highly inspired by [Scikit-learn](https://scikit-learn.org/stable/), [Scipy](https://scipy.org/) and [NumPy](https://numpy.org/)
combine-csv-files 0.1.1
GUI and console tools for combining CSV files and filtering/exporting CSV/XLSX datasets.
Requires Python: >=3.9
Keywords: csv, xlsx, tkinter, pandas, data-cleaning, gui

# Combine CSV Files

Simple desktop tools to:
- combine many CSV files into one file
- filter large datasets and export to CSV/XLSX

Both apps support **English** and **Polish** in the GUI.

## Apps You Can Use

### 1) `combine_csv_gui.py`
Use this when you want to merge multiple CSV files into one output.

What it does:
- reads many CSV files (with encoding/delimiter auto-detection)
- aligns columns to a consistent layout
- can remove duplicates
- exports to CSV or XLSX

### 2) `filter_export_gui_streaming.py`
Use this when you want to filter data, especially very large CSV files.

What it does:
- streams CSV in chunks (memory-friendly)
- filters by:
  - text contains
  - numeric min/max
  - date range
  - location list
  - non-empty phone
- can remove duplicates
- exports to CSV or XLSX

## Install

### Option A: From PyPI (recommended when published)
```bash
pip install combine-csv-files
```

### Option B: From source
```bash
python -m venv .venv
# Windows:
.\.venv\Scripts\activate
# macOS/Linux:
# source .venv/bin/activate

python -m pip install --upgrade pip
pip install -e .
```

## Run the Apps

After install, use:
- `combine-csv-gui`
- `filter-export-streaming`

Or run directly from source:
- `python combine_csv_gui.py`
- `python filter_export_gui_streaming.py`

If GUI is unavailable, both apps fall back to console mode.

## How To Use

### Combine CSV (quick steps)
1. Open `combine_csv_gui.py`.
2. Click **Select input files** and choose your CSV files.
3. Choose output format (`csv` or `xlsx`).
4. Choose where to save output.
5. Start combine and wait for completion message.

### Filter & Export (quick steps)
1. Open `filter_export_gui_streaming.py`.
2. Click **Pick input file**.
3. Set filters you need (leave others empty).
4. Choose output format and destination.
5. Click **Run and export**.

Tip:
- For very large data, use **CSV output** for best performance.

## Main Functions Explained

- **Text filter**: keeps rows where selected column contains the given text.
- **Numeric range**: keeps rows between min and max (inclusive).
- **Date range**: keeps rows between `from` and `to` dates.
- **Remove duplicates**: drops repeated records (full row or selected key columns).
- **Trim spaces in text**: cleans extra spaces before filtering.

## Language Switching

In each GUI app, change language from the **Language** selector:
- `English`
- `Polski`

## Troubleshooting

- **Output file cannot be saved**
  - close the target file in Excel and run again.
- **Wrong characters in CSV**
  - app tries common encodings automatically; if still wrong, re-save source CSV as UTF-8 and retry.
- **Very slow processing**
  - prefer CSV input/output and use `filter_export_gui_streaming.py`.
- **No rows in output**
  - your filters are too strict; clear filters and test again.

## Notes

- `script_runner_history.db` is used by the streaming app to store run history.
- XLSX worksheet password is worksheet protection, not full file encryption.
iflow-mcp_foursquare-foursquaremcp 0.1.2
MCP Foursquare API server
Requires Python: >=3.10

# Python Server for Foursquare API

## Getting Started

### Prerequisites

Follow [getting started](../README.md) steps in the project guide.

### Python Environment

Ensure that you're running Python 3.10 or higher.

Next install `uv`, a fast python project manager:

```
curl -LsSf https://astral.sh/uv/install.sh | sh
```
or alternatively if you are on a mac you can install with homebrew
```
brew install uv
```
(if you already have it installed, make sure it is up to date)

### Clone the Repo

This project currently must be cloned locally and run with uv. Clone using:
```
git clone git@github.com:foursquare/fsq-ai-mcp.git
```
Then set up the project:
```
cd fsq-ai-mcp/fsq-server-python
uv venv
uv sync
```

### Configure MCP

You will need to update the `~/Library/Application\ Support/Claude/claude_desktop_config.json` configuration. If the file doesn't exit, you can copy paste `claude_desktop_config.json` from this folder into `Claude`.

Based on the example [claude_desktop_config.json](claude_desktop_config.json), update the values with 
correct local paths and your Service API key and add to `claude_desktop_config.json`. 

- `"command": "/path/to/uv/bin/uv"`,
- `"args": [...,"/path/to/git/clone/fsq-ai-mcp/fsq-server-python/", ...]`,
- `"FOURSQUARE_SERVICE_TOKEN": "YOUR FOURSQUARE SERVICE TOKEN"`

If the file already exists because you have other local MCP servers, just insert the `foursquare` 
sub-object into the existing config.

### Run MCP

Open Claude Desktop. You should see a hammer icon appear in the lower right part of the chat input that says "5 MCP tools available" (or more, if you have installed other MCP servers). There should not be any popup dialogs with errors. Verify by clicking on the hammer that 5 tools from `server: foursquare` are listed as available.

Finally test it out by asking Claude for place recommendations!
```
hi claude, can you suggest some good coffee shops near Prospect Heights, Brooklyn?
```
(It will ask you to allow access to running the foursquare tools)
Weban 0.1.0
A Web Application Framework For Python.
Requires Python: >=3.6

This is a framework that can make web applications in python, for example:
```
import Weban

app = Weban.Weban()

@app.route('/')
def home():
    return 'Welcome to Weban!'

@app.route('/about')
def about():
    return 'This is a simple web framework called Weban.'

if __name__ == '__main__':
    app.run()
```
Installation
```
pip install Weban
```