semvec/pypi-packages huggingface dataset:
polyhex 0.1.3
A small example package
Requires Python: >=3.11

# Project Title

[![License: Apache](https://img.shields.io/badge/License-Apache-yellow.svg)](https://opensource.org/license/apache-2-0)

Polyhex is a Python library to easily create polyhexes from regular hexagons and export their underlying graph structure to deep-learning frameworks. 

## ✨ About The Project

Polyhex aims to be at the interface between a natural creation of polyhexes and a reliable graph representation of the polyhexes' attributes.

It was designed for the Material Science and Reinforcement Learning communities, but can surely be used for other purposes. 

**Key Features:**
* **Beginner friendly.** Create a polyhex, from <br>
▶️ A list of hexagons or a number of hexagons <br>
▶️ Predefined shapes with flexible dimensions <br>
* **Modular.** Record a polyhex's graph structure: record the edges, the vertices, the hexagons and the border of a polyhex in a simple call.
* **Built for Machine-Learning.** Polyhex offers an off-the-shelf export of your graphs to [PyGeom](https://pytorch-geometric.readthedocs.io/en/latest/), a popular framework for deep-learning on graphs. 

## 🚀 Getting Started

Installing `polyhex` should be as easy as
```
pip install polyhex
```
You can then have a look at the `examples` folder.

## 📓✏️ Documentation

Work in progress

## 🗺️ Roadmap

- [x] Ability to create a polyhex and export it to PyGeom's data format.
- [ ] Implementation of games rules and scoring, like [Cascadia](https://en.wikipedia.org/wiki/Cascadia_(board_game))
- [ ] Game assets
- [ ] C++ routines
- [ ] [OpenSpiel](https://openspiel.readthedocs.io/en/latest/) binders

## 🤝 Contributing

Any contribution and feedback is **greatly appreciated**.

If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".

1.  Fork the Project
2.  Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
3.  Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
4.  Push to the Branch (`git push origin feature/AmazingFeature`)
5.  Open a Pull Request

## 📜 License

Distributed under the Apache License. See `LICENSE` for more information.

## 📧 Contact

Contact the authors directly at: emilienvalat@gmail.com

## 🙏 Acknowledgments

Huge thanks to Amit Patel (Red Blob Games) for all the resources about hexagons.

* [Red Blob Games](https://www.redblobgames.com/)
llm-multi 0.1.0
A plugin for LLM that combines file bundling and LLM mapping capabilities
Requires Python: >=3.12

# llm-multi

A plugin for [LLM](https://llm.datasette.io/) that combines file bundling and LLM mapping capabilities into two complementary commands: `llm archive` and `llm map`.

## Commands

### `llm archive`

Bundle files into JSONL format or extract files from a JSONL archive:

```bash
llm archive [files...]
```

**Options:**

- `--create` - Create an archive from files (default)
- `--extract` - Extract files from an archive (exclusive with --create)
- `--basename` - For create: strip path and use only filename. For extract: ignore paths, write only filenames to current directory (last copy wins on collisions)
- `--basedir <str>` - For create and extract: strip this prefix from paths, refuse to process files without this prefix, printing warnings instead
- `--format` - Output format: `jsonl`, `json`, `jsonarr`, `xml`, `xmlish`

### `llm map`

Apply an LLM prompt to each item in a JSON structure or repeated content:

```bash
llm map data.jsonl "Summarize this: {item}"
```

The item will be inserted at the first `{item}` in the prompt. If no `{item}` exists, it will be inserted at the end, as `\n{item}`.

**Options:**

- `--model, -m` - Model to use (default: gpt-4o-mini)
- `--temperature, -t` - Temperature for generation (default: 0.0)
- `--tokens` - Max tokens (default: 15000)
- `--concurrency, -c` - Number of concurrent requests (default: 16)
- `--output, -o` - Write output to file
- `--branches` - Repeat content this many times, prefix the base filename with `{i}_`
- `--content` - Include original content in output (incompatible with `--json`/`--jsonarr` output formats)
- `--format` - Set both input and output format: `jsonl` (default), `json`, `jsonarr`
- `--iformat` - Input format: `jsonl` (default), `json`, `jsonarr`
- `--oformat` - Output format: `jsonl` (default), `json`, `jsonarr`

### Format descriptions

JSON based formats, useful for piping into `map` -

- `jsonl`: One JSON object per line with `path` and `content` fields
- `json`: Single JSON object with filenames as keys and content as values
- `jsonarr`: JSON array containing only content (no filenames)

XML based formats, useful to pass an entire archive to an LLM (`llm archive ... | llm prompt ...`):

- `xml`: XML elements with properly escaped content (e.g., `<foo.html>&lt;em&gt;escaped&lt;/em&gt;</foo.html>`)
- `xmlish`: XML elements with raw content, no escaping (e.g., `<foo.html><em>preserved</em></foo.html>`)

## Workflow Example

Process multiple files in parallel:

```bash
llm archive file1.py file2.js | llm map - "What programming language is this?"
```

Process and extract:

```bash
llm archive file1.py file2.js | llm map - "Add --reticulate-splines option" | llm archive --extract
```

Process multiple files with one call:

```bash
llm archive --format xmlish file1.py file2.js | llm prompt "Is the algorithm identical in both files"
```
niebla 0.0.18
Python package to compute the EBL with a forward folding approach.
Requires Python: <4,>=3.7
Keywords: 'extragalactic background light', 'EBL', 'gamma-ray', 'opacity'

niebla
========

Python package to compute the EBL with a forward folding approach.

![logo](src/niebla/data/logo_small.png)

Prerequisites
-------------

Python 3.5 or higher and the following packages: 
  
  - numpy 
  - scipy
  - astropy
  - matplotlib

An extra library is required to calculate the intensity of the
intrahalo light. However, implementing it is not trivial in a
virtual environment, I would not recommend to get stuck trying to
implement it if it is not needed:

- hmf

Installation:
------------

You can use pip to install the package: 

    pip install niebla

Example scripts and notebooks are provided on the github page in the
scripts/ and notebooks/ folder, https://github.com/saraporrasbedmar/niebla

License
-------
niebla is distributed under the modified BSD License.
rule-engine-core 0.0.2
A rule engine core library for Python.
Requires Python: >=3.10

## Build
-> create venv and activate
(install meta)
-> pip install setuptools wheel twine
(build package)
-> python setup.py sdist bdist_wheel
-> pip install dist/rule-engine-core-0.1.0-py3-none-any.whl
(Publish to pypi)
-> pip install twine
-> twine upload dist/*

### Docker
-> `psql --username=$POSTGRES_USER -d $POSTGRES_DB`
fmscraper 0.1.4
Scraper for FotMob matches
Requires Python: >=3.8

# FMScraper

FMScraper is a web scraping tool that uses requests for HTTP handling. This repository enables efficient extraction of data from [FotMob](https://www.fotmob.com/).

Inspired by: [Webscraper-PremData](https://github.com/deanpatel2/Webscraper-PremData/tree/main) and [scraping-football-sites](https://github.com/axelbol/scraping-football-sites/tree/main)

## Overview
FMScraper is a web scraping tool designed to extract comprehensive football match statistics and data from [FotMob](https://www.fotmob.com/), a popular platform for football statistics, live scores, and match analysis. The tool automates the data collection process, handling JavaScript-driven content and dynamic page layouts that traditional scraping methods cannot access.

## Features

- Scrapes match info from FotMob
- Extracts data for specific leagues, seasons, and matchweeks
- Provides easily exportable or processable match data for further analysis.

## Requirements

- Python 3.8+
- [requests](https://pypi.org/project/requests/)

## Disclaimer
For educational and research purposes only. Do not use it commercially.

## Installation

1. Clone the repository:
```bash
git clone https://github.com/MieszkoPugowski/FMScraper.git
cd FMScraper
```

2. Install using pip:
```bash
pip install fmscraper
```
## Example usage

```python
from fmscraper import FotMobStats 

bundesliga_stats = FotMobStats(league_id=38,season="2024-2025")
game_ids = bundesliga_stats.get_matches_list(team_or_all='all')

first_game = game_ids[0]

# List of all shots in a game
shotlist = bundesliga_stats.get_match_details(match_id=first_game,
                                                content_type="shotmap")
print(shotlist)
```

## Contributing
Contributions are welcome! Please feel free to submit a pull request or open an issue.
physical-spline 0.1.1
Physical spline designer and evaluator
Requires Python: >=3.8

# physical_spline
Library to fit a 2D trajectory of a vehicle. Detailed explanation in the paper "Physical spline for denoising object trajectory data by combining splines, ML feature regression and model knowledge"

You can initialise the spline designer, spline designer 2D or a heading spline designer. Add different measurements of position, velocities, acceleration and heading. You can also add different types of regularization in order to prefer solutions with lower accelerations, lower acceleration changes and so on. After adding everything you can call get spline to get callable functions. 

Check out the example_notebook.ipynb

## 📦 Installation

You can install `physical-spline` from PyPI:

```bash
pip install physical-spline