semvec/pypi-packages huggingface dataset:
package-renan-reis-v2 0.0.1
Pacote simples de processamento de imagens
Requires Python: >=3.8

# package_name

Description. 
The package package_name is used to:
	- 
	-

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install package_name
```

## Usage

```python
from package_name import load_image, apply_grayscale, show_image

img = load_image("IMG-20200517-WA0025.jpg")
gray = apply_grayscale(img)
show_image(gray, cmap="gray")


## Author
Renan

## License
[MIT](https://choosealicense.com/licenses/mit/)
readerraman 0.1.0
Package to load measurement from Cohaerentia Raman DTS
Requires Python: >=3.11

# Reader Raman

Pacchetto per lettura e visualizzazione delle misure salvate da software per sensore DTS Raman.

## Installazione

Tramite `pip`:

```bash
pip install readerraman
```

## Utilizzo

Per prima cosa è necessario caricare il necessario dai due moduli di lettura e visualizzazione:

```python
from ReaderRaman.reader import Single, Multiple
```

### Misura Singola

Lettura di singola misura da un singolo file di tipo json.

```python
singolo = Single("data/2025-09-11_10-10-21,202_CohDTS_50ns_480Kavg_25C.json")
```

Si può fare plot:

```python
singolo.plot().show()
singolo.plot(to_plot='apd_1', title='Prova').show()
```

e con parametro `to_plot` si può scegliere quale dato visualizzare (default 'temperature', altrimenti `apd_1`,`apd_2`,`ratio`).

### Misure multiple in una cartella

Lettura di tutti i file di tipo profilo in una cartella, contenente files di tipo json:

```python
from datetime import datetime
folder = 'data/profiles/'
multiple = Multiple(folder,)
multiple = Multiple(folder, n_measure=10)
multiple = Multiple(folder, n_measure=10, start_measure=5)
multiple.plot()
```

dove il comando di plot è analogo a quello per singola misura.

Inoltre è possibile filtrare per posizione o direttamente plottare andamento nel tempo di una lista di posizioni:

```python
array, real_position_m, index_position = multiple.filter_by_position(1000,to_filter='temperature')
multiple.plot_positions_vs_time(1000,to_plot='temperature').show()
multiple.plot_positions_vs_time([1000,3000],to_plot='apd_1').show()
```

### File hdf5

Si possono esportare in un singolo file h5 tutte le misure lette:

```python
multiple.export_to_h5("misure.h5")
```

E poi possono essere ricaricate con:

```python
from ReaderRaman.reader import MultipleH5

multiple = MultipleH5(filename="misure.h5")
```

e l'oggetto `multiple` potrà essere utilizzato come quello generato dai file `json` in una cartella.

## TODO

- [ ] Permettere di ricalcolare temperatura e ratio fornendo coefficienti differenti.
- [ ] Compensare perdite
guardian_vaultwarden 0.1.1
Vaultwarden ciphers API client

<div align="center">
  <h1>🛡️Guardian🪽</h1>
  <h3>Vaultwarden Ciphers API Client</h3>
</div>

## Introduction

🛡️Guardian🪽 is a Vaultwarden client in Python which lets you to retrieve and decrypt
your ciphers (items in the vault).

## Usage

Install it with pip:

```bash
pip install guardian_vaultwarden
```

Inside your code do:

```python
import guardian_vaultwarden

vault = guardian_vaultwarden.Client(uri, email, password, client_id, client_secret)
# Client id and secret are available in the Vaultwarden webapp, under Settings ->
# Security -> Keys.

vault.login()
cipher = valut.cipher(cipher_id) # UUID of the cipher.

# Returns a decrypted dict with cipher information, like:
#
# {
#   "name": "MY_CIPHER",
#   "login": {
#     "username": "email@email.com",
#     "password": "mypass",
#     ...
#   },
#   ...
# }
```
psx-dashboard-MWBK 0.1.0
A Streamlit dashboard for PSX stock data, including price history and fundamental analysis.
Requires Python: >=3.8

### 📈 PSX Dashboard

A powerful, interactive dashboard built with **Streamlit** to fetch and visualize real-time and historical data from the Pakistan Stock Exchange (PSX). This tool is designed for investors, traders, and analysts to perform quick fundamental and technical analysis on KMI-30 companies.

-----

### ✨ Features

  * **Real-Time Data**: Fetches live trading metrics, including price, volume, and bid/ask spread, for a chosen stock.
  * **Historical Analysis**: Displays interactive historical price and volume charts for any selected date range.
  * **Fundamental Metrics**: Retrieves and presents key fundamental data such as P/E Ratio, profit margins, and earnings per share (EPS).
  * **Financials at a Glance**: Provides detailed annual and quarterly financial statements, including sales, profit, and key ratios.
  * **Payout History**: Shows a comprehensive history of dividends and bonus payouts.
  * **User-Friendly Interface**: An intuitive, web-based interface built with Streamlit, making it easy to use for all levels of users.

-----

### 🛠️ Installation

1.  **Clone the repository**:

    ```bash
    git clone https://github.com/your-username/psx-dashboard.git
    cd psx-dashboard
    ```

2.  **Install dependencies**:

    ```bash
    pip install -r requirements.txt
    ```

    This will install all required libraries, including `streamlit`, `pandas`, `requests`, `beautifulsoup4`, `plotly`, and `numpy`.

-----

### 🚀 Usage

To run the dashboard, execute the following command in your terminal from the project's root directory:

```bash
streamlit run psx_dashboard.py
```

This command will start a local web server and open the dashboard in your browser.

#### How to use the dashboard:

1.  **Select a Company**: Use the dropdown menu in the sidebar to choose a company from the KMI-30 index.
2.  **Set Date Range**: Select a start and end date to view historical data for a specific period.
3.  **Fetch Data**: Click the "Fetch Data" button to load all the information.

-----

### 💡 Data Source & Limitations

All data is scraped from the **Pakistan Stock Exchange (PSX) website**.

  * **Data Accuracy**: The data presented is dependent on the information available on the PSX website. Occasional discrepancies or missing data points may occur.
  * **No API**: This tool relies on web scraping rather than an official API, which means its functionality may be affected by changes to the PSX website's structure.
  * **Delay**: Data is fetched in real-time but may have a slight delay depending on network speed and the time required for scraping.

-----

### 📝 License

This project is licensed under the **MIT License** - see the `LICENSE` file for details.
py-simple-sharepoint 1.1.0
A SharePoint file management tool for python programs.
Requires Python: >=3.10

# Simple SharePoint

This package is designed to be a simple code interface to manage files in a SharePoint account.

## How to Install

``pip install py_simple_sharepoint``

## How to Use

```py
import os
from py_simple_sharepoint import SharePointClient

sp = SharePointClient(
    tenant_id=os.getenv("SHAREPOINT_CLIENT_TENANT_ID"),
    client_id=os.getenv("SHAREPOINT_AZURE_APPLICATION_ID"),
    cert_path=r"Certificate.cer",
    key_path=r"Certificate.key",
    site_hostname="<sitename>.sharepoint.com",
    site_path='/sites/<location>',
    library_title='Documents'
)

files = sp.get_files(files_path)
sp.create_folder(folder_path='Path/to/New Folder')
sp.upload_file(local_path='file.txt', target_folder='Path/to/Upload Folder')
sp.download_file(file_path='Path/to/file.txt', download_dir='local/path/to/folder')
sp.move_file(file_path='path/to/file.txt', target_folder='other/path/to/file')
sp.rename_file(file_path='path/to/file.txt', new_name='path/to/new file name.txt')

```
pingdat 1.6.3
A simple ping exporter for Prometheus metrics.
Requires Python: <4,>=3.10

# pingdat #

[![PyPI](https://img.shields.io/pypi/v/pingdat.svg)](https://pypi.org/project/pingdat)
[![LICENSE](https://img.shields.io/github/license/jheddings/pingdat)](LICENSE)
[![Style](https://img.shields.io/badge/style-black-black)](https://github.com/ambv/black)

A Prometheus exporter for ping statistics.

## Installation ##

Install the published package using pip:

```shell
pip3 install pingdat
```

This project uses `uv` to manage dependencies and a local virtual environment.  To
get started, clone the repository and install the dependencies with the following:

```shell
uv sync
```

### Grafana Dashboard ###

A Grafana dashboard is available as #(17922)[https://grafana.com/grafana/dashboards/17922].

## Usage ##

Run the module and tell it which config file to use.

```shell
python3 -m pingdat --config pingdat.yaml
```

If you are using `uv` to manage the virtual environment, use the following:

```shell
uv run pingdat --config pingdat.yaml
```

### Docker ###

`pingdat` is available as a published Docker image.  To run, use the latest version:
from Docker Hub:

```shell
docker container run --rm --publish 9056:9056 "jheddings/pingdat:latest"
```

The configuration file is read from `/opt/pingdat/pingdat.yaml` and may be changed
with arguments to the container:

```shell
docker container run --rm --tty --publish 9056:9056 \
  --volume "/path/to/host/config:/etc/pingdat" \
  "jheddings/pingdat:latest" --config /etc/pingdat/pingdat.yaml
```

## Docker Compose ##

A sample configuration is also provided for using `docker compose`.  Similar to using
Docker directly, the configuration file can be provided on the host side.  Then,
simply start the cluster normally:

```shell
docker compose up
```

Or detached as a background process:

```shell
docker compose up --detach
```

## Configuration ##

For now, review the sample `pingdat.yaml` config file for a description of supported
configuration options.
guardian-vaultwarden 0.1.0
Vaultwarden ciphers API client

<div align="center">
  <h1>🛡️Guardian🪽</h1>
  <h3>Vaultwarden Ciphers API Client</h3>
</div>

## Introduction

🛡️Guardian🪽 is a Vaultwarden client in Python which lets you to retrieve and decrypt
your ciphers (items in the vault).

## Usage

Install it with pip:

```bash
pip install guardian
```

Inside your code do:

```python
import guardian

vault = guardian.Client(uri, email, password, client_id, client_secret)
# Client id and secret are available in the Vaultwarden webapp, under Settings ->
# Security -> Keys.

vault.login()
cipher = valut.cipher(cipher_id) # UUID of the cipher.

# Returns a decrypted dict with cipher information, like:
#
# {
#   "name": "MY_CIPHER",
#   "login": {
#     "username": "email@email.com",
#     "password": "mypass",
#     ...
#   },
#   ...
# }
```
pdnl-sana 1.0.4
PDNL Semi-Automatic Neuropathology Analyis (SANA)
Requires Python: >=3.9

# PDNL Semi Automatic Neuropath Analysis (PDNL-SANA)

## About

PDNL-SANA is a python-based package written by the [Penn Digital Neuropathology Lab](https://www.med.upenn.edu/digitalneuropathologylab/) to formalize our methods of IHC quantification. PDNL-SANA includes functions which facilitate extracting pixel data from a Whole Slide Images (WSI), classifying pixels, and converting positive pixel masks to quantifications. 

## Requirements

python3.9 or greater

## Installation

`python3 -m pip install pdnl_sana`

## Getting Started

We provide several example [Jupyter](https://jupyter.org/) notebooks which contain example code blocks utilizing most of SANA's functionality.

* `docs/source/examples/example0_prepare_images.ipynb` shows how to extract relevant ROI information from a WSI
* `docs/source/examples/example1_process_images.ipynb` provides a sandbox for the preprocessing and pixel classification methods
* `docs/source/examples/example2_normalize_cortex.ipynb` illustrates how to deform a curved section of cortex for more optimal quantification
* `docs/source/examples/example3_quantification.ipynb` has examples of various quantification methods based on the positive pixel masks created by the previous notebooks

For more information, please refer to the [Documentation](https://pdnl-sana.readthedocs.io/en/latest/)

## Roadmap
* GPU Acceleration 
* Automatic GM/WM segmentation
* Generic cell detection/segmentation
* Microglia detection/segmentation
* Structure Tensor Analysis
rten-convert 0.22.0
Convert ONNX models to .rten format
Requires Python: >=3.10

# rten-convert

rten-convert converts ONNX models to `.rten` format, for use with the
[RTen](https://github.com/robertknight/rten) machine learning runtime.

## Installation

The conversion tool requires Python >= 3.10. To install the tool, run:

```sh
pip install rten-convert
```

## Usage

```sh
rten-convert your-model.onnx your-model.rten
```

The second argument is optional. If omitted the output filename will be the
input filename with the `.onnx` extension replaced with `.rten`.

## Versioning

The `rten-convert` tool and `rten` library use common version numbering. A
model produced by `rten-convert` version X can be executed by `rten` version X
or newer.

## Development

To install this tool from a checkout of the Git repository, run:

```sh
pip install -e .
```

After making changes, run the QA checks. First, install the development
dependencies:

```
pip install -r requirements.dev.txt
```

Then run:

```
make check
```
mini-control-arena 0.1.0rc6
A lightweight library for running AI Control experiments
Requires Python: >=3.12

# Mini Control Arena

Last Updated: Aug 31st

A lightweight library for running [AI Control](https://arxiv.org/abs/2312.06942) experiments.

This library is still being built and is likely not stable yet.

## Documentation

**Documentation: [is hosted here](https://brucewlee.github.io/mini-control-arena)**

The documentation covers:
- Setting up your environment
- Understanding templates vs environments
- Customizing evaluations
- API reference

## License

Not licensed yet
zpic 0.1.2
A fork of the https://github.com/zpic-plasma/zpic project which attempts to integrate the python functionality as a standalone pip package for convenience
Requires Python: >=3.10

[![PyPI](https://img.shields.io/pypi/v/zpic)](https://pypi.org/project/zpic)

# ZPIC

A fork of the https://github.com/zpic-plasma/zpic project which attempts to integrate the python functionality as a standalone pip package for convenience. Installation instructions are present [here](#installation). Information about **zpic** itself is present at the origin repository and documentation page.

> Particle-in-Cell (PIC) codes are used in almost all areas of plasma physics, such as fusion energy research, plasma accelerators, space physics, ion propulsion, and plasma processing, and many other areas. Leveraging on our expertise and experience from the development and use of the OSIRIS PIC code, we have developed a suite of 1D/2D fully relativistic electromagnetic PIC codes, as well as 1D electrostatic. These codes are self-contained and require only a standard laptop/desktop computer with a C compiler to be run. The output files are written in a new file format called ZDF that can be easily read using the supplied routines in a number of languages, such as Python, and IDL. The code suite also includes a number of example problems that can be used to illustrate several textbook and advanced plasma mechanisms, including instructions for parameter space exploration. We also invite contributions to this repository of test problems that will be made freely available to the community provided the input files comply with the format defined by the ZPIC team.

## Documentation

The project now has its own dedicated website on GitHub pages. You can find all the documentation at [https://zpic-plasma.github.io](https://zpic-plasma.github.io)

## Installation

**zpic** may be installed with 
```
pip install zpic
```
The compilation process from the documentation is run for multiple OSes and platform specific wheels are provided. More details can be found on the PyPI page. 

| OS      | Compatibility |
| ------- | ------------- |
| Linux   | >= python3.10 |
| MacOS   | >= python3.10 |
1joepie-prank 0.4.0
Joepie's prank tools: safe fake hacker GUIs, terminals and effects (more realistic)
Keywords: prank, gui, fun, fake, toy

# 1joepie-prank (import as `joepie_tools`) — v0.4.0

**Safe, visual prank toolkit**. New in 0.4.0:
- **Sounds:** beep, alarm loop, typewriter clicks, error ding
- **New tools:** Fake BSOD, Fake Update Screen, Fake Virus Scan, Random Popups
- **Runner:** `run_full_prank()` with consent modal + reveal hotkey (F12) + stop-all
- **Improvements:** more realistic terminal output/themes; stop events

> This is 100% visual. It does **not** run real hacks, delete files, or scan networks. Use responsibly and always tell people it's a joke afterwards.

## Install (dev)
```bash
python -m pip install --upgrade build twine
python -m pip install -e .
```

## Quick usage
```python
from joepie_tools.hackerprank import run_full_prank
run_full_prank(require_ack=True, beep=True, reveal_hotkey="F12", num_windows=3, duration=8.0)
```

## CLI
```bash
python -m joepie_tools.cli hack -n 4 -d 10
python -m joepie_tools.cli matrix -d 12
python -m joepie_tools.cli term -d 8
python -m joepie_tools.cli dump -d 6
python -m joepie_tools.cli popup -m "Just kidding!" -d 4
python -m joepie_tools.cli bsod -d 8
python -m joepie_tools.cli update -d 15
python -m joepie_tools.cli scan -d 12 --max 500
python -m joepie_tools.cli popups -c 12 -d 8
python -m joepie_tools.cli runfull --beep --ack --hotkey F12 -n 3 -d 8
```

## Build & publish
```bash
python -m build
python -m twine upload --repository testpypi dist/*
# If OK:
python -m twine upload dist/*
```
LightGeometry 1.0.1
Light geometry library with essential function
Requires Python: >=3.9
Keywords: python, library, geometry, math

# LightGeometry
## A python library with elementar function
### note: every function returns float

## ```pip install lightgeometry```

- ```circle_area(radius)```:
returns area of a circle giving the radius
**ex: circle_area(3) = 28.27**

- ```circle_perimeter(radius)```:
returns perimeter of a circle giving the radius
**ex: circle_perimeter(3) = 18.85**

- ```circle_radius(area)```:
returns radius of a circle giving the area
**ex: circle_radius(4) = 1.13**

- ```rectangle_area(base, height)```:
returns area of a rectangle or square giving base and optionally height
**ex: rectangle_area(2) = 4 / rectangle_area(2, 4) = 8**

- ```rectangle_diagonal(base, height)```:
returns diagonal of a rectangle or square giving base and optionally height
**ex: rectangle_diagonal(2, 4) = 4.47**

- ```rectangle_perimeter(base, height)```:
returns perimeter of a rectangle or square giving base and optionally height
**ex: rectangle_perimeter(2, 4) = 12**

- ```triangle_area(base,  height)```:
returns area of a triangle giving base and height
**ex: triangle_area(2, 6) = 6**

- ```triangle_height(base,  area)```:
returns height of a triangle giving base and area
**ex: triangle_area(2, 6) = 6**

- ```triangle_perimeter(base,  area)```:
returns perimeter of a triangle giving base and area
**ex: triangle_area(2, 6) = 16**

- ```polygon_perimeter(s1, s2...s)```:
returns perimeter of a polygon giving differents sides
**ex: polygon_perimeter(1,5,3,6) = 15**

- ```distance_2d(x1,y1, x2,y2)```:
returns distance between 2 points
**ex: distance_2d(1,1, 3,3) = 2, 2**

- ```distance_3d(x1,y1,z1, x2,y2,z2,)```:
returns distance between 2 3d points
**ex: distance3d(1,1,1, 3,3,3) = 2, 2, 2**

### https://pypi.org/project/LightGeometry/
lab2mod267128850 0.1.1
A simple example package with basic calculation of RK2 and  RK4.
Requires Python: >=3.7

# lab2mod267128850

`lab2mod167128850` is a lightweight Python package that provides simple utility functions
for **RK2**, **RK4**
It is designed mainly for learning purposes and as an example of Python packaging.

---

## Features
##### Runge-Kutta 2nd Order Method
To solve the initial value problem (IVP) of ordinary differential equations (ODEs) using the Runge-Kutta 2nd Order Method.
        

The function returns a list of tuples, where each tuple contains the values of x and y at each step.
##### Runge-Kutta 2nd Order Method
To solve the initial value problem (IVP) of ordinary differential equations (ODEs) using the Runge-Kutta 2nd Order Method.
        
f : is a function that defines the ODE in the form dy/dx = f(x, y).

The function returns a list of tuples, where each tuple contains the values of x and y at each step.

---

## Installation

You can install the package directly from PyPI:

```bash
pip install lab2mod267128850
cykooz.heif 1.3.0
A decoder of HEIF format of images
Requires Python: >=3.9
Keywords: heif, heic, libheif, pil, pillow

# cykooz.heif

`cykooz.heif` is simple python wrapper for the library [libheif-rs](https://crates.io/crates/libheif-rs).

`RawHeifImage` is a simple wrapper around low level HEIF-decoder.

[CHANGELOG](https://github.com/Cykooz/cykooz.heif/blob/master/CHANGES.md)

## Usage Examples

Read HEIF-image from a file:

```python
from cykooz.heif.image import RawHeifImage


img = RawHeifImage.from_path('data/test.heif')
assert img.width == 3024
assert img.height == 4032
assert img.mode == 'RGB'
assert len(img.data) == 36578304
assert img.stride == 9072
assert len(img.exif) == 2026
```

Read HEIF-image from file-like object:

```python
from cykooz.heif.image import RawHeifImage


with open('data/test.heif') as fp:
    img = RawHeifImage.from_stream(fp)
    assert img.width == 3024
    assert img.height == 4032
```

Also package provides an opener plugin for `PIL` (`Pillow`):

```python
from PIL import Image
from cykooz.heif.pil import register_heif_opener


register_heif_opener()
img = Image.open('data/test.heif')
assert isinstance(img, Image.Image)
assert img.size == (3024, 4032)
assert img.mode == 'RGB'
assert img.getpixel((100, 100)) == (73, 74, 69)
img.save('test.jpg', 'JPEG')
```

## Installation from source

System requirements:

- libheif-dev >= 1.18 (https://github.com/strukturag/libheif)
- python3-dev
- Rust 1.78+ (https://www.rust-lang.org/)
lab2mod167128850 0.1.1
A simple example package with basic calculation of fixed_point_iteration and  false_position.
Requires Python: >=3.7

# lab2mod167128850

`lab2mod167128850` is a lightweight Python package that provides simple utility functions
for **fixed_point_iteration**, **false_position**
It is designed mainly for learning purposes and as an example of Python packaging.

---

## Features


---

## Installation

You can install the package directly from PyPI:

```bash
pip install lab2mod167128850