semvec/pypi-packages huggingface dataset:
dark-madr 0.1.2
Architecture Decision Records management tool
Requires Python: >=3.11
Keywords: adr, architecture, decision, documentation, madr, records

# dark-madr

A Python CLI for managing [Architecture Decision Records](https://cognitect.com/blog/2011/11/15/documenting-architecture-decisions).

Compatible with [adr-tools](https://github.com/npryce/adr-tools) workflow. Supports Nygard and [MADR](https://adr.github.io/madr/) templates.

For background on ADRs, see the included paper: [Using ADR on GitHub](assets/Using.ADR.GitHub.pdf)

## Installation

```bash
pip install dark-madr
```

For development:

```bash
uv sync
uv pip install -e .
```

## Usage

```bash
# Initialize ADR directory
adr init

# Create a new ADR
adr new "Use PostgreSQL for primary database"

# List all ADRs
adr list

# Show a specific ADR
adr show 1

# Supersede an existing ADR
adr new "Use PostgreSQL 15" --supersedes 1

# Generate table of contents
adr generate toc
```

## Configuration

Configure defaults in `pyproject.toml`:

```toml
[tool.adr]
dir = "docs/decisions"
template = "madr"
default_status = "proposed"
default_authors = ["Architecture Team"]
```

Initialize configuration:

```bash
adr init-config
adr config  # view current settings
```

## Commands

| Command | Description |
|---------|-------------|
| `adr init` | Initialize ADR directory with first ADR |
| `adr new <title>` | Create a new ADR |
| `adr list` | List all ADRs |
| `adr show <number>` | Display an ADR |
| `adr generate toc` | Generate table of contents |
| `adr templates` | List available templates |
| `adr config` | Show current configuration |
| `adr init-config` | Add config section to pyproject.toml |

### Options

```bash
adr new "Title" --template madr    # Use specific template
adr new "Title" --status accepted  # Set initial status
adr new "Title" --supersedes 3     # Supersede ADR-0003
adr --adr-dir ./docs list          # Override ADR directory
```

## Templates

Two built-in templates:

- **nygard** (default) - Michael Nygard's original format
- **madr** - Markdown Any Decision Records format

View template structure:

```bash
adr help-template nygard
adr help-template madr
```

Custom templates can be added to a directory specified by `template_dir` in config.

## Development

```bash
uv sync --all-extras
uv run pytest
uv run mypy src/
uv run ruff check src/
```

## References

- [Documenting Architecture Decisions](https://cognitect.com/blog/2011/11/15/documenting-architecture-decisions) - Michael Nygard
- [Lightweight ADRs](https://www.thoughtworks.com/radar/techniques/lightweight-architecture-decision-records) - ThoughtWorks Tech Radar (Adopt, Nov 2017)
- [adr-tools](https://github.com/npryce/adr-tools) - Nat Pryce
- [MADR](https://adr.github.io/madr/) - Markdown Any Decision Records

## License

MIT
cp2077-hash-updater 1.0.0
Speedrun Cyberpunk 2077 updates
Requires Python: >=3.13
Keywords: cp2077

### Cyberpunk 2077 hash updater tool

Automatically updates broken Cyberpunk 2077 mangled name hashes for plugins.

**DISCLAIMER:** This tool is almost entirely vibecoded by ChatGPT with [Codex](https://github.com/openai/codex) (I had a subscription and wanted to see how it worked). The fact that it works is a miracle.

This tool relies on the [IDA Domain](https://github.com/HexRaysSA/ida-domain) library for binary analysis and thus **requires IDA Pro to work**.

### Example usage
Note: some lines have been trimmed.
```
uv run .\src\cp2077-hash-updater\ --old-dir .\old\ --new-dir .\new\ --missing-log .\examples\patch_2.3_to_2.31_broken_hashes.txt --out examples/output.json

[run]  build new signature index: .cp2077_cache\new_sig_index.json
Wrote .cp2077_cache\new_sig_index.json with 300572 functions.
[run]  export old missing signatures: .cp2077_cache\old_missing_sigs.json
Wrote .cp2077_cache\old_missing_sigs.json with 10 missing hashes.
[run]  match function anchors offline: .cp2077_cache\func_updates.json
[run]  resolve xref anchors in new: .cp2077_cache\xref_updates.json
[run]  merge results: examples\output.json
[ok]   wrote examples\output.json
```
langchain-0g 0.1.0
Official Langchain client for 0g.ai Inference SDK
Requires Python: <4.0,>=3.10

# langchain-0g

This package contains the LangChain integrations for 0G.ai through their `a0g` SDK.

## Installation and Setup

* Install the 0G.ai Python package:

```bash
pip install python-0g langchain_0g
```

* Set your 0G.ai wallet private key as an environment variable:

```bash
export A0G_PRIVATE_KEY="your_wallet_private_key"
```

## Chat model

`ZGChat` is a wrapper around 0G.ai chat models. It allows you to interact with 0G.ai-hosted LLMs in a LangChain-compatible way.

```python
from langchain_0g import ZGChat

chat = ZGChat(provider="0xf07240Efa67755B5311bc75784a061eDB47165Dd")
response = chat.invoke("Hello 0G!")
print(response)
```

* `provider` is the ENS address of the 0G.ai model.
* `private_key` is optional if you have `A0G_PRIVATE_KEY` in the environment.

### Asynchronous Usage

```python
import asyncio
from langchain_0g import ZGChat

async def main():
    chat = ZGChat(provider="0xf07240Efa67755B5311bc75784a061eDB47165Dd")
    response = await chat.ainvoke("Hi!")
    print(response)

asyncio.run(main())
```

---

## LLM (Legacy)

`ZGLLM` refers to legacy text-completion models hosted on 0G.ai.

```python
from langchain_0g import ZGLLM

llm = ZGLLM(provider="0xf07240Efa67755B5311bc75784a061eDB47165Dd")
text = llm.invoke("Summarize the following article...")
print(text)
```

* `provider` specifies the 0G.ai model.
* Use `private_key` to sign requests via your wallet.

---

## List available models

```python
from langchain_0g import ZGChat

llm = ZGChat(provider="0xf07240Efa67755B5311bc75784a061eDB47165Dd")
print(llm.zg_client.get_all_services())

```

---

## Notes

* 0G.ai clients (`client` and `async_client`) handle authentication using your wallet private key instead of traditional OpenAI API keys.
* The ENS `provider` identifies which LLM to query.
* All requests go through 0G.ai smart contracts for on-chain verification.
gssdata 0.1.1
Python client for General Social Survey (GSS) data
Requires Python: >=3.9
Keywords: general social survey, gss, norc, social science, survey data

# gssdata

[![PyPI version](https://badge.fury.io/py/gssdata.svg)](https://badge.fury.io/py/gssdata)
[![CI](https://github.com/MaxGhenis/gss/actions/workflows/ci.yml/badge.svg)](https://github.com/MaxGhenis/gss/actions/workflows/ci.yml)
[![Documentation](https://img.shields.io/badge/docs-GitHub%20Pages-blue)](https://maxghenis.github.io/gss)

Python client for [General Social Survey (GSS)](https://gss.norc.org/) data.

## Installation

```bash
pip install gssdata
```

## Quick Start

```python
import gssdata

# Get time series for a variable
df = gssdata.trend("NATEDUC")
print(df.head())
#    year  pct
# 0  1973   49
# 1  1974   52
# 2  1975   51
# ...

# List all available variables
variables = gssdata.variables()
print(len(variables))  # 17 core variables

# Get variable metadata
info = gssdata.info("NATEDUC")
print(info["question"])
# "Are we spending too much, too little, or about the right amount on education?"
print(info["responses"])
# {1: "Too little", 2: "About right", 3: "Too much"}
```

## Features

- **Simple API**: `trend()`, `variables()`, `info()` - that's it
- **Pre-computed trends**: Fast access to time series for key variables
- **Full metadata**: Question text, response options, first year asked

## Available Variables

The package includes 17 frequently-studied GSS variables spanning social attitudes, political views, and trust:

| Variable | Description |
|----------|-------------|
| HOMOSEX | Attitudes toward same-sex relations |
| GRASS | Marijuana legalization support |
| PREMARSX | Premarital sex attitudes |
| ABANY | Abortion for any reason |
| FEPOL | Women suited for politics |
| CAPPUN | Death penalty opposition |
| GUNLAW | Gun permit support |
| NATRACE | Spending on race issues |
| NATEDUC | Spending on education |
| NATENVIR | Spending on environment |
| NATHEAL | Spending on health |
| EQWLTH | Government reduce inequality |
| HELPPOOR | Government help poor |
| TRUST | Social trust |
| FAIR | People try to be fair |
| POLVIEWS | Political ideology |
| PRAYER | School prayer ban approval |

## Documentation

Full documentation: [maxghenis.github.io/gss](https://maxghenis.github.io/gss)

## License

MIT
papermc-plugin-manager 0.1.1
A modern CLI tool for managing PaperMC server plugins
Requires Python: >=3.13

# PaperMC Plugin Manager (ppm)

A modern, user-friendly command-line tool for managing PaperMC server plugins. Built with Python and featuring intelligent caching, automatic updates, and beautiful console output powered by Rich.

## Features

- **Search**: Search for plugins across Modrinth with fuzzy matching
- **Easy Installation**: Install plugins with a single command
- **Version Management**: Upgrade, downgrade, or switch between specific versions
- **Version Detection**: Automatically detects outdated plugins
- **Installation Status**: See which plugins are installed at a glance

## Screenshots

**List installed plugins** - View all installed plugins with version information and update status:
![ppm list](media/ppm_list.png)

**Search for plugins** - Find plugins across Modrinth with fuzzy matching:
![ppm search](media/ppm_search.png)

**Show plugin details** - Display comprehensive plugin information including metadata and available versions:
![ppm show](media/ppm_show.png)

## Installation

```bash
pip install papermc-plugin-manager
```

Or using uv:

```bash
uv tool install papermc-plugin-manager
```

## Usage

- List installed plugins:

```bash
ppm update
ppm list
```

- Search for plugins:

```bash
ppm search <plugin-name>
```

- Show plugin details:

```bash
ppm show <plugin-name-or-id> [--version <version>]
```

- Install plugins:

```bash
# Latest release
ppm install <plugin-name> [-y]

# Specific version
ppm install <plugin-name> --version <version> [-y]

# Latest snapshot/beta
ppm install <plugin-name> --snapshot [-y]
```
python-bytecode-ir 0.1.0a0
An expressive set of Python classes modeling Python bytecode as an SSA-form IR.
Requires Python: >=2

# `python-bytecode-ir`

An expressive set of Python classes modeling Python bytecode as an SSA-form IR. Useful for static analysis and program
transformation. Upstream and downstream infrastructure still work in progress.

Base Classes

- IRInstruction
- IRValue

Code Stucture

- IRRegion(IRValue)
- IRBasicBlock(IRValue)

Atoms

- IRConstant(IRInstruction, IRValue)

Named Variable Access

- IRLoad(IRInstruction, IRValue)
- IRStore(IRInstruction)
- IRDelete(IRInstruction)

Special Loads

- IRImport(IRInstruction, IRValue)
- IRImportFrom(IRInstruction, IRValue)
- IRImportStar(IRInstruction)
- IRLoadBuiltIn(IRInstruction, IRValue)
- IRLoadRegion(IRInstruction, IRValue)

Unary Expressions

- IRUnaryOp(IRInstruction, IRValue)

Binary/In-place Expressions

- IRBinaryOp(IRInstruction, IRValue)
- IRInPlaceBinaryOp(IRInstruction)

Collection Literals

- IRBuildList(IRInstruction, IRValue)
- IRBuildTuple(IRInstruction, IRValue)
- IRBuildSet(IRInstruction, IRValue)
- IRBuildMap(IRInstruction, IRValue)

Subscriptions

- IRBuildSlice
- IRLoadSubscr
- IRStoreSubscr
- IRDeleteSubscr

Attribute Accesses

- IRLoadAttr(IRInstruction, IRValue)
- IRLoadSuperAttr(IRInstruction, IRValue)
- IRStoreAttr(IRInstruction)
- IRDeleteAttr(IRInstruction)

Unpacking

- IRUnpackSequence(IRInstruction, IRValue)
- IRUnpackEx(IRInstruction, IRValue)

F-string Related

- IRFormatString(IRInstruction, IRValue)
- IRConcatenateStrings(IRInstruction, IRValue)

Function Definitions and Calls

- IRMakeFunction(IRInstruction, IRValue)
- IRCall(IRInstruction, IRValue)
- IRCallFunctionEx(IRInstruction, IRValue)

Iterators

- IRGetIter(IRInstruction, IRValue)

Basic Block Terminators

- IRForIter(IRInstruction, IRValue)
- IRYield(IRInstruction, IRValue)
- IRBranch(IRInstruction)
- IRJump(IRInstruction)
- IRReturn(IRInstruction)
- IRRaise(IRInstruction)

Exception Stack Manipulation

- IRGetException(IRInstruction, IRValue)
- IRSetException(IRInstruction)

Other

- IRSetupAnnotations(IRInstruction)

## Contributing

Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.

## License

This project is licensed under the [MIT License](LICENSE).
wh-mqtt-client-ex 0.1.1
A MQTT library Wrapper
Requires Python: >=3.9
Keywords: mqtt, mqtt-rpc, mqtt_client_ex, paho-mqtt

# CRUD Tortoise ORM Extension

## Project Overview
This project is an extension that implements CRUD operations based on Tortoise ORM, providing a simple and efficient way to manage database records.

## Installation Instructions

Install the `wh-fastapi-crud-tortoise` package:
   ```bash
   pip install wh-fastapi-crud-tortoise
   ```

## Usage
Here is a basic example of how to use the CRUD extension:

```python
from fastapi import FastAPI
from pydantic import BaseModel, ConfigDict
from datetime import datetime, date
from typing import Optional, Union

from datetime import datetime
from tortoise import fields
from src import CrudModel, TortoiseCRUDRouter, resp_success, resp_fail
from tortoise.contrib.fastapi import register_tortoise


class DummyModel(CrudModel):
    """Record Table"""

    name = fields.CharField(max_length=255, null=False)
    age = fields.IntField()
    salary = fields.FloatField()
    is_active = fields.BooleanField(default=True)
    birthdate = fields.DateField()
    created_at = fields.DatetimeField()
    notes = fields.TextField()
    json_data = fields.JSONField(null=True, default=None)

    class Meta:
        table = "dummy"


ID_TYPE = str


class DummyCreateDTO(BaseModel):
    name: str
    age: int
    salary: float
    is_active: bool
    birthdate: date
    created_at: datetime
    notes: str
    json_data: Optional[object] = None


class DummyDTO(BaseModel):
    id: Optional[ID_TYPE] = None
    name: Optional[str] = None
    age: Optional[int] = None
    salary: Optional[float] = None
    is_active: Optional[bool] = None
    birthdate: Optional[date] = None
    created_at: Optional[datetime] = None
    notes: Optional[str] = None
    json_data: Optional[object] = None

    model_config = ConfigDict(from_attributes=True)


dummy_router = TortoiseCRUDRouter(
    schema=DummyDTO, create_schema=DummyCreateDTO, db_model=DummyModel, prefix="dummy"
)


@dummy_router.post("/custom_router")
async def test(para1: int, para2: str):
    return resp_success(data="test custom router")


app = FastAPI(title="FastapiCrudPro")
register_tortoise(
    app,
    db_url="sqlite://tortoise.sqlite3",
    modules={"models": ["demo"]},
    generate_schemas=True,
    add_exception_handlers=True,
)

app.include_router(dummy_router)


@app.get("/")
def read_root():
    return {"Hello": "World"}


if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app="demo:app", host="127.0.0.1", port=8010, reload=True)
```

## API Documentation
To view the API documentation, open your browser and navigate to `http://127.0.0.1:8010/docs`.

<img alt="dummy" src="https://raw.githubusercontent.com/kanbang/fastapi-crud-pro/master/doc/dummy.png">

## License
This project is licensed under the MIT License.
jerm2000-stat-386-project 0.1.4
STAT 386 project package
Requires Python: >=3.10

# stat_386_project

Final group project for stat 386
Link to hosted GitHub Pages site: https://jerm2000.github.io/stat_386_project/
Link to PyPi package: https://pypi.org/project/jerm2000-stat-386-project/#description