semvec/pypi-packages huggingface dataset:
meow-md 0.3.0
Markdown renderer with Rich
Requires Python: <=4.0,>=3.8
Keywords: markdown, cat

# meow

**meow** is a terminal markdown viewer written in python and inspired by [glow](https://github.com/charmbracelet/glow). it's just a `cat` with [Rich](https://github.com/Textualize/rich), though, no file browsing! (yet?)

## features

- uses `LS_COLORS` — respects your terminal colorscheme for all you (us) ricers
- syntax highlighting in fenced codeblocks via Pygments
- styled lists, headers, blockquotes, and **bold** and *italics*
- `git log`-like, terminal height-aware paging

### gripes / future

- [ ] make the checkboxes cuter! glow-style `[ ]` / `[-]` / `[x]`
- [ ] tables...

## installation

install directly from [pypi](https://pypi.org/project/meow-md):

```bash
# run directly without installing
uvx --from meow-md meow

# or install globaly
uv tool install meow-md

# or more traditionally
pip install --user meow-md  # if you use pip
pipx install meow-md        # if you use pipx
```

or build from source:

```bash
git clone https://codeberg.org/sailorfe/meow.git
cd meow
uv run -m meow.__main__                 # run directly
# or
uv sync && uv run -m meow.__main__      # for development
```

## usage

```bash
meow README.md
```
apbuilder 1.0.0
Atmospheric Profile Builder (APBuilder)
Requires Python: >=3.11
Keywords: atmosphere, climate, forecast, grib2, models, weather

# Atmospheric Profile Builder (APBuilder)

The APBuilder is a tool to create [AC2Dr](https://github.com/LLNL/AC2Dr) atmosphere profiles by
downloading a weather model and making transformations to generate the 1D or 2D binary profile.
The binary profile is used as an input to AC2Dr.

## Installation

APBuilder is provided as a pip package and container image.  
Please follow the [installation instructions](https://software.llnl.gov/APBuilder/install/) on
the documentation.

## More Info

For more information, please check the `docs` directory or visit the
following [documentation page.](https://software.llnl.gov/APBuilder/)

## License

See [LICENSE](https://github.com/LLNL/APBuilder/blob/main/LICENSE) and
[NOTICE](https://github.com/LLNL/APBuilder/blob/main/NOTICE) files for details.

```text
LLNL-CODE-2012226
```
dsnparse 0.4.0
parse dsn urls
Requires Python: >=3.10
Keywords: dsn url parser database configuration

# dsnparse

Parse [dsn connection url strings](http://en.wikipedia.org/wiki/Data_source_name). Responsible for parsing dsn strings in projects like [prom](https://github.com/jaymon/prom) and [morp](https://github.com/jaymon/morp).

This is a generic version of [dj-database-url](https://github.com/kennethreitz/dj-database-url).

So, now you can create dsns like this:

    scheme://user:pass@host:port/path?query=query_val#fragment

For example, let's look at a prom dsn:

    prom.interface.postgres.Interface://testuser:testpw@localhost/testdb

Now let's parse it:

```python
import dsnparse

dsn = "prom.interface.postgres.Interface://testuser:testpw@localhost:1234/testdb"
r = dsnparse.parse(dsn)

print(r.scheme) # prom.interface.postgres.Interface
print(r.username) # testuser
print(r.password) # testpw
print(r.host) # localhost
print(r.port) # 1234
print(r.hostloc) # localhost:1234
print(r.paths) # ['testdb']
```

Also, dsnparse can easily use environment variables:

```python
r = dsnparse.parse_environ('ENVIRONMENT_VARIABLE_NAME')
```

I tried to keep the interface very similar to [urlparse](https://docs.python.org/3/library/urllib.parse.html#urllib.parse.urlparse) so it will feel familiar to use.


## Customizing

By default, `dsnparse.parse(dsn)` returns a `ParseResult` instance, but that can be customized:

```python
import dsnparse

class MyResult(dsnparse.ParseResult):
    def configure(self):
        # expose an interface property
        self.interface = self.scheme

dsn = "Interface://testuser:testpw@localhost:1234/testdb"
r = dsnparse.parse(dsn, parse_class=MyResult)
print(isinstance(r, MyResult)) # True
print(r.interface) # Interface
```


## Install

Use pip:

    pip install dsnparse

or use pip with github:

    pip install -U "git+https://github.com/Jaymon/dsnparse#egg=dsnparse"
pyt 1.4.0
easily run python unit tests
Requires Python: >=3.10

# Pyt 

Pyt is a lightweight wrapper around [Python's unittest module](https://docs.python.org/3/library/unittest.html) that adds some nice features and enhancements over the stock `unittest` module.


### Quickstart

Pyt overrides unittest's built-in pathfinding to be smarter and less verbose, so you can match tests using prefix matching which makes running a test like:

	$ python -m unittest tests.foo_test.BarTestCase.test_che
	
as simple as:

	$ pyt foo.Bar.che
	
But it's even less verbose if you want it to be, pyt can reach into the modules and classes to do its matching, so you don't even need to specify the module and class if you don't want to:

	$ pyt che


#### More examples

To run all the `Happy` tests:

    $ pyt Happy

To run all the `newmodule` tests:

    $ pyt newmodule

To run more than one test:

    $ pyt test1 test2 ...

To run every test `pyt` can find:

    $ pyt

And the way I like to run all tests in the current directory:

    $ pyt -vb
    
Which can also be written:

	$ pyt --verbose --buffer


### Flags

To see everything pyt can do

    $ pyt --help
    
#### --warnings

This will convert warnings into errors.

	$ pyt --warnings
	
#### --rerun

If your last testrun had failing tests this will rerun only the tests that failed.

	$pyt --rerun


### Things to be aware of

#### pyt uses Python's PEP 8 style conventions

`pyt` uses [Python's code styling conventions](http://www.python.org/dev/peps/pep-0008/) to decide what is the module and class, so, given input like this:

    $ pyt foo.bar.Baz.che

`pyt` will consider `foo.bar` to be the module, `Baz` to be a class (because it starts with a capital letter), and `che` to be a method (since it comes after the class).

Likewise, `pyt` uses unittest conventions, so a test module should end with `_test` (eg, `foo.bar_test`) or start with test (eg, `test_foo.py`) and a TestCase class should extend `unittest.TestCase`, and test methods should start with `test_` (eg, `test_che`).


#### Vague input can cause pyt to run more tests than you expect

So if you have something like this:

    project/
      __init__.py
      user.py
      foo/
        __init__.py
        user.py
      tests/
        __init__.py
        user_test.py
        foo/
          __init__.py
          user_test.py

And you want to run tests for `foo.user` and you run:

    $ pyt user

it will run both `tests/user_test` and `tests.foo.user_test`, the solution is to just be more verbose when you have to be:

    $ pyt foo.user


#### Environment Variables

If you are running the tests within pyt, you might notice there is an environment variable `PYT_TEST_COUNT` that contains the count of how many tests pyt found to run.


## Installation

Use `pip`:

    $ pip install pyt

You can also get it directly from the repo:

    $ pip install --upgrade git+https://github.com/Jaymon/pyt#egg=pyt


## Testing

Testing on MacOS:

    $ python -m unittest discover

Or, if you're really brave, you can use `pyt` to test itself:

    $ python -m pyt tests -df
genai4sa 0.2.1
A software architecture generation tool using LLMs
Requires Python: >=3.8

# GenAI-for-SA
 A tool to generate software design document using LLM models and different prompting techniques.

[![PyPi](https://img.shields.io/pypi/v/GenAI4SA.svg)](https://pypi.org/project/genai4sa/)
[![Downloads](https://static.pepy.tech/badge/GenAI4SA)](https://pypi.org/project/genai4sa/)
![alt text](<Screenshot 2025-08-17 183501.png>)

# How to use the tool:
        1. Enter the API Key for OpenAI, GoogleAI or GroqAI depending on the model you want to use.
        2. Select the Model to use.
        3. Select the Prompting technique to use.
        4. Input the textual description of the system. 
        5. Press Generate and wait for the PDF to open. The PDF will be saved in the current working directory 
        from where you ran the tool.
        6. If you want to continue the conversation and iterate over the LLM respond, set Continue Conversation 
        to Yes, and enter the prompt in Textbox and Press Generate.

# How to download the library and run the tool:
        1. Install with this command (enter in command prompt/terminal):
            pip install genai4sa
        2. Run with this command:
            genai4sa
            
# How to Contribute:
        1. Fork the repository at https://github.com/yorku-ease/devbot_SA
        2. Create a feature branch: `git checkout -b feature/my-feature`
        3. Make your changes and test.
        4. Commit and push.
        5. Open a Pull Request (PR)

# How to run locally
        1. Open terminal and go to where repo was cloned.
                cd <repo name>
        2. Run this command there to create a virtual environment (Only when running the First Time, Skip to 3rd step otherwise)
                python -m venv venv
        3. Then run this command to activate the virtual environment
                For macOS/Linux:
                        source venv/bin/activate
                For Windows (PowerShell)
                        .\venv\Scripts\Activate.ps1
                (If you get the error saying running scripts is disabled on this system… -> Run this command in the root folder in PowerShell)
                        Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned
                (When prompted, type Y and press Enter.) 
        4. Run this command there
                pip install -e .
        5. Then enter this command to run the program
                genai4sa
changelogbump 0.5.0
A CLI tool to manage project versioning and changelogs with Keep a Changelog compliance.
Requires Python: >=3.11
Keywords: changelog, versioning, semantic, cli

# changelogbump

[![Python](https://img.shields.io/badge/python3-555555?style=for-the-badge&logo=python&logoColor=ffdd54)](https://www.python.org)
[![Poetry](https://img.shields.io/badge/Poetry-555555?style=for-the-badge&logo=Poetry)](https://python-poetry.org/)
![PyPI - Version](https://img.shields.io/pypi/v/ChangelogBump?style=for-the-badge&logo=PyPi&logoColor=EEEEEE&color=blue)


A command-line tool that updates a project's changelog and bumps its semantic version according to [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) conventions.

## Features

- Initializes a new CHANGELOG.md file with a standard header.
- Increments the project version (major, minor, or patch) and updates:
  - The pyproject.toml version.
  - The changelog, prompting for added, changed, or removed entries.
- Helps maintain strict adherence to semantic versioning.

## Requirements

- pyproject.toml

## Installation

1. Ensure you have Python 3.11 or newer installed.
2. Install via pip:
   ```bash
   pip install changelogbump
   ```

## Usage

From your terminal, run:

- Initialize a fresh changelog in the project root (if not present):
  ```bash
  changelogbump init
  ```

- Add and bump your version, specifying the part to increment:
  ```bash
  changelogbump add --major
  changelogbump add --minor
  changelogbump add --patch
  ```

- Provide a summary for the version:
  ```bash
  changelogbump add --patch --summary "Small bug fixes"
  ```

- Check the currently installed version of changelogbump:
  ```bash
  changelogbump version
  ```

You will be prompted for items to add under different sections (Added, Changed, Removed), which are appended to the changelog.

## Contributing

Pull requests, issues, and feature requests are welcome! Feel free to check out the [issues page](https://github.com/muad-dweeb/changelogbump/issues).

## License

This project is licensed under the MIT License.
ironrdp-py 0.1.0
Python bindings for IronRDP
Requires Python: >=3.8

# ironrdp-py

Python bindings for a headless IronRDP screenshot client, mirroring the `ironrdp/examples/screenshot.rs` logic.

## Build and install into your current Python

- Ensure Rust toolchain and a C++ build toolchain (MSVC) are installed.
- Install maturin: `pip install maturin`
- From this directory, run: `maturin develop --release`

## Usage (Python)

```python
import ironrdp as rdp

png_bytes = rdp.screenshot(
    host="example.com",
    username="user",
    password="pass",
    port=3389,
    domain=None,
)

with open("out.png", "wb") as f:
    f.write(png_bytes)
```

or

```python
import ironrdp as rdp
rdp.screenshot_to_file("example.com", "user", "pass", "out.png", port=3389, domain=None)
```

Enable verbose logging for troubleshooting:

```powershell
$env:IRONRDP_LOG = 'trace'
```

### Interactive client example

See `examples/example.py` for a full flow. Summary:

```python
import time
import ironrdp as rdp

client = rdp.RdpClient(host, username, password, port, domain)
client.connect()

# Drive the event loop
deadline = time.time() + 2.0
while time.time() < deadline:
    client.poll()

# Get the current frame
png = client.frame_png()
with open("out.png", "wb") as f:
    f.write(png)

client.close()
```

### Keyboard input (by name)

Methods accept human-friendly key names (e.g. `"CTRL"`, `"ALT"`, `"DEL"`, `"WIN"`, `"ENTER"`, `"SPACE"`, `"F1"`…):

```python
# Press/release directly
client.key_down("LWIN", True)   # optional: extended override
client.key_up("LWIN", True)

# Press-and-release a key
client.key_press("ENTER")
```

Notes:

- **extended** is inferred from the mapping but can be overridden by passing `True`/`False`.
- `type_text("Hello")` sends Unicode key events directly (useful for arbitrary text).

### Mouse

```python
client.mouse_move(100, 200)
prompd 0.3.4
Structured prompt management CLI with universal LLM provider support, version control, and git integration
Requires Python: >=3.8
Keywords: prompt, prompd, prompt-management, prompt-engineering, template, ai, cli, llm, openai, anthropic, ollama, local-llm, groq, together-ai

# Prompd Python CLI

This is the Python implementation of the Prompd CLI with rich features and LLM provider integrations.

## Features

- Full LLM provider support (OpenAI, Anthropic, Ollama, etc.)
- Rich terminal output with colors and formatting
- Advanced validation and error reporting
- Git integration for version control
- Template engine with Jinja2
- Configuration management

## Installation

```bash
cd cli/prompd/python
pip install -e .
```

## Usage

```bash
# Validate a .prmd file
prompd validate example.prmd

# List available files
prompd list prompts/

# Show file structure
prompd show example.prmd

# Execute with LLM
prompd execute example.prmd --provider openai --model gpt-4 -p name=Alice

# Provider management
prompd provider list
prompd provider add custom-llm http://localhost:8080/v1 model1 model2

# Git operations
prompd git status
prompd git commit -m "Update prompts"

# Version management
prompd version bump example.prmd minor
prompd version history example.prmd
```

## Dependencies

See `pyproject.toml` for full dependency list. Requires Python 3.8+.