semvec/pypi-packages huggingface dataset:
testape 0.1.0
SDK to create extsions for the Testape platform
Requires Python: >=3.10,<4.0

# Testape SDK

[![PyPI - Version](https://img.shields.io/pypi/v/testape.svg)](https://pypi.org/project/testape)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/testape.svg)](https://pypi.org/project/testape)

---

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install testape
```

Then, in your code:

```python
from testape import TestapeClient

client = TestapeClient(api_key="<your_api_key>")

def func():
    client.send_event()
```

## License

`testape` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
software-engineer-assignment-final 1.2.0
Software Engineering assignment for job interview.
Requires Python: >=3.10,<4.0

# Software-engineer-assignment
+ Python project for software engineer job interview. 

### Author
+ Martin P.

### Purpose of the Package
+ Purpose of test assignment is 
to develeop a simple GUI application for connecting and gathering data from encoder device.

### Dependencies
+ serial
+ PyQt5
+ pyqtgraph


### Modules
+ main_app.py - contains main method for the application
+ gui_main.py - contains main gui class 
+ gui_components.py - contains gui component classes for used PyQt widgets
+ gui_alarm_module.py - contains class for logging encoder alarms in to the file
+ encoder_interface.py - contains interface class for encoder
+ serial_interface.py - contains basic class for serial interface

### Main Method/Usage
+ Start the application by calling App() method from main_app.py in your main.py script.

+ Example:

	from software_engineer_assignment import app

	if __name__ == '__main__':
	    app()
tencdec 0.0.1
A number array to/from bytes high performance encoder/decoder.
Requires Python: >=3

# What is tencdec

A number array to/from bytes high performance encoder/decoder.

It gets a list of monotonic increasing integers and can encode it to a byte object very fast in a compressed form using deltas.

Then you may store that byte object in a DB or whatever, and when you need the list of integers back, you just decode it.

Example:

```
>>> numbers = [0, 1, 2, 3, 4, 28, 87, 87, 500, 501, 507, 2313]
>>> enc = tencdec.encode(numbers)
>>> enc
b'\x00\x01\x01\x01\x01\x18;\x00\x9d\x03\x01\x06\x8e\x0e'
>>> dec = tencdec.decode(enc)
>>> numbers == dec
True
```

And it's very fast! 

Using the numbers from the example above, `timeit` shows around 2 microseconds to encode or decode (in a AMD Ryzen 7 PRO 4750U CPU):

```
$ python3 -m timeit -s "import tencdec; numbers = [0, 1, 2, 3, 4, 28, 87, 87, 500, 501, 507, 2313]" "tencdec.encode(numbers)"
100000 loops, best of 5: 2.28 usec per loop
$ python3 -m timeit -s "import tencdec; e = tencdec.encode([0, 1, 2, 3, 4, 28, 87, 87, 500, 501, 507, 2313])" "tencdec.decode(e)"
100000 loops, best of 5: 2.42 usec per loop
```

The restriction are that numbers need to be integers (else encoding will crash with `TypeError`) and monotonic increasing positive (this is verified, otherwise it gets into an infinite loop, but with an `assert` so you may disable the verification running Python with `-O` if you are already sure that list of numbers is ok).

Note that there are no external dependencies for this. It's just Python 3 and its standard library.


## How it works

It encodes a delta of the numbers. Deltas must always positive (that's why source numbers must be monotonic increasing).

If the delta is less than or equal to 127, it's stored directly, otherwise it's stored in multiple bytes, using seven bits on each byte, with the most significant one in 1 if more bytes to process.

E.g. for a simple case:

```
0000 0100 -> 4 (in decimal)
```

Multiple bytes:

```
    1111 0100
    0000 0011
```
- first byte indicates that it goes on, second byte indicates that ends there

- bits are collected without using the most significant one, in reverse order:

    ```
    000 0011 111 0100 -> 0000 0001 1111 0100 -> 500 (in decimal)
    ```
dsigma 0.6.1
A Galaxy-Galaxy Lensing Pipeline
Requires Python: >=3.4
Keywords: astronomy,weak-lensing

![logo](https://raw.githubusercontent.com/johannesulf/dsigma/main/docs/dsigma.png)

[![Unit Testing Status](https://img.shields.io/github/actions/workflow/status/johannesulf/dsigma/tests.yml?branch=main&label=tests)](https://github.com/johannesulf/dsigma/actions)
[![Documentation Status](https://img.shields.io/readthedocs/dsigma)](https://dsigma.readthedocs.io/en/latest/)
[![PyPI](https://img.shields.io/pypi/v/dsigma?color=blue)](https://pypi.org/project/dsigma/)
[![License: MIT](https://img.shields.io/github/license/johannesulf/dsigma?color=blue)](https://raw.githubusercontent.com/johannesulf/dsigma/main/LICENSE)
![Language: Python](https://img.shields.io/github/languages/top/johannesulf/dsigma)
[![ASCL](https://img.shields.io/badge/ascl-2204.006-orange.svg?style=flat)](https://ascl.net/2204.006)

`dsigma` is an easy-to-use python package for measuring gravitational galaxy-galaxy lensing. Using a lensing catalog, it estimates excess surface density around a population of lenses, such as galaxies in the Sloan Digital Sky Survey or the Baryon Oscillation Spectroscopic Survey. It has a broadly applicable API and can utilize data from the Dark Energy Survey (DES), the Kilo-Degree Survey (KiDS), and the Hyper-Suprime Cam (HSC) lensing surveys, among others. With core computations written in C, `dsigma` is very fast. Additionally, `dsigma` provides out-of-the-box support for estimating covariances with jackknife resampling and calculating various summary statistics. Below is a plot showing the excess surface density around galaxies in the CMASS sample calculated with `dsigma`.

![plot](https://raw.githubusercontent.com/johannesulf/dsigma/main/docs/plot.png)

## Authors

* Johannes Lange
* Song Huang

## Documentation

Documentation for `dsigma` with concept introductions, examples, and API documentation is available on [readthedocs](https://dsigma.readthedocs.io/).

## Attribution

`dsigma` is listed in the [Astronomy Source Code Library](https://ascl.net/2204.006). If you find the code useful in your research, please cite [Lange & Huang (2022)](https://ui.adsabs.harvard.edu/abs/2022ascl.soft04006L/abstract).

## License

`dsigma` is licensed under the MIT License.
spritegen 0.1.0
A tool for generating placeholder spritesheets

# Spritegen
Easily generate placeholder sprites sheets for your game.

## Installation
Install package using pip
```bash
pip install spritegen
```

## Usage
This script generates a sprite sheet image, which is a single image file containing a grid of smaller images (sprites).

A row in the sprite sheet consist of multiple sprites with the same reference text and an increasing number.

For example a row can be 10 sprites with text "Idle 0", "Idle 1", "Idle 2" etc.

Each row can have different number of sprites and sprite size.

## How to use

To use spritegen, you will need to provide it with some information about the sprites you want it to include. Specifically, for each row you can specify

- The reference text
- The sprite size
- The number of sprites

You can specify multiple rows of sprites by providing this information multiple times.

The script can be executed from the command line, or you can import it as a module use it in your own python code.

### Command line usage

```bash
spritegen --sprite text size number [-o OUTPUT]
```

For example:

```bash
spritegen --sprite Idle 32 5 --sprite Left 32 3  --sprite Right 32 3 --sprite Boss 128 3
```

This will generate a sprite sheet with 4 rows of sprites. The first row will contain 5 sprites with the text "Idle 0", "Idle 1", "Idle 2" etc. The second row will contain 3 sprites with the text "Left 0", "Left 1", "Left 2". The third row will contain 3 sprites with the text "Right 0", "Right 1", "Right 2". The fourth row will contain 3 sprites with the text "Boss 0", "Boss 1", "Boss 2". First three rows will have sprites of size 32x32 and the last row will have sprites of size 128x128.
eks-pv-encrypter 0.3.0
A simple tool to encrypt the EBS volumes linked to your EKS Persistent Volumes.
Requires Python: >=3.9,<3.10

# EKS Persistent Volume Encrypter

##  What is it?

A tool to detect Persistent Volumes (PVs) in your EKS cluster that are backed by
unencrypted EBS Volumes and encrypt them.

## Do I need it?

If you:

➡️ Have an EKS Cluster.  
➡️ Use Persistent Volumes backed by EBS Volumes.  
➡️ Want to make sure all the EBS Volumes you use are encrypted.  
➡️ Don't want to do it one-by-one.  

Then this tool will help you speed up this process.

## What does it contain?

* A Jupyter Notebook which is the main interface.
* A simple CLI that displays relevant information about your cluster.

The CLI will be limited to read-only actions. The Notebook is the only way to execute
constructive/destructive actions.

## Installation

Hosted on [PyPI](https://pypi.org/project/eks-pv-encrypter/).

`pip install eks-pv-encrypter`

## Usage

1. Use the `pv_encrypter.ipynb` Notebook.
2. If you want a read-only overview of your Cluster. Just run `pv-encrypter status`. 

## Overview of the Process

![Overview](https://raw.githubusercontent.com/VishDev12/eks-pv-encrypter/main/ebs-pv-encrypter.jpg)
fractuversalis 0.1.0a5
Shattered world mod generator for EU4
Requires Python: >=3.7,<4

# Fractuversalis
An EU4 tool to dynamically generate Shattered World mod.

## Description
The project is in stage 1 developing. It is yet to have even basic functionality.

## What to expect...
### ...on 0.1
* Base game is manually specified by the user; it must either be base EU4 folder or overhauled mod folder;
* Generated mod is put locally;
* One province minors generation:
	* Nations take inhabited land, differing on time period;
	* One's name is taken from province it is based on, localization for it is taken from base game;
	* Map color is some deviance from region's color nation is in;
	* Main culture is one that province has;
	* Have generic ideas;
	* No ruler generated.
* Basic flag generation *(e.g. tricolors)* with decent color combinations.

## Pre-release versions in the nutshell
* `x.y.0-alpha.z` - only started developing features promised for `x.y`;
* `x.y.0-beta.z` - features of `x.y` are done in their basis, bugs are possibly easy to find;
* `x.y.0-rc.z` - features of `x.y` are refactored and polished, stage of testing and bugs' hunting.
pheatmap 1.0.1
pheatmap for Python
Requires Python: >=3.8, <4
Keywords: heatmap,gene,expression,visualization

# pheatmap

[![codecov](https://codecov.io/gh/Ann-Holmes/pheatmap/branch/main/graph/badge.svg?token=MTTRU5NLA8)](https://codecov.io/gh/Ann-Holmes/pheatmap)

`pheatmap` for Python.

You can create a heatmap with its annotation bars, just like pheatmap of R. Documnets at [here](https://pheatmap.readthedocs.io/en/latest/)

## Requirements

`pheatmap` need `python` > 3.8, and `numpy`, `pandas` and `matplolib`. 

## Install

You can install `pheatmap` by `pip`. 

```shell
pip install pheatmap
```

Run the command above, `pip` will automatically install `numpy`, `pandas` and `matplolib`.

## Usage

```python
import numpy as np
import pandas as pd
from pheatmap import pheatmap

nrows, ncols = 10, 10
mat = np.linspace(-1, 1, nrows * ncols).reshape(nrows, ncols)
rownames = ["abcdefghig"[i % 10] for i in np.arange(nrows)]
colnames = ["xyz"[i % 3] for i in np.arange(ncols)]

mat = pd.DataFrame(mat, index=rownames, columns=colnames)

anno_row = pd.DataFrame(dict(
    anno1=np.linspace(0, 10, nrows),
    anno2=["CNS"[i % 3] for i in np.arange(nrows)]
))
anno_col = pd.DataFrame(dict(
    anno3=np.linspace(0, 20, ncols),
    anno4=["ABC"[i % 3] for i in np.arange(ncols)]
))

anno_row_cmaps = {"anno1": "Blues", "anno2": "Set1"}
anno_col_cmaps = {"anno3": "Purples", "anno4": "Set3"}

fig = pheatmap(
    self.mat, annotation_row=self.anno_row, annotation_col=self.anno_col,
    annotation_row_cmaps=self.anno_row_cmaps, annotation_col_cmaps=self.anno_col_cmaps
)
fig.savefig("tests/pheatmap.png")
```

Run the above code at the ipython or jupyter notebook. You can see the fellow heatmap with its
annotation bars. 

![heatmap](https://raw.githubusercontent.com/Ann-Holmes/pheatmap/main/pic/pheatmap.png)

Also, you can save the figure to file. For example, save the figure to `PDF` file. 

```python
fig.savefig("pheatmap.pdf")
```