semvec/pypi-packages huggingface dataset:
sdss-cherno 1.2.1
SDSS guider actor
Requires Python: >=3.10

# cherno

![Versions](https://img.shields.io/badge/python->=3.10-blue)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Documentation Status](https://readthedocs.org/projects/sdss-cherno/badge/?version=latest)](https://sdss-cherno.readthedocs.io/en/latest/?badge=latest)
[![Tests Status](https://github.com/sdss/cherno/workflows/Test/badge.svg)](https://github.com/sdss/cherno/actions)
<!-- [![codecov](https://codecov.io/gh/sdss/cherno/branch/main/graph/badge.svg)](https://codecov.io/gh/sdss/cherno) -->


SDSS guider actor

## Installation

In general you should be able to install ``cherno`` by doing

```console
pip install sdss-cherno
```

To build from source, use

```console
git clone git@github.com:sdss/cherno
cd cherno
pip install .
```

## Development

`cherno` uses [uv](https://docs.astral.sh/uv/) for dependency management and packaging. To work with an editable install it's recommended that you setup `uv` and install `cherno` in a virtual environment by doing

```console
uv sync
```

### Style and type checking

This project uses the [black](https://github.com/psf/black) code style with 88-character line lengths for code and docstrings. It is recommended to use [ruff](https://docs.astral.sh/ruff/) for both linting and formatting and the `pyproject.toml` file contains the appropriate configuration. For Visual Studio Code, the following project file is compatible with the project configuration:

```json
{
  "[python]": {
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
      "source.fixAll": "explicit",
      "source.organizeImports.ruff": "explicit"
    },
    "editor.wordWrap": "off",
    "editor.tabSize": 4,
    "editor.defaultFormatter": "charliermarsh.ruff"
  },
  "[markdown]": {
    "editor.wordWrapColumn": 88
  },
  "[restructuredtext]": {
    "editor.wordWrapColumn": 88
  },
  "[json]": {
    "editor.quickSuggestions": {
      "strings": true
    },
    "editor.suggest.insertMode": "replace",
    "editor.formatOnSave": true,
    "editor.defaultFormatter": "esbenp.prettier-vscode",
    "editor.tabSize": 2
  },
  "[yaml]": {
    "editor.insertSpaces": true,
    "editor.formatOnSave": true,
    "editor.tabSize": 2,
    "editor.autoIndent": "advanced",
  },
  "prettier.tabWidth": 2,
  "editor.rulers": [88],
  "editor.wordWrapColumn": 88,
  "python.analysis.typeCheckingMode": "basic",
  "ruff.nativeServer": true
}
```

This assumes that the [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) and [Pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance) extensions are installed.
sdkFilms 0.0.2
SDK Python pour accéder à l’API MovieLens (Data Analysts/Data Scientists friendly)
Requires Python: >=3.13

# MovieLens SDK - `sdkFilms`

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/sdkFilms.svg)](https://badge.fury.io/py/sdkFilms)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

---

## Installation

```bash
pip install sdkFilms
```

---

## Configuration

```python
from sdkFilms import MovieClient, MovieConfig

# Configuration avec l’URL de votre API (Render ou locale)
config = MovieConfig(movie_base_url="https://film-api-3i06.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://film-api-3i06.onrender.com](https://film-api-3i06.onrender.com)
- PyPI : [https://pypi.org/project/sdkFilms](https://pypi.org/project/sdkFilms)# MovieLens SDK - `sdkFilms`
mind-t-gap 1.0.2
Mind the Gap is an algorithm for detecting gaps in building footprints datasets 
Requires Python: <4.0,>=3.10

# Mind the Gap

Mind the Gap is an algorithm for detecting gaps in building footprints datasets, with a preference for finding the rectangular-shaped gaps caused by missing imagery tiles. It works best on country-sized datasets or smaller, or larger datasets divided into smaller chunks.

## Getting started

A Dockerfile and requirements are included, and can help you set up a suitable container. 

Alternatively, you can use poetry by running:
`pip install poetry`
and then
`poetry install`
from the root directory of the repository.

The core of the algorithm is found in mind_the_gap.py, and you can use `mind_the_gap` function to directly run the algorith. For an easier start, you can use the `auto_tune` module, which will free you from having to guess and check all the parameters. This will do a decent job of tuning all the paramters, but you may still need to tweak things. The default parameters in the `Region.run` method work generally well but may need a little tweaking. `Region.run_parallel` is advantageous for large datasets as it allows for parallel processing.

### Inputs

Mind the Gap requires two inputs: building footprints (or just their centroids) and a boundary to the aoi. These are best handled using GeoPandas

### Outputs

Gaps will be stored as a GeoDataFrame of the Region object once `Region.run` has ran.
pwdhash.py 0.2.0
Python Stanford PwdHash implementation
Requires Python: >=3.8
Keywords: pwdhash

This is an implementation of Stanford PwdHash algorithm [1] based on JavaScript
version from https://www.pwdhash.com/pwdhash.js.

Original JavaScript code Copyright notice is:

    Copyright (C) Stanford University 2004-2006
    Author: Collin Jackson
    Other Contributors: Dan Boneh, John Mitchell, Nick Miyake, and Blake Ross
    Distributed under the BSD License

[1] Ross, B., Jackson, C., Miyake, N., Boneh, D., & Mitchell, J. C. (2005,
August). Stronger Password Authentication Using Browser Extensions. In Usenix
security (pp. 17-32).
pydictnest 0.2.1
A small package, which provides functions for working with nested dictionaries.
Requires Python: >=3.9

# Pydictnest

Nothing fancy. Just a lightweight Python package for some basic work with nested dictionaries. Provides functions to set, get, check, flatten, and unflatten values in arbitrarily deep mappings, plus iteration over nested structures.

* **Get and Set** Get and set values based on a list of keys in nested mappings
* **Check** whether a nested path exists.
* **Iterate** over all (path, value) pairs in a nested mapping.
* **Flatten** a nested dict to a single-level dict with concatenated keys.
* **Unflatten** a flat dict back into a nested structure.

## Installation

Install via pip with

```bash
pip install pydictnest
```

or from the newest source with

```bash
pip install git+https://github.com/MSallermann/pydictnest.git
```

You can also clone the repo and install locally

```bash
git clone https://github.com/MSallermann/pydictnest.git
cd pydictnest
pip install .
```

## Usage

Should be quite obvious. Here is a small writeup (mostly take from the unit test):

```python
from pydictnest import (
    set_nested, get_nested, has_nested,
    items_nested, flatten_dict, unflatten_dict
)

# Start with an empty dict
data = {}
set_nested(data, ['a', 'b', 'c'], 123)
# data == {'a': {'b': {'c': 123}}}

# Retrieve values
val = get_nested(data, ['a', 'b', 'c'])        # 123
missing = get_nested(data, ['x', 'y'], default=0) # 0

# Check existence
assert has_nested(data, ['a', 'b', 'c'])
assert not has_nested(data, ['a', 'z'])

# Iterate over all leaf nodes
for path, value in items_nested(data):
    print(path, value)
    # ['a', 'b', 'c'] 123

# Flatten and unflatten
nested = {'x': {'y': 1, 'z': {'w': 2}}, 'u': 3}
flat = flatten_dict(nested, sep='.')
# flat == {'x.y': 1, 'x.z.w': 2, 'u': 3}

roundtrip = unflatten_dict(flat, sep='.')
# roundtrip == nested
```

## API Reference

### `set_nested(dictionary, keys, value, subdict_factory=dict)`

Set a value at the specified nested key-path, creating sub-dicts with `subdict_factory`.

### `get_nested(dictionary, keys, default=None)`

Retrieve a deep value, returning `default` if any key is missing.

### `has_nested(dictionary, keys)`

Return `True` if a deep key-path exists, otherwise `False`.

### `items_nested(d, subkeys=[])`

Yields `(key_path, value)` tuples for each leaf node in a nested mapping.

### `keys_nested(d)`

Yields `key_path` for each leaf node in a nested mapping.

### `values_nested(d)`

Yields `value` for each leaf node in a nested mapping.

### `flatten_dict(dictionary, sep='.', dict_factory=dict)`

Convert a nested dict into a flat dict by joining keys with `sep`.

### `unflatten_dict(dictionary, sep='.', dict_factory=dict)`

Reconstruct a nested mapping from a flat dict with joined keys.

## Running Tests

This project uses pytest. To run the test suite:

```bash
pytest
```

## Rationale

Not much of a rationale really. Needed this for a small project and wanted something lightweight.

## Contributing

Make a PR if you want to contribute anything.

## License

This project is licensed under the MIT License. See [LICENSE](LICENSE) for details.
AgentX-Dev 0.1.1
A lightweight LLM agent framework with standard and structured tool support use, prompt management, and support for OpenAI.
Requires Python: >=3.8


# 🧠 Bruce Agent

**AgentX** is a lightweight, extensible agentic framework for building custom LLM agents with structured tool use, prompt templates, and integration with OpenAI and Gemini models.

## 🚀 Features

- 🔁 Custom reasoning loop (`AgentRunner`)
- 🧩 Structured tool execution (Pydantic-based)
- 💬 Prompt templating and management
- 🔌 LLM-agnostic: supports **OpenAI function calling** and **Google Gemini**
- 🪄 Easy-to-use API for building agents

## 📦 Installation

published to PyPI:

```sh
pip install AgentX-Dev
```

## Example use

```python
from AgentXL import AgentRunner, AgentType,ChatModel
from pydantic import BaseModel
from AgentXL.Tools import StructuredTool
# Define a sample tool
class MultiplyTool(StructuredTool):
    name = "multiply"
    description = "Multiply two numbers"

    class Schema(BaseModel):
        a: int
        b: int

    def run(self, a: int, b: int) -> int:
        return a * b

# Create chat model and agent
ReAct=AgentType.ReAct
chat_model = ChatModel.GPT(model="gpt-4", temperature=0.7)
tools = [MultiplyTool()]
agent = AgentRunner(model=chat_model,Agent=ReAct, tools=tools)

response = agent.Initialize("What is 5 times 8?")
print(response.content)



```

``` bruce_framework/
├── src/
│   └── bruce_framework/
│       ├── __init__.py
│       ├── agent/
│       │   ├── __init__.py
│       │   └── agent.py
│       ├── runner/
│       │   ├── __init__.py
│       │   └── agent_run.py
│       └── chatmodel.py
├── README.md
├── LICENSE
└── pyproject.toml

```

## 📚 Documentation (Coming Soon)
### More tutorials, tool examples, and structured prompting guides coming soon.

## 🧑‍💻 Author
#### Bruce-Arhin Shadrach
#### 📧 brucearhin098@gmail.com
#### 🌐 GitHub

📝 License
MIT License
pycalculator-aniket 0.1.0
A full-featured Python calculator package
Requires Python: >=3.6

# PyCalculator

A fully functional Python calculator supporting:

- Basic operations: add, subtract, multiply, divide
- Advanced math: power, modulus, factorial, square root
- Trigonometry: sin, cos, tan (in degrees)
- Constants: PI, E

## Install

```bash
pip install pycalculator