semvec/pypi-packages huggingface dataset:
pytest-axe-playwright-snapshot 0.0.6
A pytest plugin that runs Axe-core on Playwright pages and takes snapshots of the results.
Requires Python: >=3.8

# pytest-axe-playwright-snapshot

A pytest plugin that runs Axe-core on Playwright pages and takes snapshots of the results.

## Installation

1. Install the plugin:

    ```sh
    python3 -m pip install pytest-axe-playwright-snapshot
    ```

2. Install Playwright browsers:

    ```sh
    python3 -m playwright install --with-deps
    ```

## Usage

In your tests, use the `page` fixture from pytest-playwright along with our plugin's`axe_pytest_snapshot` fixture. Once you've navigated to a page, call `axe_pytest_snapshot` with the `page` fixture as an argument:

```python
from playwright.sync_api import Page

def test_violations(page: Page, axe_pytest_snapshot):
    page.goto("https://www.example.com")
    axe_pytest_snapshot(page)
```

When you run a test for the first time, you must tell it explicitly to save a snapshot:

```sh
pytest --snapshot-update
```

The plugin will take a snapshot of the page and save it to a file in the `snapshots` directory. The snapshot directory will be named after the test function, and the file will be named 'violations.txt'.

On subsequent runs, the plugin will compare the latest snapshot against the snapshot and report any difference in the violations.
polarsai 0.0.32
poalrsai is an integration between the Python Polars library and LLM models created by Aimpoint Digital, LP
Requires Python: >=3.10

# PolarsAI
A library converted from PandasAI to run with the Python Polars library
## Authors
- [Aaron McClendon (Aimpoint Digital)](https://www.github.com/apd-smcclendon)
## Installation
Install my-project with pip
```bash
  pip install polarsai
```
## Requirements
* numpy
streamlit-chrono 0.0.2
Streamlit component that allows you to add Chrono Timeline
Requires Python: >=3.7

# streamlit-chrono

Streamlit port of the react-chrono library. Allows for the rendering of timelines with cards.

## Installation instructions

```sh
pip install streamlit-chrono
```

## Usage instructions

The `streamlit_chrono` API is similar to `react-chrono` interface.

See the documentation at https://github.com/prabhuignoto/react-chrono

```python
import streamlit as st
import json
from streamlit_chrono import chrono

items=[
    {"title": "Home"},
    {"title": "Workflow"},
    {"title": "Diagnostic Features"},
    {"title": "Referential Groups"},
    {"title": "Review Changes"},
    {"title": "Run Workflow"},
]
active_item_index=0

current_item = chrono(
    items=items,
    active_item_index=active_item_index
)

st.write(json.dumps(current_item, indent=4))
```
pymilldb 0.0.14
A python library for MillenniumDB
Requires Python: >=3.10

# PyMillDB: A python library for MillenniumDB

**PyMillDB** is a library that implements modules and classes for interacting with [MillenniumDB](https://github.com/MillenniumDB/MillenniumDB). 

Most of the classes in this library require a `MDBClient` instance, which connects to the `pymilldb_server`, found at the `MillenniumDB-Dev/MillenniumAI` branch.

For the `Doxygen` documentation, follow [this link](https://millenniumdb.github.io/PyMillDB/).

For installing the library, just run the `pip install pymdb` command.
pkhpc1pyr 0.0.4
Scripts and functions for the pharmacokinetic modeling of hyperpolarized [1-13C]-pyruvate.
Requires Python: ~=3.10

<h1> HP C1-Pyruvate Pharmacokinetic Modeling Package for Python </h1>

<h2>
Purpose
</h2>

<ul>
This package was meant to create a more user friendly, open source version of the MATLAB developed by the MD Anderson Magnetic Resonance Engineering Laboratory.
The original repository is available at https://github.com/mda-mrsl/HP-C1Pyr-PK
</ul>

<ul>
These scripts calculate the relationship between [1-13C]-pyruvate and [1-13C]-lactate, but can easily be extended to include other metabolites.
</ul>

<ul>
There are three base models, of differing complexity, which include a different number of physical compartments:
</ul>

<ul>
The scripts titled P2L3*.py describe signal evolution between two chemical pools and three physical compartments. The three-compartment model is the most physiologically accurate among these models, but it is also the most computationally intensive, requiring the largest number of descriptive parameters.
</ul>

<ul>
The scripts titled P2L2*.py are for the PK model with two chemical pools and two physical compartments. Here, HP pyruvate and lactate in the extravascular/extracellular space is assumed to be very well mixed with HP pyruvate in the intracellular space - and separate from pyr/lac in the vascular supply.
</ul>

<ul>
The scripts titled P2L1*.py represent a simple precursor-product model, which does not consider physical compartmentalization of imaging agents. Equivalently, this assumes that all compartments (vascular; extravascular/extracellular; and cellular) are well mixed.
</ul>

<ul>
Each script is accompanied by utilities and a test function which runs a model and plots the results for given parameters. 
</ul>

<h2> 
Installation
</h2>

<ul> Running requires python version 3.10 or compatible </ul>

<ul>
Can be installed from Pypi repository with pip
<br> <i> pip install pkhpc1pyr </i>
<br> The required dependencies can be found in the file requirements.txt and installed with the command 
<br> <i> pip install -r requirements.txt </i>
</ul>

<ul>
The installation can be tested by calling the TestP2L* functions without any arguments. For example:
<br> <i> import pkhpc1pyr as pk 
<br> pk.tests.TestP2L3() </i>
</ul>

<h2> 
Contact
</h2>

<ul>
For questions about code or maintenance please contact Ryan Boyce <br> rboyce@mdanderson.org
<br> For further questions about the original MATLAB repository please contact Dr. Jim Bankson <br> jbankson@mdanderson.org
</ul>
guify 0.3.2
A tool that will GUI-ify your functions

# GUIfy

![PyPI_version](https://img.shields.io/pypi/v/guify?style=for-the-badge)

![PyPI_downloads](https://img.shields.io/pypi/dm/guify?style=for-the-badge)

![PyPI_wheel](https://img.shields.io/pypi/wheel/guify?style=for-the-badge)

Simplest form of GUI for automation scripts.

Made with eel as python backend and react used as frontend.

## **[For Quick Start docs click here](../README.md)**

## Main tab

![main tab](./images/main_tab.png)

## Config tab

![config tab](./images/config_tab.png)

# Running the source code

Since we're using react, there's a custom script [run_debug.py](../run_debug.py) to run the eel backend so it does not conflict with the react dev server port.

If you're working on the frontend use

```bash
npm run start
```

This will start react dev server and run python too in same terminal instance.

If you're working on the python side, it is recommended to run the code in 2 seperate terminals:

```bash
# In first terminal
npm run start:js

# In second terminal
npm run start:guify # or "py ./run_debug.py"
```

This is because unlike React, python won't restart eel session on change of the guify source, so you'd end up restarting python a lot.

# Building

To build the package (wheel and source) in dist folder, run the following:

`npm run build`