semvec/pypi-packages huggingface dataset:
feynml 0.3.2
Feynman diagram markup language
Requires Python: >=3.8

# FeynML

FeynML from <https://feynml.hepforge.org/>

FeynML is a project to develop an XML dialect for describing Feynman diagrams as used in quantum field theory calculations. The primary aim is to unambiguously describe the structure of a diagram in XML, giving a de facto representation for diagram structure which can be easily translated into another representation.

[![PyPI version][pypi image]][pypi link] [![PyPI version][pypi versions]][pypi link]  ![downloads](https://img.shields.io/pypi/dm/feynml.svg) [![DOI](https://zenodo.org/badge/584503197.svg)](https://zenodo.org/badge/latestdoi/584503197)

[![test][a t image]][a t link]     [![Coverage Status][c t i]][c t l] [![Codacy Badge](https://app.codacy.com/project/badge/Coverage/6ca71460fc2d44049a87bf4580134322)](https://app.codacy.com/gh/APN-Pucky/feynml/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage)  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/6ca71460fc2d44049a87bf4580134322)](https://app.codacy.com/gh/APN-Pucky/feynml/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)  [![Documentation][rtd t i]][rtd t l] [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/APN-Pucky/pyhep-2023/final)

## Installation

```sh
pip install [--user] feynml
```

or from cloned source:

```sh
poerty install --with docs --with dev
poetry shell
```

## Documentation

- <https://pyfeyn2.readthedocs.io/en/stable/feynml/>
- <https://apn-pucky.github.io/pyfeyn2/feynml/index.html>

## Related:

- <https://github.com/APN-Pucky/pyfeyn2>

## Development

### package/python structure:

- <https://mathspp.com/blog/how-to-create-a-python-package-in-2022>
- <https://www.brainsorting.com/posts/publish-a-package-on-pypi-using-poetry/>

[a t image]: https://github.com/APN-Pucky/feynml/actions/workflows/test.yml/badge.svg
[a t link]: https://github.com/APN-Pucky/feynml/actions/workflows/test.yml
[c t i]: https://coveralls.io/repos/github/APN-Pucky/feynml/badge.svg?branch=master
[c t l]: https://coveralls.io/github/APN-Pucky/feynml?branch=master
[pypi image]: https://badge.fury.io/py/feynml.svg
[pypi link]: https://pypi.org/project/feynml/
[pypi versions]: https://img.shields.io/pypi/pyversions/feynml.svg
[rtd t i]: https://readthedocs.org/projects/pyfeyn2/badge/?version=latest
[rtd t l]: https://pyfeyn2.readthedocs.io/en/latest/?badge=latest
ug4py-plugins-superlu 0.0.1
This is UG4-plugin for ijkdata.

# SuperLU plugin

**UG4-Plugin** implementing an interface for the [SuperLU solver](https://github.com/xiaoyeli/superlu)

Copyright 2014-2023 Goethe University Frankfurt

## Install
Please install/clone this repository through UG4's package manager[ughub](https://github.com/UG4/ughub).

The default is the *internal* SuperLU v6.0.0, which is included as a submodule. Switching to an *external* version can be achieved via cmake:

 ```
 cmake -DSuperLU6=ON [-DUSE_INTERNAL_SUPERLU=ON|OFF] ..
 ```


## Dependency
* [SuperLU solver (v6.0.0)](https://github.com/xiaoyeli/superlu) is included as a submodule.
* If you are using SuperLU, remember to cite it! Bibtex information is [here](http://crd-legacy.lbl.gov/~xiaoye/SuperLU/referencing.html).

## License
The plugin can be used in accordance with SuperLU license.
armcrop 1.2.1
A machine learning model that crops CT scans to a bone of interest in the arm
Requires Python: >=3.11

# *armcrop*

[![PyPI Latest Release](https://img.shields.io/pypi/v/armcrop.svg)](https://pypi.org/project/armcrop)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

This package contains a machine learning model that can crop a CT scan to any of the following classes:
- clavicle
- scapula
- humerus
- radius_ulna
- hand

It can do both axis aligned cropping and oriented bounding box (obb) cropping. The obb cropping allows for rigid registration of CT scans.

This model was trained on arm only scans and proximal half chest scans. A limitation of this model is that when using a full chest CT where the spine is present the model will struggle to differentiate between it and the scapula.

## Installation
To use CPU execution install with:
```
pip install armcrop
```
To use CUDA execution you will need to also install torch and onnxruntime-gpu.


## Usage
```python
import armcrop
import SimpleITK as sitk

# load CT scan
volume = sitk.ReadImage("path/to/ct_scan.nrrd")

# Oriented Bounding Box Cropping
cropper = armcrop.CropOrientedBoundingBox(volume)
cropped_images = cropper.process(bone="humerus")
for i, img in enumerate(cropped_images):
    sitk.WriteImage(img, f"aligned_humerus-{i}.nrrd")

# Bounding Box Cropping
cropper = armcrop.Crop(volume)
output = cropper.process(bone="scapula")
for i, img in enumerate(output):
    sitk.WriteImage(img, f"cropped_scapula-{i}.nrrd")
chimp-osc 0.2.0
Wrapper for OSC of the Infinity Chimp Lighting Console
Requires Python: >=3.12
Keywords: osc, infinity, chimp, lighting

# chimp-osc
Wrapper for OSC of the Infinity Chimp Lighting Console
Logging is used in all modules and can be activated by:
```py
import logging

logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s [%(levelname)s] %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
```

## Use Chimp or Interface for custom implementation
Install library without options
```
pip install chimp-osc
```

Use plain OSC-Interface

```py
from chimp_osc import ChimpOSCInterface

itf = ChimpOSCInterface("<IP of console>")

def handler(address, *args):
    logging.info(f"Received {args} in {address}")

itf.add_handler("/*",handler)
itf.executor_flash(nr=1,data=True)
```

Or use the Chimp Console
```py
from chimp_osc import Chimp

chimp = Chimp(target_ip="<IP of console>")

chimp.faders[1].flash.press()
```

## Use web-based User Interface
```
pip install chimp-osc[ui]
```

and create it using with the already shown chimp
```py
from chimp_osc.chimp_ui import create_ui
create_ui(chimp)
```

## Use Controllers like XBox-controllers
```
pip install chimp_osc[controller]
```
The controller runs in it own thread.
This offers the possibility to connect multiple controllers or run a controller and the UI at the same time.

```py
from chimp_osc.controllers import XBoxController
XBoxController(chimp).start()
while True:
    pass
```

## Use Full features in combination
Install dependencies for all above mentioned features
```
pip install chimp-osc[full]
```
terraform-it 0.2.1
A tool to generate Terraform providers from OpenAPI specs and Go SDKs.
Requires Python: >=3.6

# Terraform Provider Generator

This tool generates a Terraform provider from an OpenAPI specification and a configuration file.

## Prerequisites

- Python 3.6+
- Go 1.16+
- Terraform 1.0+
- GoReleaser (optional, for building and releasing the provider)
- jinja2 (Python package)
- pyyaml (Python package)

## Installation

2. Install required Python package:

```bash
pip install terraform-it
```

## Usage

```bash
tfit openapi-spec.yaml config.yaml --output-dir ./terraform-provider-rivet
```

### Arguments

- `openapi_spec.yml`: Path to the OpenAPI specification YAML file
- `config.yml`: Path to the configuration YAML file that defines resources and data sources
- `--output-dir`: (Optional) Output directory for generated files (default: current directory)

## Configuration File Format

The configuration file (`config.yml`) should define resources and data sources in the following format:

```yaml
sdk-client-path: SDKClientPath
resources:
  ResourceName:
    resource-path: ResourcePath in SDK
    read:
      method: get
      name: FunctionName in SDK
      path: /path/to/resource/{id}
    create:
      method: post
      name: FunctionName in SDK
      path: /path/to/resource
    update:
      method: put
      name: FunctionName in SDK
      path: /path/to/resource/{id}
    delete:
      method: delete
      name: FunctionName in SDK
      path: /path/to/resource/{id}

datasources:
  DatasourceName:
    read: /path/to/resource/{id}
    list: /path/to/resources
    list-name: FunctionName in SDK
```

## Building the Provider

After generating the provider code, check the `CHECK.md` file for any manual changes or additions required. 
Then you can build it with:

```bash
cd <output_directory>
go build -o terraform-provider-<provider_name>
```

## Using the Provider

To use the provider in Terraform:

1. Copy the built provider to your Terraform plugins directory
2. Create a Terraform configuration file that uses the provider
3. Run `terraform init` to initialize the provider
4. Run `terraform plan` and `terraform apply` to use the provider
open-ttg 0.0.0.4
graph builder from text
Requires Python: >=3.6

# Text2Graph
🌐 Languages: [中文](./README.zh.md)

---

## 📚 Table of Contents

* [Features](#features)
* [Installation](#installation)
* [Usage](#usage)

  * [Build from Concept List](#build-from-concept-list)
  * [Build from Text](#build-from-text)
* [Output Format](#output-format)
* [Testing](#testing)

---

## 🚀 Features

* Build graphs from concept lists or raw text
* Customizable sliding window size and PMI threshold
* Returns graph data with nodes, edges, and PMI scores

---

## 🔧 Installation

```bash
pip install -e .
```

---

## 🧠 Usage

### Build from Concept List

```python
from text2graph.graph_builder import GraphBuilder

builder = GraphBuilder(window_size=5, pmi_threshold=0.1)
concepts = ['人工智能', '机器学习', '神经网络', '深度学习', '人工智能', '大模型', '神经网络']

nodes, edges, pmis = builder.build_graph(concepts)
```

### Build from Text

```python
from text2graph.graph_builder import GraphBuilder

builder = GraphBuilder(window_size=5, pmi_threshold=0.1)
text = '\n'.join(['人工智能', '机器学习', '神经网络', '深度学习', '人工智能', '大模型', '神经网络'])

data = builder.build_graph_from_text(text)
nodes = data['nodes']
edges = data['edges']
pmis = data['pmis']
```

---

## 📦 Output Format

* `nodes`: List of unique concepts
* `edges`: List of tuples (concept1, concept2)
* `pmis`: List of PMI scores corresponding to each edge

---

## ✅ Testing

```bash
python -m unittest
```

---


# For Developers
## setup docker env
```text
docker build -t text2graph -f docker/Dockerfile .
docker run -it --rm --name text2graph -v .\:/code text2graph bash
```
a-law-lib 0.2.0
A-law companding and quantization processing for WAV audio files
Requires Python: >=3.6

a_law_lib is a Python library designed to perform A-law companding, quantization, and WAV audio processing. It provides core functions for compressing and reconstructing signals, useful in digital audio signal processing and educational simulations.

It mainly comes with four functions: `a_law_encode()`, `a_law_decode()`, `quantize()`, and `process_wave_file()`.

a_law_encode(signal, A=87.6):

Perform A-law companding on the input signal.

Parameters:
- signal (numpy.ndarray): Input signal to be encoded.
- A (float, optional): Companding parameter (default is 87.6).

Returns:
- numpy.ndarray: A-law encoded signal.

a_law_decode(companded_signal, A=87.6):

Decode an A-law companded signal.

Parameters:
- companded_signal (numpy.ndarray): Encoded signal.
- A (float, optional): Companding parameter (same as used in encoding).

Returns:
- numpy.ndarray: Decoded signal approximating the original input.

quantize(signal, num_levels):

Apply uniform quantization to the input signal.

Parameters:
- signal (numpy.ndarray): Input signal to be quantized.
- num_levels (int): Number of quantization levels.

Returns:
- numpy.ndarray: Quantized signal.

process_wave_file(file_path, output_path, A=87.6, num_levels=16):

Read a WAV file, apply A-law encoding, quantization, decoding, and save the output.

Parameters:
- file_path (str): Path to the input WAV file.
- output_path (str): Destination path for the processed WAV file.
- A (float, optional): Companding parameter (default is 87.6).
- num_levels (int, optional): Number of quantization levels (default is 16).

Returns:
- None. Writes processed audio to the specified output path.

Features:
- A-law companding and reconstruction.
- Uniform quantization.
- Works with mono and stereo WAV files.
- Handles both integer and floating-point audio data.

Sample usage:

```python
import a_law_lib as al
import numpy as np

signal = np.linspace(-1.0, 1.0, 100)
encoded = al.a_law_encode(signal)
decoded = al.a_law_decode(encoded)
quantized = al.quantize(decoded, num_levels=16)
al.process_wave_file("input.wav", "output.wav", A=87.6, num_levels=16)