semvec/pypi-packages huggingface dataset:
django-percentagefield 0.1.7
A ``PercentageField`` for Django that shows a Decimal (ex. ``0.2100`` in the database - by default rounded to 4 decimal spaces) as a percentage in the admin (ex. ``21%``). With built-in (overridable) min and max validator to ensure a valid percentage range: 0 ≤ x ≤ 100.
Requires Python: >=3.12

# Django Percentage Field

This package add a ``PercentageField`` to Django (also works with Unfold, some minor styling improvements needed) that
shows a percentage in the admin as ``21%``, but stores it as a Decimal - ``0.2100`` - to the database.
This makes it clearer for admins what the field represents, while the decimal value makes actual calculations easier.

## Installation

Run `pip install django-percentagefield` (or `poetry add django-percentagefield`)

## Settings

- add ``django_percentagefield`` to your ``INSTALLED_APPS`` **before** ``django.contrib.admin``
- in your ``models.py``, add the ``PercentageField`` as such:

```python models.py
from django.db import models

from django_percentagefield.db.models import PercentageField


class YourModel(models.Model):
    percentage_field = PercentageField()
```

- in your ``admin.py``, add the following wherever you use ``PercentageField``:

```python admin.py
from django.contrib import admin
from django.utils.translation import gettext_lazy as _
from django_percentagefield.utils import format_percentage

from .models import YourModel


@admin.register(YourModel)
class YourModelAdmin(admin.ModelAdmin):
    list_display = ('formatted_percentage_field',)

    def formatted_percentage_field(self, instance: YourModel) -> str:
        return format_percentage(value=instance.percentage_field, include_percentage_symbol=True)

    formatted_percentage_field.short_description = _('PercentageField description')
```

- _[optional]_: add ``PERCENTAGE_MAX_DIGITS`` and ``PERCENTAGE_DECIMAL_PLACES`` to your ``settings.py`` (default values
  ``7`` and ``4`` respectively)

**TODO**: make the ``django-percentagefield`` package handle the formatting in ``list_display``, ``readonly_fields``,
etc. automatically.
tacky 0.0.32
a CLI to manage the macOS pasteboard
Requires Python: >=3.11

# Usage

## copying

-   copy file to pasteboard as UTI: `tacky copy -i public.text <name of file>`
-   copy stdin to pasteboard as UTI: `tacky copy -i public.text -`

## pasting

-   paste from pasteboard to stdout as UTI: `tacky paste -u public.text`
-   list available UTI's from pasteboard to stdout: `tacky paste --list`
sagpy 0.0.13
Implementation of the Schedule-Abstraction Graph (SAG) in Python.
Requires Python: >=3.12

# Schedule-Abstraction Graph in Python

Schedule-abstraction graph (SAG) is a reachability-based response-time analysis for real-time systems.

This is the unofficial implementation of the SAG in Python. You can visit the official repository [here](https://github.com/SAG-org/schedule_abstraction-main). This is still WIP (Work-in-Progress) - you can run the anaysis but it doesn't scale because path merging is not implemented yet. The implemented SAG follows the following paper:
- M. Nasri, G. Nelissen, and B. Brandenburg, “[Response-Time Analysis of Limited-Preemptive Parallel DAG Tasks under Global Scheduling](https://drops.dagstuhl.de/storage/00lipics/lipics-vol133-ecrts2019/LIPIcs.ECRTS.2019.21/LIPIcs.ECRTS.2019.21.pdf)”, Proceedings of the 31st Euromicro Conference on Real-Time Systems (ECRTS 2019), pp. 21:1–21:23, July 2019.

### For Users
1. Install the package with:
```
pip install sagpy
```

2. Use the `sagpy` Command-Line Interface (CLI) to run the SAG analysis on a set of jobs from a csv file. You must select what SAG algorithm to use. For now there are only 2: `ecrts2019` (the one presented in the paper above) and `ros` (based on ecrts2019, but adapted to analyze ROS2's executor):
```
sagpy overlapping_release_intervals.csv --algorithm ecrts2019
```

3. Output files are by default generated in the `~/USER/.sagpy` folder. 

By default the script generates a csv 
containing the Best Response times (BR) and the Worst Response times (WR) for all given jobs. Moreover, a png with
the visual representation of the SAG is generated as well. Optionally, you can add `--drawio` to generate a drawio
file with a job release plot, so you can better visualize the interference between jobs. Also optionally, the SAG
can be serialized with `pickle` and saved for later use, e.g. making ground truths for testing.

### For Developers
1. Clone the repository.
```
git clone https://github.com/RaduLucianR/sag-py.git
```
2. Change directory in the root folder of the repository.
```
cd sag-py
```
3. Install the package locally. This allows you to run the scripts like they'd be run by the OS. Even if you make changes in the scripts, these
changes will be taken into account when Python runs the script again after install.
```
pip install -e . --break-system-package
```

4. Run the CLI script `sagpy` on a `csv` file that contains a set of jobs:
```
python3 -m src.sagpy.sagpy examples/input_examples/job_sets/overlapping_release_intervals.csv --algorithm ecrts2019
```
5. Output files are by default generated in the `~/USER/.sagpy` folder. 
6. Run the tests running `pytest` from the root directiory:
```
pytest
```
propylean 0.3.0
The pandas and pyspark series wrapper for chemical process industries.
Requires Python: >=3.9

[![Windows](https://github.com/abhishekvraman/Propylean/actions/workflows/build-windows.yml/badge.svg?branch=main)](https://github.com/abhishekvraman/Propylean/actions/workflows/build-windows.yml)
[![macOS](https://github.com/abhishekvraman/Propylean/actions/workflows/build-macos.yml/badge.svg?branch=main)](https://github.com/abhishekvraman/Propylean/actions/workflows/build-macos.yml)
[![Ubuntu](https://github.com/abhishekvraman/Propylean/actions/workflows/build-ubuntu.yml/badge.svg?branch=main)](https://github.com/abhishekvraman/Propylean/actions/workflows/build-ubuntu.yml)
[![License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/abhishekvraman/Propylean/blob/main/LICENSE)
[![PythonVersions](https://img.shields.io/pypi/pyversions/propylean.svg?style=flat)](https://pypi.python.org/pypi/propylean)
# Propylean
#### The open-source analytics and calculation package for chemical process industries.

## What is Propylean
The name is derived from words Process/Production + Python + lean programming/manufacturing.
Propylean is a Python library for analysis of production plants for chemical and related process industries. It wraps Pandas and PySpark series for time-series analysis of instrument data. 
Supports for general calculations like hydraulics, vessel sizing and other process engineering calculations will be provided and constantly updated.

## Installation and Requirements
To download use below command or download the wheel file from PyPi page.

Pip command:
`pip install propylean`

PyPi page:
https://pypi.org/project/propylean/

## Getting Started and Documentation
To get started with Propylean, have a look at the getting started documenation.
https://github.com/abhishekvraman/Propylean/wiki/Getting-started-with-Propylean

## Supported objects that can be imported:

* equipments.rotary
    1. CentrifugalPump
    2. PositiveDisplacementPump
    3. CentrifugalCompressor
    4. TurboExpander
* equipments.static
    1. PipeSegment
* equipments.storage
    1. VerticalStorage
    2. Bullet
    3. Tank
    4. Sphere
* equipments.exchangers
    1. AirCooler
    2. ElectricHeater
* instruments
    1. ControlValve
    2. FlowMeter
    3. PressureGuage
    4. TemparatureGuage
* streams
    1. MaterialStream
    2. EnergyStream
* properties
    1. Pressure
    2. Temperature
    3. MassFlowRate
    4. Components (Molecular components)
    5. Length
    6. Time
    7. Mass
    8. MolecularWeigth
    9. MolarFlowRate
    10. VolumetricFlowRate
    11. Volume
    12. Density
    13. DViscosity
    14. Power
    15. Frequency
mf4processor 2.0.1
A Python library for processing MF4 files
Requires Python: >=3.6

# **MF4Processor**

`MF4Processor` is a Python library for working with `.mf4` files, enabling you to extract channel names, convert specific channel data into CSV format, and retrieve signal data as NumPy arrays.

---

## **Features**
- Extract all channel names from `.mf4` files and save them to a `.txt` file.
- Convert a specific channel's signal data to a CSV file.
- Retrieve signal data as a NumPy array for further analysis.

---

## **Installation**

Install the library using `pip`:

```bash
pip install mf4processor
```

---

## **Usage**

### **1. Import the Library**

```python
from mf4processor.processor import MF4Processor
```

### **2. Load an `.mf4` File**

```python
processor = MF4Processor("path/to/your/file.mf4")
```

### **3. Save All Channel Names to a `.txt` File**

```python
processor.save_channel_names_to_txt("output_channels.txt")
```

### **4. Convert a Channel to CSV**

```python
processor.convert_channel_to_csv("Channel_Name", "output.csv")
```

### **5. Retrieve Signal Data as a NumPy Array**

```python
signal_data = processor.get_signal_as_numpy("Channel_Name")
print(signal_data)
```

---

## **Dependencies**

- `asammdf`
- `pandas`
- `numpy`

These dependencies are installed automatically with the library.

---

## **License**

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

---

## **Contributing**

Contributions, issues, and feature requests are welcome! Feel free to open an issue on the [GitHub repository](https://github.com/varshithvhegde/mf4processor).

---

## **Author**

- **Varshith V Hegde**
- Email: varshithvh@gmail.com

---