semvec/pypi-packages huggingface dataset:
stardewModPY 0.3.11.post1
Uma biblioteca para gerar mods com packs de conteúdo em json para Stardew Valley
Requires Python: >=3.12

# StardewModPY

## 🌍 Other languages

- 🇬🇧 English (you are here)
- 🇧🇷 [Português](README.pt.md)

**StardewModPY** is a Python library designed to simplify the creation and manipulation of content patch files (mods) for the game **Stardew Valley**.

## Installation

You can install the library via pip:

```bash
pip install StardewModPY
```

## 1. Creating a New Project

After installing StardewModPY, you can easily create a new mod project using the following command:

```bash
sdvpy create nameMod nameAuthor 0.0.1 "Mod Description"
```

**File: ModEntry.py**

```python
from StardewValley import Manifest
from StardewValley.helper import Helper

class ModEntry(Helper):
    def __init__(self):
        super().__init__(Manifest(
            "nameMod", "nameAuthor", "0.0.1", "Mod Description", "nameAuthor.nameMod", ContentPackFor={
                "UniqueID": "Pathoschild.ContentPatcher"
            }
        ))
        self.contents()

    def contents(self):
        ...
```

**File: main.py**

```python
from ModEntry import ModEntry

mod=ModEntry()
mod.write()
```



## Compiling the Mod

To compile the mod, simply run:

```bash
sdvpy run
```


> We will continue improving the library's documentation over time. We also recommend checking the Stardew Valley wiki to find accurate information about the game data you want to modify. [Documentation](http://stardewmodpy.kya.app.br/)
qugradlab 0.1.2
An extension to the Python package QuGrad that implements common Hilbert space structures, Hamiltonians, and pulse shapes for quantum control.
Requires Python: >=3.9
Keywords: Hamiltonian, control, pulse

# QuGradLab
An extension to the Python package [QuGrad](https://QuGrad.readthedocs.io) ([doi:10.5281/zenodo.17116721](https://doi.org/10.5281/zenodo.17116721)) that implements common Hilbert space structures, Hamiltonians, and pulse shapes for quantum control.

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17116725.svg)](https://doi.org/10.5281/zenodo.17116725)

[![Unit Tests](https://github.com/Christopher-K-Long/QuGradLab/actions/workflows/test-python-package.yml/badge.svg)](https://github.com/Christopher-K-Long/QuGradLab/actions/workflows/test-python-package.yml)

## Installation

The python package can be installed with pip as follows:
```bash
pip install qugradlab
```

If on Linux and using a conda environment you may encounter an error
```
version `GLIBCXX_...' not found
```
to fix this you also need to execute:
```bash
conda install -c conda-forge libstdcxx-ng
```

### Requirements

Requires:
- [QuGrad](https://QuGrad.readthedocs.io) (== 1.*) ([doi:10.5281/zenodo.17116721](https://doi.org/10.5281/zenodo.17116721))
- [PySTE](https://PySTE.readthedocs.io) (== 1.*) ([doi:10.5281/zenodo.17116431](https://doi.org/10.5281/zenodo.17116431))
- [TensorFlow](https://www.tensorflow.org) (== 2.*)
- [NumPy](https://numpy.org) (>= 1.21, < 3)
- [SciPy](https://scipy.org/) (== 1.*)

#### Additional requirements for testing

- [toml](https://github.com/uiri/toml)
- [PyYAML](https://pyyaml.org/)

## Documentation

Documentation including worked examples can be found at: [https://QuGradLab.readthedocs.io](https://QuGradLab.readthedocs.io)

## Source Code

Source code can be found at: [https://github.com/Christopher-K-Long/QuGradLab](https://github.com/Christopher-K-Long/QuGradLab)

## Version and Changes

The current version is [`0.1.2`](ChangeLog.md#release-012). Please see the [Change Log](ChangeLog.md) for more details. QuGradLab uses [semantic versioning](https://semver.org/).
qugrad 1.0.2
A Python package for quantum optimal control.
Requires Python: >=3.9
Keywords: control, optimal, quantum

# QuGrad
A Python package for quantum optimal control.

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17116721.svg)](https://doi.org/10.5281/zenodo.17116721)

[![Unit Tests](https://github.com/Christopher-K-Long/QuGrad/actions/workflows/test-python-package.yml/badge.svg)](https://github.com/Christopher-K-Long/QuGrad/actions/workflows/test-python-package.yml)

## Installation

The python package can be installed with pip as follows:
```bash
pip install qugrad
```

If on Linux and using a conda environment you may encounter an error
```
version `GLIBCXX_...' not found
```
to fix this you also need to execute:
```bash
conda install -c conda-forge libstdcxx-ng
```

### Requirements

Requires:
- [PySTE](https://PySTE.readthedocs.io) (== 1.*) ([doi:10.5281/zenodo.17116431](https://doi.org/10.5281/zenodo.17116431))
- [TensorFlow](https://www.tensorflow.org) (== 2.*)
- [NumPy](https://numpy.org) (>= 1.21, < 3)

#### Additional requirements for testing

- [toml](https://github.com/uiri/toml)
- [PyYAML](https://pyyaml.org/)

## Documentation

Documentation including worked examples can be found at: [https://QuGrad.readthedocs.io](https://QuGrad.readthedocs.io)

## Source Code

Source code can be found at: [https://github.com/Christopher-K-Long/QuGrad](https://github.com/Christopher-K-Long/QuGrad)

## Version and Changes

The current version is [`1.0.2`](ChangeLog.md#release-102). Please see the [Change Log](ChangeLog.md) for more details. QuGrad uses [semantic versioning](https://semver.org/).
yog-sothoth 0.0.1
That one who knows all the secrets
Requires Python: >=3.14

# Yog-Sothoth

Este repositorio es un taller personal para construir, probar y documentar herramientas y conceptos de seguridad. Es un entorno de aprendizaje práctico tanto para seguridad ofensiva como defensiva, combinando la flexibilidad de Python con el rendimiento de Go.

El nombre `Yog-Sothoth` (La Llave y la Puerta) representa la naturaleza de este laboratorio: una colección de conocimiento omnisciente y herramientas que "lo ven todo".

## Directrices Éticas

Todas las herramientas y scripts en este repositorio son solo para fines educativos. Siempre asegúrate de tener permiso explícito antes de probar la seguridad en cualquier entorno. Usa el conocimiento de manera responsable para fortalecer la seguridad, no para dañar.

## Licencia

Este proyecto es para fines educativos y está disponible gratuitamente para usar, modificar y distribuir bajo la **[Licencia MIT](LICENSE)**.
holy_bible_api 6.0.0
A Python client library for the Holy Bible API
Requires Python: >=3.9

# Holy Bible API Python Client

A Python client library for accessing the Holy Bible API with full type support.

## Installation

```bash
pip install holy_bible_api
```

## Usage

### Basic Usage

```python
from holy_bible_api import create_bible_api

# Create an API client
api = create_bible_api()

# Make API calls
bibles = api.get_bibles()
```

### With Type Hints

```python
from holy_bible_api import (
    create_bible_api,
    DefaultApi,
    Bible,
    BibleVerse,
    GetBiblesRes,
    GetBibleVersesRes,
)

# Create a typed API client
api: DefaultApi = create_bible_api()

# Get bibles with type hints
bibles_response: GetBiblesRes = api.get_bibles()
bible: Bible = bibles_response.data[0]

# Get verses with type hints
verses_response: GetBibleVersesRes = api.get_bible_verses(
    bible_id=bible.id,
    book=1,
    chapter=1
)
verse: BibleVerse = verses_response.data[0]
print(f"{verse.book}:{verse.chapter}:{verse.verse} - {verse.text}")
```

### Custom Host

```python
from holy_bible_api import create_bible_api

# Use a custom API host
api = create_bible_api(url="https://custom-host.com")
```

## Available Types

The following types are exported for use:

### API Classes
- `DefaultApi` - Main API client
- `ApiClient` - Low-level HTTP client
- `Configuration` - API configuration
- `ApiResponse` - API response wrapper

### Models
- `Bible` - Bible metadata
- `BibleVerse` - Bible verse data
- `AudioBible` - Audio bible metadata
- `GetBiblesRes` - Response for getting bibles
- `GetBibleVersesRes` - Response for getting verses
- `GetBibleBooksRes` - Response for getting books
- `GetBibleChaptersRes` - Response for getting chapters
- `GetAudioBiblesRes` - Response for getting audio bibles
- `GetAudioBooksRes` - Response for getting audio books
- `GetAudioChaptersRes` - Response for getting audio chapters

### Exceptions
- `OpenApiException` - Base exception
- `ApiTypeError` - Type error
- `ApiValueError` - Value error
- `ApiKeyError` - Key error
- `ApiAttributeError` - Attribute error
- `ApiException` - General API exception

## Type Checking

This package includes `py.typed` marker file for full type checking support with mypy, pyright, and other type checkers.

## License

[Your License Here]
varsnap 1.5.9
Varsnap
Requires Python: >=3.7
Keywords: testing

Varsnap Python
==============

[![Build Status](https://drone.albertyw.com/api/badges/albertyw/varsnap-python/status.svg)](https://drone.albertyw.com/albertyw/varsnap-python)

[Python Varsnap Client](https://www.varsnap.com/)

Installation
------------

Install from PyPI - `pip install varsnap`

Requirements
------------

The client depends on three environment variables to be set:

 - `VARSNAP` - Should be either `true` or `false`.  Varsnap will be disabled if the variable is anything other than `true`.
 - `ENV` - If set to `development`, the client will receive events from production.  If set to `production`, the client will emit events.
 - `VARSNAP_PRODUCER_TOKEN` - Only clients with this token may emit production snapshots.  Copied from https://www.varsnap.com/user/
 - `VARSNAP_CONSUMER_TOKEN` - Only clients with this token may emit development snapshots.  Copied from https://www.varsnap.com/user/

Usage
-----

Add the varsnap decorator in front of any function you'd like to make better:

```python
from varsnap import varsnap


@varsnap
def example(args, **kwargs):
    return 'output'
```

Testing
-------

With the proper environment variables set, in a test file, add:

```python
import unittest
from varsnap import test

class TestIntegration(unittest.TestCase):
    def test_varsnap(self):
        matches, logs = test()
        if matches is None:
            raise unittest.case.SkipTest('No Snaps found')
        self.assertTrue(matches, logs)
```

If you're testing a Flask application, set up a
[test request context](https://flask.palletsprojects.com/en/1.1.x/api/#flask.Flask.test_request_context) when testing:

```python
# app = Flask()
with app.test_request_context():
    matches, logs = test()
```

Troubleshooting
---------------

**Decorators changing function names**

Using decorators may change the name of functions.  In order to not confuse
varsnap, set the decorated function's `__qualname__` and `__signature__` to
match the original function:

```python
import inspect


def decorator(func):
    def decorated(*args, **kwargs):
        func(*args, **kwargs)
    decorated.__qualname__ = func.__qualname__
    wrapper.__signature__ = inspect.signature(func)
    return decorated
```

Publishing
----------

```bash
pip install build twine
python -m build
twine upload dist/*
```
jupytergis-mcp 0.1.0rc1
An MCP server for JupyterGIS that allows you to control it using LLMs/natural language.
Requires Python: >=3.10
Keywords: jupytergis, jupyterlab, mcp, geospatial, gis

# jupytercad-mcp

An MCP server for [JupyterGIS](https://github.com/geojupyter/jupytergis/) that allows you to control it using LLMs/natural language.
slightly-better-dicts 0.1.0
A Python library that provides some classes and functions that add quality of life improvements to the standard library's `dict`
Requires Python: >=3.13

# Slightly Better Dicts

A Python library that provides some classes and functions that add quality of life improvements to the standard library's `dict`.

This is a library that I end up re-writing in some form or another every time I work on a new Python project. I decided that it was long past time I threw together a module.

---

Before and after:

```python
my_data = {
    "id": 123,
    "profile": {
        "name": "Mr. Cool Guy",
        "email": "cool.guy@matthewhale.xyz",
        "address": {
            "street": "123 Baller Ave",
            "city": "Coolsville",
            "state": "HI",
            "zip": 55555,
        },
    },
    "preferences": {
        "notifications": {
            "messages": True,
            "promotions": False,
        },
    },
}

my_data.get("profile").get("address").get("zip")
# 55555

my_data.get("preferences").get("oops").get("frobnicate")
# AttributeError: 'NoneType' object has no attribute 'get'

my_data.get("preferences", {}).get("clunky, huh?", {}).get("frobnicate", "default")
# 'default'


from slightly_better_dicts import BetterDict

my_better_data = BetterDict(my_data)

my_better_data.get_in(["profile", "address", "zip"])
# 55555

my_better_data.get_in(["preferences", "oops", "frobnicate"], "default")
# 'default'

if state := my_better_data.get_in(["profile", "address", "state"]) == "HI":
    print("Hi, HI!")
# Hi, HI!
```

## Installation

It's on PyPI. `pip install slightly_better_dicts`, `poetry add slightly_better_dicts`, `uv add slightly_better_dicts` and so on and so forth and what have you.

## Usage

Functionality is provided via two interfaces: subclasses of `dict`, and a collection of pure functions. All of the methods found in the `dict` subclasses are also available as regular functions that accept a mapping as their first argument.

For example:

```python
from slightly_better_dicts import BetterDict, get_in

data = {
    "a": {
        "b": {
            "c": True,
        },
    },
}
better_data = BetterDict(data)

better_data.get_in(["a", "b", "c"])
# True

get_in(data, ["a", "b", "c"])
# True
```