semvec/pypi-packages huggingface dataset:
ghoster-py 1.0.3
A powerful stealth automation library for Playwright designed to mimic human behavior and bypass advanced bot detection systems.
Requires Python: >=3.8

# 👻 Ghoster for Python

This is the Python version of the Ghoster stealth automation library.

## Installation

```bash
pip install ghoster-py
```

Then, install the necessary browsers:

```bash
playwright install
```

## Usage

*Full usage examples will be added soon.*
filesinfo 0.1.2
File extension metadata and platform selection utilities
Requires Python: >=3.9
Keywords: file, extension, metadata, sandbox

# FilesInfo

FilesInfo is a Python toolkit for mapping file extensions to rich metadata and recommended execution platforms. It ships with an extensive extension catalog, powerful lookup helpers, and a convenient CLI for exploring the data.

## Installation

Clone the repository and install the package in editable mode (or publish to PyPI/TestPyPI and install from there):

```bash
pip install .
```

The installation exposes the `filesinfo` command-line tool automatically.

## Command-Line Usage

```bash
# Inspect platform recommendations for file names
filesinfo payload.exe archive.tar.gz

# List extensions supported on specific platforms
filesinfo --platform windows --platform linux --include-cross-platform

# Show detailed metadata for each match
filesinfo --platform macos --details

# Review dataset validation warnings
filesinfo --show-dataset-issues
```

For backwards compatibility the legacy `run_demo.py` script simply forwards to the same CLI entry point.

## Python API Example

```python
from filesinfo import file_info_expert, get_extensions_for_platform

print(file_info_expert("payload.exe"))
# ['windows']

print(get_extensions_for_platform("linux", include_cross_platform=False)[:10])
```

## Updating the Dataset

Regenerate the MIME-driven extension dataset whenever you want the latest upstream metadata:

```bash
python3 scripts/update_extension_dataset.py
```

The command writes a fresh `filesinfo/data/external_extensions.json` file that is packaged with the library.

## Tests

```bash
python3 -m unittest
```

The test suite verifies the core lookups, platform alias behaviour, and integration with the external dataset.
bunduk-mcp 0.2.1
MCP server for Chinese history study: BiogRef/TextRef CSVs, CBDB/TGAZ enrichments
Requires Python: >=3.10
Keywords: mcp, chinese-history, cbdb, chgis, biographical-data, textual-references

# Bunduk MCP — Chinese History Study Server

MCP server exposing BiogRef/TextRef CSVs as resources and tools for Chinese history study, with optional live CBDB and CHGIS TGAZ enrichments.

## Quick Start

- Requirements: Python 3.10+
- Data: CSVs are expected under `references/` (already present in this repo).

Install (editable):

```
pip install -e .
```

Run (stdio transport):

```
mcp-chinese-history
```

or

```
python -m bunduk_mcp.server
```

This starts an MCP stdio server suitable for MCP-compatible clients.

## Implemented

- Resources: `biogref://{source}/person/{person_id}`, `textref://{source}/work/{primary_id}`
- Tools: person.search, person.get, crosswalk.person, text.search
- Entity resolution: entity.resolve_people, entity.resolve_books
- Place lookup (TGAZ): place.lookup (online; safe fallback if offline)
- CBDB API thin wrapper: cbdb.person (online; safe fallback if offline)
- Disambiguation: disambig.person (rule-based scoring)
- HTML builder: html.build_annotations (deterministic wrapping with tooltips)
- Dataset management (scaffold): dataset.list, dataset.reload (update/sync stubbed)

## Configuration

- `BUNDUK_MCP_REFERENCES_DIR` — override path to CSVs (default: `references`)
- `BUNDUK_HTTP_TIMEOUT` — HTTP timeout seconds (default: 10)

## Notes

- Network-enriched tools return clear errors when offline; the rest work fully offline using local CSV files.
- CSV BOM is handled; fields are normalized but values preserve Chinese text.
- See `MCP_PLAN.md` for design, scenarios, and roadmap.
bnum 0.3
Bounded numbers
Requires Python: >=3.11

Bounded Numbers
===============

Bounded numbers were first conceptualized by Chris Crawford, and
introduced in his book, `Chris Crawford on Interactive Storytelling`_.

.. _Chris Crawford on Interactive Storytelling: https://www.amazon.com/Chris-Crawford-Interactive-Storytelling-ebook/dp/B00AU3JRTC

The basic idea of bounded numbers is to force the real number range
into the bounded range of ``-1.0 < b < 1.0``, with limits at -1.0 and 1.0,
with the whole range observing a bell curve distribution.

A real number can be converted to a bounded number like so::

  def _bind(unbounded_number: Union[float, int]) -> float:
      """Transform an unbounded number into an bounded number."""
      if unbounded_number > 0.0:
          return 1.0 - (1.0 / (1.0 + unbounded_number))
      else:
          return (1.0 / (1.0 - unbounded_number)) - 1.0

A bounded number may be transformed back to an unbounded number (with
rounding errors) like so::

  def _unbind(bounded_number: float) -> float:
    """Transform a bounded number into an unbounded number."""
    if bounded_number > 0.0:
        return (1.0 / (1.0 - bounded_number)) - 1.0
    else:
        return 1.0 - (1.0 / (1.0 + bounded_number))


Note that in the world of bounded numbers, from ten on up, the number
of places beyond 1 *roughly* corresponds to the number of nines.  That
is:

- 10 ~= 0.9
- 100 ~= 0.99
- 1000 ~= 0.999
- etc.

Note also that the journey from unbounded to bounded will result in
rounding errors.  The larger the unbounded number, the larger the
round-trip deviation.

Instantiating
-------------

Use the ``bnum(x)`` constructor (or its alias, ``b(x)``) to make a
bounded number from a float in the range ``-1.0 < x < 1.0``.

Use ``bind(x)`` to bind an arbitrary real number.


Blending, Amplifying, Suppressing
---------------------------------

Bounded numbers may be manipulated using the unique ``blend()``
function, which combines two bounded numbers with an optional
weight. Without a weight, ``blend(x, y)`` finds the midpoint between
``x`` and ``y``. A non-zero weight pushes the midpoint up or down
accordingly.

The ``bnum`` type also has three blending shortcuts:

- ``x.blend(y, weight=0.0)``: equivalent of ``blend(x, y, weight)``.

- ``x.amplify(weight=0.0)``: scale ``x`` away from 0.

- ``x.suppress(weight=0.0)``: scale ``x`` towards 0.
bdkpython 2.2.0
The Python language bindings for the Bitcoin Development Kit
Requires Python: >=3.10
Keywords: bitcoin, bdk, wallet, ffi, rust

# bdkpython

The Python language bindings for the [bitcoindevkit](https://github.com/bitcoindevkit).

See the [package on PyPI](https://pypi.org/project/bdkpython/).

# Working with the submodule

This repository uses the bdk-ffi repository as a git submodule. Here are useful tips for working with the submodule:

1. When initially cloning the repo, the `bdk-ffi` submodule will be empty locally. You can intitiate/populate the directory by using the `just submodule-init` command.
2. If you make local changes to the `bdk-ffi` directory while developing and want to hard delete all changes and return to the exact committed version hash of the bdk-ffi repo, use the `just submodule-reset` command.

## Local Testing and Usage

1. Start a Python virtual environment
2. Run one of the build script
3. Create the wheel
4. Install the library
5. Run the tests

```sh
source .localpythonenv/bin/activate

bash scripts/generate-macos-arm64.sh

python3 -m build --wheel --outdir dist --verbose 

pip3 install ./dist/bdkpython-<yourversion>.whl --force-reinstall

python3 -m unittest --verbose
```

## Build HTML API Documentation (Optional)

6. Generate docs
7. Build HTML Documentation

```sh
python3 ./docs/generate_docs.py

python3 -m sphinx -b html -W --keep-going -v docs/source docs/_build/html
```
pyd2d 0.2.0
A Python wrapper for the Windows Direct2D and DirectWrite APIs
Requires Python: >=3.9

# pyD2D - A Python wrapper for the Windows Direct2D API

pyD2D is a Python wrapper for the Windows Direct2D and DirectWrite APIs.

> Note: Not all of the Direct2D and DirectWrite APIs are wrapped, but the most
> commonly used ones are. If you need a specific API that is not wrapped, feel
> free to open an issue or submit a pull request.

## Installation

```bash
pip install pyd2d
```

## Usage

See the [demo app](/demo.py) for a working example app using pyD2D and ctypes.

Basic usage is as below:

```python
import pyd2d

# Initialize COM
pyd2d.InitializeCOM()

# Create a Direct2D factory
factory = pyd2d.GetD2DFactory()

# Create a render target
render_target = factory.CreateHwndRenderTarget(
    my_hwnd, width=800, height=600,
)

# Draw a rectangle
render_target.BeginDraw()
render_target.Clear(1.0, 1.0, 1.0, 1.0)
render_target.FillRectangle(
    100, 100, 200, 200,
    render_target.CreateSolidColorBrush(0.0, 0.0, 0.0, 1.0),
)
render_target.EndDraw()

# Release resources
render_target.Release()
factory.Release()
pyd2d.UninitializeCOM()
```

## License

pyD2D is licensed under the MIT License.
sombra-engine 0.1.0
Small 3D game engine used at Sombra Studio
Requires Python: >=3.11

# sombra-engine 

Game Engine made in Python on top of the pyglet framework (work in progress).

## Planned features

- 3D models through glTF format (and limited support for OBJ)
- OpenGL Renderer and GLSL shaders
- Skeletal animations
- Pathfinding
- Rigid body physics
- Particle systems
- Terrain rendering
- UI library with shaders support (through [pudu-ui](https://github.com/sombra-studio/pudu-ui))

![screenshot](https://raw.githubusercontent.com/sombra-studio/sombra-engine/refs/heads/main/docs/screenshot.png)

You can get the OBJ model of Yoda from [here](https://graphics.cs.utah.edu/courses/cs6610/spring2022/prj04/yoda.zip)
music-mesa-tables 0.2.3
MESA tables for post-processing of MUSIC simulations
Requires Python: >=3.10

# music-mesa-tables

Fast implementation of the `'mesa'` equation of state as used in the MUSIC
project.

MUSIC is a stellar convection code. See e.g.
[Viallet _et al_ (2016)](https://doi.org/10.1051/0004-6361/201527339),
[Goffrey _et al_ (2017)](https://doi.org/10.1051/0004-6361/201628960).

The so-called `'mesa'` equation of state implemented in MUSIC relies on tables
from the [MESA project](https://docs.mesastar.org) (version 15140).
In the regimes typically simulated in MUSIC, the relevant tables are:

- FreeEOS, from [Irwin](http://freeeos.sourceforge.net/);
- OPAL, from [Rogers and Nayfonov (2002)](https://doi.org/10.1086/341894);
- SCVH, from [Saumon, Chabrier, and van Horn (1995)](https://doi.org/10.1086/192204).

See the [MESA documentation for more details](https://docs.mesastar.org/en/r15140/eos/overview.html).

For use in MUSIC, these tables are reinterpolated in (density, internal energy)
space. The reinterpolated tables are bundled in this package. This package is
intended for post-processing of data from MUSIC simulations. To build stellar
evolution models, refer to the MESA project.

---

This offers a Python API. Here is a simple example:

```python
import music_mesa_tables as mmt
import numpy as np

eos = mmt.CstCompoEos(metallicity=0.02, he_frac=0.28)

density = np.array([1.05, 15.7, 134.9])
internal_energy = np.array([1e12, 1e15, 3e15])
state = mmt.CstCompoState(eos, density, internal_energy)

temperature = 10 ** state.compute(mmt.StateVar.LogTemperature)
# array([2.21745558e+03, 5.00852231e+06, 1.48317986e+07])
```