semvec/pypi-packages huggingface dataset:
notcl 0.4.1
Replace Tcl scripting with Python
Requires Python: >=3.9

# NoTcl: Replace Tcl scripting with Python

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![NoTcl on PyPI](https://img.shields.io/pypi/v/notcl.svg)](https://pypi.python.org/pypi/notcl)
[![Documentation Status](https://readthedocs.org/projects/notcl/badge/?version=latest)](https://notcl.readthedocs.io/en/latest/?badge=latest)

Many tools, especially in VLSI and digital circuit design, expose their functionality through a custom Tcl interpreter. In order to automate those programs, users are expected to write Tcl scripts. With growing complexity, such Tcl scripts become difficult to maintain and often do not integrate seamlessly into larger software systems.

NoTcl allows Tcl-based tools to be automated using Python instead of Tcl. It wraps each tool in a Python interface, turning it into a library that can be imported, tested, and integrated like any other Python package. Python's module system, testing frameworks, and rich ecosystem make it better suited for complex automation than Tcl scripts. NoTcl handles subprocess management and communication via named pipes, exposing a Python API for calling Tcl commands.

## Installation

```bash
pip3 install notcl
```

## Quick Start

Define a custom tool by subclassing `TclTool`:

```python
from notcl import TclTool

class Tclsh(TclTool):
    def cmdline(self):
        return ["tclsh", self.script_name()]

with Tclsh() as t:
    result = t.expr(3, "*", 5)  # Call Tcl commands as Python methods
    print(result)  # 15

    items = t.lreverse([1, 2, 3])  # Automatic type conversion
```

To dive in deeper, please have a look at the **[documentation](https://notcl.readthedocs.io)**.

## Related Tools

- **[pydesignflow](https://github.com/TobiasKaiser/pydesignflow)** — A technology- and tool-agnostic micro-framework for constructing FPGA and VLSI design flows in Python. Uses NoTcl to automate Tcl-based EDA tools like Yosys and OpenROAD.

## Example Projects

- **[RISC-V Lab](https://github.com/tub-msc/rvlab)**: An FPGA-based RISC-V design platform and flow for teaching SoC development, using PyDesignFlow to manage hardware synthesis, simulation, and software builds..

## License

Copyright 2022 - 2026 Tobias Kaiser

SPDX-License-Identifier: Apache-2.0
ifatmagamha-package-creation 0.1.0
A simple Python package for string manipulation operations
Requires Python: >=3.8

# Package Creation

A simple Python package demonstrating string manipulation operations.

## Features

- **Reverse String**: Reverse any string
- **Count Vowels**: Count vowels in a string
- **Capitalize Words**: Capitalize the first letter of each word

## Installation

```bash
pip install ifatmagamha-package-creation
```

## Usage

```python
from package_creation.string_ops import reverse_string, count_vowels, capitalize_words

# Reverse a string
result = reverse_string("hello world")
print(result)  # Output: dlrow olleh

# Count vowels
count = count_vowels("hello world")
print(count)  # Output: 3

# Capitalize words
capitalized = capitalize_words("hello world")
print(capitalized)  # Output: Hello World
```

## Development

### Setup

```bash
# Clone the repository
git clone https://github.com/ifatmagamha/py_project.git
cd py_project/package_creation

# Install dependencies
poetry install

# Run tests
poetry run python -m unittest tests.test_string_ops -v
```

### Building

```bash
poetry build
```

### Testing

```bash
poetry run python -m unittest discover tests -v
```

## Documentation

Full documentation is available at: https://ifatmagamha.github.io/py_project/

## License

MIT License

## Author

ifatmagamha (gamhaif@gmail.com)
pycoilgen 0.2.4
Magnetic Field Coil Generator for Python.
Requires Python: >=3.6
Keywords: MRI, Magnetic Resonance Imaging, NMR, Nuclear Resonance Imaging, Target Field, Gradient Field, Physics, Coil

# pyCoilGen
[![GitHub license](https://img.shields.io/github/license/kev-m/pyCoilGen)](https://github.com/kev-m/pyCoilGen/blob/main/LICENSE)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pycoilgen?logo=pypi)](https://pypi.org/project/pycoilgen/)
[![semver](https://img.shields.io/badge/semver-2.0.0-blue)](https://semver.org/)
[![GitHub tag (latest SemVer)](https://img.shields.io/github/v/tag/kev-m/pyCoilGen?sort=semver)](https://github.com/kev-m/pyCoilGen/releases)
[![Code style: autopep8](https://img.shields.io/badge/code%20style-autopep8-000000.svg)](https://pypi.org/project/autopep8/)

![pyCoilGen logo](https://github.com/kev-m/pyCoilGen/blob/master/docs/source/figures/Logo_small.png)

The **pyCoilGen** project is an open source tool for generating coil winding layouts, such as
[gradient field coils](https://mriquestions.com/gradient-coils.html), within the
[MRI](https://en.wikipedia.org/wiki/Magnetic_resonance_imaging) and
[NMR](https://en.wikipedia.org/wiki/Nuclear_magnetic_resonance) environments. **pyCoilGen** is based on a boundary element method and generates interconnected non-overlapping wire-tracks on 3D support structures.

This Python project is a port of the MATLAB [CoilGen code](https://github.com/Philipp-MR/CoilGen) developed by Philipp Amrein. 

For detailed documentation, refer to the [pyCoilGen Documentation](https://pycoilgen.readthedocs.io/).

## Installation

Refer to the [Installation Guide](https://pycoilgen.readthedocs.io/en/latest/installation.html) for detailed instructions on how to install and set up **pyCoilGen**.

## Examples

The [`examples`](https://github.com/kev-m/pyCoilGen/blob/master/examples) directory contains several examples for how to use **pyCoilGen**. These examples demonstrate different scenarios and configurations for generating coil layouts.

## Acknowledgements

The porting of the code from MATLAB to Python was facilitated by [ChatGPT, May 24 through August 3 Version](https://chat.openai.com) with manual corrections. 

Additional cross-checking was done using [MATLAB Online](https://www.mathworks.com/products/matlab-online.html) provided by MathWorks.

## Contributing

If you'd like to contribute to **pyCoilGen**, follow the guidelines outlined in the [Contributing Guide](https://github.com/kev-m/pyCoilGen/blob/master/CONTRIBUTING.md).

## License

See [`LICENSE.txt`](https://github.com/kev-m/pyCoilGen/blob/master/LICENSE.txt) for more information.

## Contact

For inquiries and discussion, use [pyCoilGen Discussions](https://github.com/kev-m/pyCoilGen/discussions).

## Issues

For issues related to this Python implementation, visit the [Issues](https://github.com/kev-m/pyCoilGen/issues) page.

## Citation

Use the following publication, if you need to cite this work:

- [Amrein, P., Jia, F., Zaitsev, M., & Littin, S. (2022). CoilGen: Open-source MR coil layout generator. Magnetic Resonance in Medicine, 88(3), 1465-1479.](https://onlinelibrary.wiley.com/doi/10.1002/mrm.29294)
kumiho-memory 0.2.0
Universal memory provider for AI agents (Redis + Kumiho)
Requires Python: >=3.10
Keywords: kumiho, memory, ai-agents, redis, cognitive-memory, summarization, conversational-ai, mcp

# Kumiho Memory

---

## Experimental client-side utilities for AI agent memory integration

---

### ⚠️ Status

> **Experimental / Preview (0.1.x)**
> This package is provided for early experimentation and reference usage.
> APIs and behavior may change without notice.
> Latest patch: `0.1.2` (2026-02-09) - README refresh and version metadata sync.

---

### What this package is

`kumiho-memory` provides **client-side utilities** that help AI agents
temporarily buffer interaction context and interface with the broader
Kumiho Cognitive Memory architecture.

It is designed to be:

* Lightweight
* Model-agnostic
* Framework-agnostic
* Safe to use in local or sandboxed environments

---

### What this package is NOT

To avoid confusion, this package **does NOT** implement:

* ❌ A full cognitive memory system
* ❌ Long-term memory graphs or lineage tracking
* ❌ Memory consolidation or offline processing
* ❌ Automated belief revision or pruning
* ❌ The "Dream State" consolidation pipeline

Those capabilities exist at the **system level** and are intentionally
decoupled from this client-side library.

---

### Design intent

This separation is intentional.

By keeping advanced memory logic outside the client library:

* Memory remains independent of any specific LLM
* Client environments stay fast and lightweight
* Sensitive or irreversible memory operations are centrally controlled
* The architecture remains portable across platforms and models

---

### Typical use cases

* Experimenting with memory-aware AI agents
* Prototyping agent workflows that require short-term context buffering
* Reference integration for platforms such as:

  * Multi-agent systems
  * Collaborative AI environments
  * MCP-compatible agent runtimes

---

### Installation

```bash
pip install kumiho-memory
```

---

### Minimal example

```python
from kumiho_memory import RedisMemoryBuffer

memory = RedisMemoryBuffer()

memory.add_message(
    project="example",
    session_id="demo-session",
    role="user",
    content="Hello!"
)
```

> This example demonstrates **temporary, short-term buffering only**.
> It does not represent long-term memory persistence.

---

### Architectural note

`kumiho-memory` is one component within a larger, model-agnostic memory
architecture.

The full system includes:

* Client-side buffers (this package)
* Persistent memory storage
* Structured relationships between memories
* Offline consolidation and lifecycle management

This package intentionally exposes **only the client-side surface**.

---

### Roadmap

* `0.1.x` — Experimental preview (current)
* `0.2.x` — Stabilized client APIs
* `1.0.0` — Production-ready client SDK

The scope of this package will remain limited to **client-side concerns**.

---

### License

MIT
cadquery-ocp-stubs 7.9.3.1
Typing stubs for cadquery-ocp based on the official CadQuery/OCP sources
Requires Python: <3.15,>=3.10

# cadquery-ocp-stubs

Typing stubs for cadquery-ocp based on the official CadQuery/OCP sources.

## Notes

In order to use them with MyPy install using pip
cadquery-ocp-novtk 7.9.3.1
Python wrapper for Open CASCADE Technology 3D geometry library based on the official CadQuery/OCP sources (no VTK support)
Requires Python: <3.15,>=3.10

# cadquery-ocp-novtk (also known as OCP)

Python wrapper for OCCT generated using pywrap. Typing [stubs](https://pypi.org/project/cadquery-ocp-stubs/) available from pypi.
Note: VTK is not supported with cadquery-ocp-novtk.

## Goals of OCP
* Provide thin bindings to OCCT.
* Wrap all OCCT modules (if practical).
* React quickly to new OCCT releases.
* Cater primarily for the CadQuery project.

## Non-goals
* Provide additional functionality not present in OCCT
cadquery-ocp 7.9.3.1
Python wrapper for Open CASCADE Technology 3D geometry library based on the official CadQuery/OCP sources
Requires Python: <3.15,>=3.10

# cadquery-ocp (also known as OCP)

Python wrapper for OCCT generated using pywrap. Typing [stubs](https://pypi.org/project/cadquery-ocp-stubs/) available from pypi.

## Goals of OCP
* Provide thin bindings to OCCT.
* Wrap all OCCT modules (if practical).
* React quickly to new OCCT releases.
* Cater primarily for the CadQuery project.

## Non-goals
* Provide additional functionality not present in OCCT
nodnod 1.0.1
Programming in Python empowered with Nodes DI, implements efficient nodes computation agents and dependency scoping
Requires Python: <4.0,>=3.13

# NodNod

🧑‍🧑‍🧒‍🧒 Programming in Python enhanced with Nodes

[![codecov](https://codecov.io/gh/timoniq/nodnod/branch/dev/graph/badge.svg)](https://codecov.io/gh/timoniq/nodnod)
topsis-kavish-102317012 1.0.0
A Python package for TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution)
Requires Python: >=3.6

# Topsis-Kavish-102317012

A Python package for implementing **TOPSIS** (Technique for Order of Preference by Similarity to Ideal Solution) for multi-criteria decision analysis.

## What is TOPSIS?

TOPSIS is a multi-criteria decision analysis method that helps in ranking alternatives based on their closeness to the ideal solution. It is widely used in decision-making scenarios where multiple conflicting criteria need to be considered.

## Installation

You can install the package using pip:

```bash
pip install Topsis-Kavish-102317012
```

## Usage

### Command Line

After installation, you can use the `topsis` command directly from the terminal:

```bash
topsis <InputDataFile> <Weights> <Impacts> <OutputResultFileName>
```

**Example:**
```bash
topsis data.csv "1,1,1,1" "+,+,-,+" output.csv
```

### Python Script

You can also use it in your Python code:

```python
from topsis_kavish_102317012 import topsis

topsis('data.csv', '1,1,1,1', '+,+,-,+', 'output.csv')
```

## Input File Format

The input CSV file should have the following structure:

- **First column**: Names of alternatives (e.g., Fund Name, Model Name)
- **Remaining columns**: Numeric criteria values

**Example (data.csv):**
```
Fund Name,P1,P2,P3,P4
M1,0.87,0.40,6.7,47.9
M2,0.66,0.45,6.9,48.5
M3,0.66,0.42,5.4,49.7
```

## Parameters

- **InputDataFile**: Path to the input CSV file
- **Weights**: Comma-separated weights for each criterion (e.g., "1,1,1,1")
- **Impacts**: Comma-separated impacts for each criterion, either '+' (beneficial) or '-' (non-beneficial)
- **OutputResultFileName**: Path for the output CSV file

## Output

The output CSV file will contain:
- All original columns
- **Topsis Score**: Calculated TOPSIS score for each alternative
- **Rank**: Ranking based on TOPSIS score (1 is best)

## Requirements

- Python >= 3.6
- pandas >= 1.0.0
- numpy >= 1.18.0

## Validations

The package performs the following validations:
- Input file must have at least 3 columns
- Columns from 2nd to last must contain only numeric values
- Number of weights must equal number of criteria
- Number of impacts must equal number of criteria
- Impacts must be either '+' or '-'

## Author

**Kavish**  
Roll Number: 102317012

## License

MIT License
nox-ext 0.4.0
Utility functions and helpers for Nox.
Requires Python: <4.0.0,>=3.10.2
Keywords: nox_ext, nox-ext, nox, packaging

nox_ext
=======

Utility functions and helpers for Nox.

Overview
========

TBD...

`PyPI record`_.

`Documentation`_.

Usage
-----

TBD...

Installation
============

Prerequisites:

+ Python 3.10 or higher

  * https://www.python.org/

+ pip

  * https://pypi.org/project/pip/

To install run:

  .. parsed-literal::

    python -m pip install --upgrade |package|

Development
===========

Prerequisites:

+ Development is strictly based on *nox*. To install it run::

    python -m pip install --upgrade nox

Visit `Development page`_.

Installation from sources:

clone the sources:

  .. parsed-literal::

    git clone |respository| |package|

and run:

  .. parsed-literal::

    python -m pip install ./|package|

or on development mode:

  .. parsed-literal::

    python -m pip install --editable ./|package|

License
=======

  | |copyright|
  | Licensed under the zlib/libpng License
  | https://opensource.org/license/zlib
  | Please refer to the accompanying LICENSE file.

Authors
=======

* Adam Karpierz <adam@karpierz.net>

Sponsoring
==========

| If you would like to sponsor the development of this project, your contribution
  is greatly appreciated.
| As I am now retired, any support helps me dedicate more time to maintaining and
  improving this work.

`Donate`_

.. |package| replace:: nox_ext
.. |package_bold| replace:: **nox_ext**
.. |copyright| replace:: Copyright (c) 2025-2026 Adam Karpierz
.. |respository| replace:: https://github.com/karpierz/nox_ext
.. _Development page: https://github.com/karpierz/nox_ext
.. _PyPI record: https://pypi.org/project/nox-ext/
.. _Documentation: https://karpierz.github.io/nox_ext/
.. _Donate: https://www.paypal.com/donate/?hosted_button_id=FX8L7CJUGLW7S
rigetti-quax 0.3.0
A high-performance library for quantum information science built on top of JAX
Requires Python: >=3.11

# Quax

A high-performance quantum information science library built on top of JAX.

## Documentation

[Check out the docs.](https://rigetti.gitlab.io/application_benchmarking/quax)

## Features

- **Quantum Objects**: States, gates and superoperators objects are defined ot allow natural manipulations and operations.
- **Clear typing**: Standard objects such as Unitaries, Chois and Density matrices are all typed, clarifying the nature of various objects.
- **Standard operators** composition/application `@`, tensor products `|`, scalar multiplication `*` and powers `*` are defined on all quantum objects.
- **Automatic promotion** Pure states and operators are automatically promoted to mixed states and superoperators when appropriate.
- **Qudit support** Operations on d-dimensional qudits are supported.
- **Batch support** Operating on batches or ensembles of states is supported for straightforward parallelization.

## Installation

```bash
pip install rigetti-quax
```

## Quick Example

```python
import jax
import quax as qx

# Create a quantum state
state = qx.zero_state_vector(dims=(2,))

# Apply a unitary operation
U = qx.random_unitary(dims=(2,), key=jax.random.key(0))
final_state = U @ state

# Convert between representations
choi = qx.unitary_to_choi(U)
pauli_liouville = qx.to_pauli_liouville(choi)
```

## License

Copyright 2026 Rigetti & Co, LLC. Licensed under Apache License 2.0.
scd-cohort-descriptive-cli-150226-1400 0.1.0
CLI for descriptive SCD cohort analyses.
Requires Python: >=3.9

# scd_cohort_descriptive_cli

CLI for descriptive SCD cohort analyses from Arrow/CSV pipeline outputs.

## Names

- Rust crate/package: `scd_cohort_descriptive_cli`
- Binary: `scd_cohort_descriptive_cli`
- Python package (maturin): `scd-cohort-descriptive-cli`

## Run

```bash
cargo run -- --input-dir <input_dir> --output-dir <output_dir>
```

Common flags:

- `--safe-export-dir <dir>`
- `--skip-disclosure-check`
- `--match-ratios 4,3,2`
- `--min-year <year> --max-year <year>`
- `--tariff-profile dkk-proxy-v1|unit`
- `--lpr-episode-weight <f64>` (overrides profile default)
- `--lpr-contact-weight <f64>` (overrides profile default)
- `--lmdb-dispense-weight <f64>` (overrides profile default)
- `--lmdb-package-weight <f64>` (overrides profile default)
- `--primary-contact-weight <f64>` (overrides profile default)
- `--primary-service-weight <f64>` (overrides profile default)

Tariff profiles:

- `dkk-proxy-v1` (default): proxy DKK tariffs for placeholder costing.
- `unit`: legacy unit-event weights (`1/0`) for tests/debugging.

Each run writes tariff metadata to:

- `protocol_tariff_metadata.csv`

## Model Safeguards

Model fitting in `protocol_two_part_*` outputs uses these safeguards:

- Negative outcomes are clamped to `0` for model fitting only (descriptive outputs keep raw values).
- Constant predictors are dropped from the design matrix before fitting.
- Two-part/lognormal fits use light ridge regularization for numerical stability.
- Two-part rows are marked `not_applicable` when `positive_share >= 0.995`.

Diagnostics remain available in:

- `protocol_model_input_diagnostics.csv`

## Test and Lint

```bash
cargo test
cargo clippy --all-targets -- -W clippy::pedantic -W clippy::nursery
```

## Build Python Binary Wheel

This project uses maturin with `bindings = "bin"` and the root `Cargo.toml`:

```bash
maturin build
```
discord-plotter 0.2.2
A lightweight module to send Matplotlib figures to Discord via Webhook.
Requires Python: >=3.7

# Discord Plotter

A lightweight Python module designed to send Matplotlib figures directly to a Discord channel using Webhooks.

## Features

- **Lightweight**: Minimal dependencies (`requests`, `matplotlib`, `python-dotenv`).
- **Clean**: No temporary file cleanup required.
- **Secure**: Webhook URLs are managed via environment variables.

## Installation

```bash
uv add git+https://github.com/AliEmreSenel/discord_plotter.git
```

or

```bash
uv add git+ssh://git@github.com/AliEmreSenel/discord_plotter.git
```

## Configuration

This module requires a **Discord Webhook URL**.

1. In Discord, go to **Server Settings** > **Integrations** > **Webhooks**.
2. Create a Webhook and copy the URL.
3. Set the `DISCORD_WEBHOOK_URL` environment variable.

### Option A: Using a `.env` file (Recommended)

Create a file named `.env` in the folder where you run your script:

```ini
DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/your_id/your_token
```

### Option B: Using Terminal Export

```bash
export DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/your_id/your_token"

```
discord.http 3.0.2
Python library that handles interactions from Discord POST requests.
Requires Python: <3.14,>=3.11.0
Keywords: discord, http, api, interaction, aiohttp, webhook, slash

# discord.http
Python library that handles interactions from Discord POST requests.

## Supported installs
- [Guild application (normal bot)](/examples/ping_cmd_example.py)
- [User application (bots on user accounts)](/examples/user_command_example.py)

## Installing
> You need **Python >=3.11** to use this library.

Install by using `pip install discord.http` in the terminal.
If `pip` does not work, there are other ways to install as well, most commonly:
- `python -m pip install discord.http`
- `python3 -m pip install discord.http`
- `pip3 install discord.http`

### Installing beta
Do you live on the edge and want to test before the next version is released?
You can install it by using `git+https://github.com/AlexFlipnote/discord.http@master` instead of `discord.http` when running `pip install`.

> [!NOTE]
> It can be unstable and unreliable, so use it at your own risk.

## Quick example
```py <!-- DOCS: quick_example -->
from discord_http import Context, Client

client = Client(
    token="Your bot token here",
    sync=True  # Optional, defaults to False
)

@client.command()
async def ping(ctx: Context):
    """ A simple ping command """
    return ctx.response.send_message("Pong!")

client.start()
```

Need further help on how to make Discord API able to send requests to your bot?
Check out [the documentation](https://discordhttp.alexflipnote.dev/pages/getting_started.html) for more detailed information.

## Resources
- Documentations
  - [Library documentation](https://discordhttp.alexflipnote.dev)
  - [Discord API documentation](https://discord.com/developers/docs/intro)
- [Discord server](https://discord.gg/yqb7vATbjH)
- [discord.http Bot example](https://github.com/AlexFlipnote/discord_bot.http)


## Acknowledgements
This library was inspired by [discord.py](https://github.com/Rapptz/discord.py), developed by [Rapptz](https://github.com/Rapptz).
We would like to express our gratitude for their amazing work, which has served as a foundation for this project.

The project is also a fork of [joyn-gg/discord.http](https://github.com/joyn-gg/discord.http)