semvec/pypi-packages huggingface dataset:
splitcache 0.0.1
A type of split cache for number computation problems, caching low numbers and optionally some higher ones.
Requires Python: >=3.9
Keywords: math, smooth

# splitcache

A tiny “two-tier” caching decorator for **integer-keyed** functions:

* **Small inputs** (≤ `cutoff`) are cached entirely using `functools.cache`
* **Large inputs** (> `cutoff`) are either:

  * **not cached** (default when `lru_size` is `None`/`0`), or
  * cached with a bounded **LRU** using `functools.lru_cache(maxsize=...)` 

This is useful when you have hot paths that repeatedly hit a dense “small” region, 
  but also wander into huge integers (e.g., > $10^{20}$) where unbounded caching would explode memory.

## Installation

```bash
pip install splitcache
```

---

## Quick start

```python
from splitcache import split_cache

@split_cache(cutoff=10**9, lru_size=10**6)
def nextprime(p: int) -> int:
    ...
```

Behavior:

* If `p <= 10**9`: cached completely
* If `p > 10**9`: cached in an LRU of size $10^6$

To disable caching above the cutoff:

```python
@split_cache(cutoff=10**9, lru_size=None)
def nextprime(p: int) -> int:
    ...
```

When `lru_size` is `None` (or `0`), values above the cutoff are recomputed every time. 

### Note about memory size

For a method with a signature `(int, ) -> int` with numbers below $10^{45}$ or so, each cache entry 
  below the cutoff is measured at approximately 130 bytes, 
    and above the cutoff each cache entry is measured at approximately 190 bytes.
  
If any number below $10^9$ is provided to this method, that would be a cache size of over 120GB in memory.
  If restricted to just primes: there are approximately 48 million primes below $10^9$, 
    which would be a cache size of nearly 6GB. The primes can be further restricted, eg primes $\equiv 1 \bmod 4$.

The point of all this is to express the importance of being aware of the **potential size of the caches you are creating**.

---

## API

### `split_cache`

* `cutoff` (**required**): cache all calls where `cutoff_value(*args, **kwargs) <= cutoff`. Must be `> 0`. 
* `lru_size` (**optional**): LRU size for calls above the cutoff.

  * `None` or `0` ⇒ no cache above cutoff 
  * `> 0` ⇒ `functools.lru_cache(maxsize=lru_size)` above cutoff 

* `cutoff_value` (**optional**): function that chooses which numeric value to compare against `cutoff`. Defaults to `default_cutoff_value`.

#### Cache controls

`split_cache` exposes a few helpers on the wrapped function:

* `fn.small_cache_clear()`: clear the unbounded “small” cache 
* `fn.big_cache_clear()`: clear the “big” LRU cache if enabled 
* `fn.small_cache_info` / `fn.big_cache_info`: cache info functions when available 

Example:

```python
next_prime_1mod4.small_cache_clear()
next_prime_1mod4.big_cache_clear()

# If big cache is enabled:
info = next_prime_1mod4.big_cache_info()
print(info)
```
sqlfluffrs 4.0.4
The SQL Linter for Humans
Requires Python: >=3.9

# SQLFluff-rs

This package is an optional installation for [SQLFluff](https://github.com/sqlfluff/sqlfluff) and is **not** intended to be used as a standalone linting solution.

## Purpose

SQLFluff-rs serves as a Rust-based component that can be integrated with the main SQLFluff package. It is currently in development and should be considered experimental.

## Installation

This package is automatically handled when installing SQLFluff with the appropriate optional dependencies. Direct installation or standalone usage is not supported.

To install from pip:
```sh
pip install sqlfluff[rs]
```

## Development Status

This is a supplementary component and is not meant to replace or function independently of the main SQLFluff package. For SQL linting, please use the main [SQLFluff](https://github.com/sqlfluff/sqlfluff) package.
collectors-channel-cli 1.8.3
Monitor your favorite shops in search of disc titles launches and promotions
Requires Python: <4.0,>=3.10

# collectors-channel-cli

Built with ❤️ using [Typer](https://typer.tiangolo.com)

## How to use it

Create a properties file at `$HOME/.collectors/my.properties` using this as an example:

```
# MongoDB
MONGO_URL=mongodb+srv://user:password@url/database
```

Or pass `--props` to the CLI with the file location.

Check out the project at GitLab: https://gitlab.com/collectors-channel.
aiocua 0.0.0a0
A Simple Python CUA (Computer Use Agent) Solution
Requires Python: >=3.10

# aiocua

A Simple Python CUA (Computer Use Agent) Solution

## Status

This project is in **Technical Preview**.
- APIs are subject to change.
- Not ready for production use.

## Supported Platforms

- Windows
- macOS

## Installation

```bash
pip install aiocua
```

## Quick Start

```python
import asyncio
from aiocua import CuaOperator

async def main():
    operator = CuaOperator()

    # Get screen dimensions
    width, height = await operator.dimensions()

    # Take a screenshot (returns base64-encoded string)
    screenshot_base64 = await operator.screenshot()

    # Get monitor info
    monitors = await operator.monitors()
    for m in monitors:
        print(f"Monitor {m.id}: {m.width}x{m.height} (scale={m.scale}, primary={m.primary})")

if __name__ == "__main__":
    asyncio.run(main())
```

## API Reference

All methods on `CuaOperator` are async.

### Mouse

| Method | Description |
| --- | --- |
| `move(x, y)` | Move the cursor to the given coordinates. |
| `click(button="left", x=None, y=None)` | Click a mouse button. Supported buttons: `left`, `right`, `wheel`, `back`, `forward`. If `x`/`y` are provided, moves first. |
| `double_click(x=None, y=None)` | Double-click at the current or given position. |
| `drag(path)` | Drag along a list of `(x, y)` coordinates. |
| `scroll(scroll_x, scroll_y, x=None, y=None)` | Scroll by the given amounts. Optionally move to `x`/`y` first. |

### Keyboard

| Method | Description |
| --- | --- |
| `key_press(keys)` | Press one or more keys simultaneously (e.g. `["CTRL", "C"]`). Keys are automatically remapped per platform. |
| `type_text(text)` | Type a string of text, including Unicode characters. |

### Screen

| Method | Description |
| --- | --- |
| `screenshot()` | Capture the screen and return it as a base64-encoded PNG string. |
| `dimensions()` | Return the primary monitor resolution as `(width, height)`. |
| `monitors()` | Return a list of `MonitorMetadata` for each connected display. |

### Other

| Method | Description |
| --- | --- |
| `wait()` | Wait for any pending operations to complete. |

## Testing

```bash
pip install aiocua[test]
pytest
```