semvec/pypi-packages huggingface dataset:
juancobo6-marco-polo-timeseries 0.1.1
Python implementation of the game of marco polo with time dependencies.
Requires Python: >=3.12

# Marco Polo

A Python implementation of the classic game of Marco Polo.

## Description

This library provides a simple Python function that implements the Marco Polo game logic. When you call "Marco", it responds with "Polo"!

## Installation

Install the package using pip:

```bash
pip install juancobo6-marco-polo-timeseries
```

Or if you're using uv:

```bash
uv add juancobo6-marco-polo-timeseries
```

## Requirements

- Python 3.12 or higher
- pandas >= 2.3.1

## Usage

```python
from juancobo6_marco_polo_timeseries import marco_polo

# Basic usage
result = marco_polo("Marco", pd.Timestamp("2025-01-01 11:00:00"))
print(result)  # Output: "Polo"

# Other inputs return None
result = marco_polo("Hello", pd.Timestamp("2025-01-01 11:00:00"))
print(result)  # Output: None
```

## API Reference

### `marco_polo(name: str, time: pd.Timestamp) -> str | None`

Returns "Polo" if the name is "Marco", otherwise returns None.

**Parameters:**
- `name` (str): The name to check
- `time` (pd.Timestamp): The time to check

**Returns:**
- `str | None`: "Polo" if the name is "Marco", otherwise None

**Example:**
```python
from juancobo6_marco_polo_timeseries import marco_polo

assert marco_polo("Marco", pd.Timestamp("2025-01-01 11:00:00")) == "Polo"
assert marco_polo("Polo", pd.Timestamp("2025-01-01 11:00:00")) is None
assert marco_polo("John", pd.Timestamp("2025-01-01 11:00:00")) is None
```

## Development

This project uses:
- **Build system**: Hatchling
- **Dependencies**: pandas
- **Type hints**: Fully typed with py.typed marker

## License

This project is open source. See the license file for details.

## Author

- **JuanCobo** - juan.cobo@baobabsoluciones.es

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
juancobo6-marco-polo 0.2.1
Python implementation of the game of marco polo.
Requires Python: >=3.12

# Marco Polo

A Python implementation of the classic game of Marco Polo.

## Description

This library provides a simple Python function that implements the Marco Polo game logic. When you call "Marco", it responds with "Polo"!

## Installation

Install the package using pip:

```bash
pip install juancobo6-marco-polo
```

Or if you're using uv:

```bash
uv add juancobo6-marco-polo
```

## Requirements

- Python 3.12 or higher
- pandas >= 2.3.1

## Usage

```python
from juancobo6_marco_polo import marco_polo

# Basic usage
result = marco_polo("Marco")
print(result)  # Output: "Polo"

# Other inputs return None
result = marco_polo("Hello")
print(result)  # Output: None
```

## API Reference

### `marco_polo(name: str) -> str | None`

Returns "Polo" if the name is "Marco", otherwise returns None.

**Parameters:**
- `name` (str): The name to check

**Returns:**
- `str | None`: "Polo" if the name is "Marco", otherwise None

**Example:**
```python
from marco_polo import marco_polo

assert marco_polo("Marco") == "Polo"
assert marco_polo("Polo") is None
assert marco_polo("John") is None
```

## Development

This project uses:
- **Build system**: Hatchling
- **Dependencies**: pandas
- **Type hints**: Fully typed with py.typed marker

## License

This project is open source. See the license file for details.

## Author

- **JuanCobo** - juan.cobo@baobabsoluciones.es

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
jaxkd 0.1.2
Minimal JAX implementation of k-nearest neighbors using a k-d tree.
Requires Python: >=3.10

# JAX *k*-D
Find *k*-nearest neighbors using a *k*-d tree in JAX!

This is an implementation of two GPU-friendly tree algorithms [[1](https://arxiv.org/abs/2211.00120), [2](https://arxiv.org/abs/2210.12859)] using only JAX primitives. The core `build_tree`, `query_neighbors`, and `count_neighbors` operations are compatible with JIT and automatic differentiation. They are reasonably fast when vectorized on GPU/TPU, but will be slower than SciPy's `KDTree` on CPU. For small problems where a pairwise distance matrix fits in memory, check whether brute force is faster (see `jaxkd.extras`).

If query speed is the performance bottleneck and you only use Nvidia GPUs, the [jaxkd-cuda](https://github.com/dodgebc/jaxkd-cuda) extension can be installed as an optional dependency (see below) to enable more efficient tree operations, particularly traversal. The intention is to match the behavior of the pure-JAX version and integrate seamlessly with the `cuda=True` argument. Building the extension will require CMake and NVCC installed on your system. There may be some rough edges and the internal workings may change.

For even more power, flexibility, and speed, consider binding the original [cudaKDTree](https://github.com/ingowald/cudaKDTree) library to JAX. Functionality will be different as described in the [jaxkd-cuda](https://github.com/dodgebc/jaxkd-cuda) repository, where example bindings can also be found and modified to your needs. Be warned that these will not spark joy. The advantage of the pure-JAX version is that it is portable and easy to use, with the ability to scale up to larger problems without the complexity of integrating non-JAX libraries. Try it out!

<a target="_blank" href="https://colab.research.google.com/github/dodgebc/jaxkd/blob/main/demo.ipynb">
  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
</a>


## Usage

```python
import jax
import jaxkd as jk

kp, kq = jax.random.split(jax.random.key(83))
points = jax.random.normal(kp, shape=(100_000, 3))
queries = jax.random.normal(kq, shape=(10_000, 3))

tree = jk.build_tree(points)
counts = jk.count_neighbors(tree, queries, r=0.1)
neighbors, distances = jk.query_neighbors(tree, queries, k=10)
```

There is also a one-step `build_and_query` for convenience, and all these functions accept `cuda=True` to use the CUDA extension if it is installed.

Additional helpful functionality can be found in `jaxkd.extras`.
- `query_neighbors_pairwise` and `count_neighbors_pairwise` for brute-force neighbor searches
- `k_means` for clustering using *k*-means++ initialization, thanks to [@NeilGirdhar](https://github.com/NeilGirdhar) for contributions

Suggestions and contributions for other extras are always welcome!

## Installation
To install, use `pip`. The only dependency is `jax`.
```
python -m pip install jaxkd
```
Or with the CUDA extension.
```
python -m pip install jaxkd[cuda]
```
Or just grab `tree.py`.
ubootenv 0.1.1
U-Boot environment setter and getter from the C library libubootenv
Requires Python: >=3.9

# UBootEnv package
This package offers a Python implementation of the well-known `fw_setenv` and `fw_getenv` commands, based on the C library *libubootenv*.

## Features
- Read and modify variables in the U-Boot environment
- Erase variable values
- Shadow writing to minimize write cycles

## Usage
```python
from ubootenv import UBootEnv

uenv = UBootEnv()
# Or specify a custom config path
uenv = UBootEnv("/etc/fw_env.config")

uenv.open()
var = uenv.get("foo")
print(var) # => None

uenv.set("foo", "bar")
var = uenv.get("foo")
print(var) # => b'bar'

# Use shadow writing, get method returns the shadow value
uenv.shadow("foo", "foo")
var = uenv.get("foo")
print(var) # => b'foo'

# Commit shadow values to disk
uenv.store()
uenv.close()

```