semvec/pypi-packages huggingface dataset:
nd-line 0.2.0
Interpolate points on an n-dimensional line by euclidean arc length
Requires Python: >=3.7

# nd_line

Interpolate points on an n-dimensional line by euclidean arc length.

### Installation

`pip install nd_line`

#### Methods

- `ln.interp(dist)`: returns a point dist length along the arc of the line

- `ln.interp_rat(ratio)`: ratio should be a value between 0 and 1, returns a value ratio*length along the line

- `ln.splineify(samples)`: generates a new line from a spline approximation, occurs in place, use samples to specify how many points will be sampled from the splines to generate the new line

#### Attributes

- `ln.points`: the points of the line
- `ln.length`: the length of the line
- `ln.type`: linear if not spline approximated, spline otherwise

#### Example

```python
from nd_line.nd_line import nd_line
import numpy as np

ln = nd_line(np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]]))
interpolated_point = ln.interp(1.5)
line_length = ln.length
halfway_point = ln.interp_rat(0.5)
```

### Notes

Currently points must be sampled one at a time, future version will allow interpolation of a list of distances along the line
sentaku 0.9.1
variadic ux implementation for testing
Requires Python: >=3.8
Keywords: testing

About Sentaku
==============

Sentaku_ is a python library that allows objects to dynamically choose their implementation.
Sentaku_ is the Japanese word for 'choice'.

With Sentaku_ it is possible to describe the elements of the applications you interact with
and the actions/attributes they have.
Sentaku_ takes care of choosing the implementation of the actions/attributes.


Installing
----------

::

	pip install sentaku



Use cases
-----------

A common use for such a system is testing various layers of an application with the same code,
as well as using different layers of an application for setup/teardown and for concise acceptance-tests.


A typical use case is testing your modern html5 application.
Such an application usually consists of different layers.

1. The internal back-end API
2. A rich front-end
3. A REST API
4. APIs that directly interact with other services the application uses

When doing test setup/teardown it is
desirable to run against the fast back-end API or REST API,
while when running the actual acceptance/system tests
it is more desirable to run against the rich user interface or the REST API.

.. _Sentaku: http://pypi.python.org/pypi/sentaku
french-bins 0.2.0
A library for Bins from French banks

# French Bins

`french-bins` est une bibliothÃ¨que Python qui fournit des informations sur les Bins (Bank Identification Numbers) des principales banques franÃ§aises, telles que BNP Paribas, SociÃ©tÃ© GÃ©nÃ©rale, LCL, AXA, CrÃ©dit Mutuel et CrÃ©dit Agricole.

## Installation

Vous pouvez installer `french-bins` en utilisant `pip` :

```bash
pip install french-bins
```

## Utilisation

Pour utiliser french-bins dans votre projet, importez simplement la variable FRENCH_BANK_BINS :

```python
from french_bins import FRENCH_BANK_BINS
```
FRENCH_BANK_BINS est un dictionnaire contenant les informations sur les Bins des banques franÃ§aises. Voici un exemple d'utilisation :

```python
print(FRENCH_BANK_BINS["BNP_Paribas"]["gold"][0])
```

Cela affichera les informations suivantes :

```arduino
{
    'bin': '497462',
    'type': 'CrÃ©dit',
    'bank': 'BNP Paribas',
    'level': 'Gold'
}
```

## Contribuer

Si vous souhaitez contribuer au projet, veuillez soumettre une pull request sur [https://github.com/toomanylog/french-bins](https://github.com/toomanylog/french-bins).

## Licence

french-bins est publiÃ© sous la licence MIT. Voir le fichier LICENSE pour plus de dÃ©tails.
expressgpt 0.1.2
Run chatGPT anywhere

# expressGPT

expressGPT is a handy utility that allows you to run ChatGPT prompts in any window or application just by typing a simple keyword sequence. It provides a quick and convenient way to get assistance from ChatGPT, whether you're drafting an email, writing code, or even coming up with a flirty message for your partner.

## Features

- **Universal ChatGPT access**: Use ChatGPT in any window or application by typing `gpt:` followed by your query and ending the query with `:gpt`.
- **Versatile use cases**: Get help with various tasks, such as drafting emails in your mail app, writing code in a code editor, generating jokes, and more.


## Setup

You need to add your openAI API key and the modelname to the evironment variable:

#### Setting Environment Variables

To use expressGPT, you need to set up the following environment variables:

- `API_KEY_OPENAI`: Your OpenAI API key
- `CHATGPT_MODEL`: The ChatGPT model name for the [model](https://platform.openai.com/docs/models/gpt-3-5) you want to use (e.g., `gpt-3.5-turbo`)

It is recommended to set the variables permanently for ease of use instead of setting them temporary.

You can follow [this](https://kb.wisc.edu/cae/page.php?id=24500) tutorial to setup the environment variable in Windows. 
Follow [this](https://devconnected.com/set-environment-variable-bash-how-to/#:~:text=In%20order%20to%20set%20a,to%20have%20this%20environment%20variable.) tutorial for setting the environment variable in Linux.
For Mac OS use [this](https://phoenixnap.com/kb/set-environment-variable-mac) .


## Installation

You can install expressGPT using pip:

```bash
pip install expressgpt
```

## Usage

Open a terminal and type:

```bash
expressgpt
```

The program will run and to use ChatGPT in any window or application, simply type `gpt:` followed by your query and end the query with `:gpt`. expressGPT will replace your query with ChatGPT's response.
For example, if you're in a text editor and you type:
```
gpt: Who was the winner of the first IPL season :gpt
```
expressGPT will replace the query with ChatGPT's response, like:
```
Rajasthan Royal won the first IPL season. 
```

![](https://i.ibb.co/6PdsG2C/express-GPT.gif)

## Support
If you find expressGPT helpful and want to show your appreciation, consider buying me a cup of coffee:
[![Buy me a coffee](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/DigantPatel)
Your support is greatly appreciated!

Thanks,

Digant Patel 
[www.digantpatel.com](http://digantpatel.com)
postprocessing-variant-calls 0.2.2
This hosts multiple scripts necessary for filtering and processing of variant calls in the vcfs/txt file generated by callers.
Requires Python: >=3.7

# Post-processing of variant calls

This hosts multiple scripts necessary for filtering and processing of variant calls in the vcfs/txt file generated by callers.

## Callers Supported
`pv` is the main command for the `postprocessing_variant_calls` package see `pv --help` to see supported variant callers commands. 

### VarDictJava

The sub-command `pv vardict` allows users to perform post-processing on VarDictJava output. The two supported inputs to `pv vardict` from VarDictJava are `single` and `case-control` vcfs. 

To specify to `pv vardict`, which input type will be used one of the following sub-commands may be used: 
- `pv vardict single` for single sample vcfs 
- `pv vardict case-control` for case-controlled vcfs. 

Next the user can specify, what post-processing should be done. Right now, `postprocessing_variant_calls` supports filtering: 
-  `pv vardict single filter` 
-  `pv vardict case-control filter` 

Finally, we can specify the paths and options for our filtering and run our command. Here is an example using the test data provided in this repository: 

`pv vardict single filter --inputVcf data/Myeloid200-1.vcf  --tsampleName Myeloid200-1  -ad 1 -o data/single`

There are various options and input specifications for filtering so see `pv vardict single filter --help` or `pv vardict single case-sontrol --help` for help. 

See `example_calls.sh` for more example calls. 

### Maf 

maf concat examples: 
- `pv maf concat -f path/to/maf1.maf -f path/to/maf2.maf -o output_maf`
- `pv maf concat -f path/to/maf1.maf -f path/to/maf2.maf -o output_maf -h header.txt`
where `header.txt` is a header file with names by which the mafs will be row-wise concatenated. See `resources/header.txt` for an example.
- `pv maf -p path/to/paths.txt -o output/path/file`
where `path/to/paths.txt` is a txt file with maf path locations. See `resources/paths.txt` for an example. 

maf annotate examples:
- `pv maf mafbybed -m path/to/maf.maf -b path/to/maf.bed -o output/path/file -c annotation`

## How the repo was made

Template used: https://github.com/yxtay/python-project-template

### Usage


#### External dependencies

- [Conda][conda]
- [Docker][docker]
- [Make][make]

#### Create environment

Use Conda to create a virtual environment and activate it for the project.

```bash
conda env create -f environment.yml
conda activate pv_calls
```

#### Install dependencies

Then install project dependencies with Poetry.

```bash
make deps-install
```

#### Updating Environment

To update the environment after initial setup up run: 

```bash
conda env update -f environment.yml
```

instead of `conda create`, and then re-run `make deps-install`
alpha-pca 1.0.2
Phi-Alpha PCA
Requires Python: >=3.7

# Alpha-PCA

Alpha-PCA is more robust to outliers than standard PCA. \
Standard PCA is a special case of alpha PCA (when alpha=1).

* [Usage](#usage)

## Usage

The model is inherited from a sklearn module and works the same way as the [standard PCA](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html). \
It also supports [PyTorch](https://pytorch.org/) tensors (on cpu and GPU).

```python
from alpha_pca import AlphaPCA
import torch 

X = torch.randn(16, 10) # also works with numpy
pca = AlphaPCA(n_components=5, alpha=0.7, random_state=123) # alpha=1 -> standard PCA
pca.fit(X)

# to project X in the latent space
X_transformed = pca.transform(X) # (16, 10) -> (16, 5)

# fit inverse
X_ = pca.inverse_transform(X_transformed) # (16, 5) -> (16, 10)

# directly approximate X_ == inverse_transform(transform(X))
X_ = pca.approximate(X) # (16, 10) -> (16, 10)

# Find the optimal alpha via a reconstruction loss
best_alpha = pca.compute_optimal_alpha(X, n_components=5)
```
wmul_emailer 0.6.0
Utility to send an email to multiple addresses.
Requires Python: >=3.6

# wmul_emailer

Utility to send an email to multiple addresses. Primarily intended for cli applications. The various fields such as server host, username, etc. are entered at the command line, used to construct a wmul_emailer.EmailSender object, and that object is passed into the main part of the script. The main part of the script can use it as needed to report errors or results without having to worry about the e-mail details.

A cli is provided for testing purposes. 

## class EmailSender(server_host, port, user_name, password, from_email_address=None, destination_email_addresses=None)
`server_host` The hostname or ip address of the smtp server.  
`port` The port number on which the smtp server resides.  
`user_name` The username to authenticate with the smtp server.  
`password` The password to authenticate with the smtp server.  
`from_email_address=None` The 'from' e-mail address.  
`destination_email_addresses=None` The e-mail address to which the results should be sent. Must be a list or tuple for multiple addresses, or a str for a single address. 

### send_email(self, email_body, email_subject, from_email_address=None, destination_email_addresses=None)
`email_body` The body of the e-mail to be sent.  
`email_subject` The subject line of the e-mail to be sent.  
`from_email_address=None` The 'from' e-mail address, if provided here. If a `from_email_address` is not included when calling this method, the one provided to the constructor will be used.  
`destination_email_addresses=None` The e-mail address to which the results should be sent, if provided here. If `destination_email_addresses` are not included when calling this method, the ones provided to the constructor will be used. Must be a list or tuple for multiple addresses, or a str for a single address. 

Raises `ValueError` if either `destination_email_addresses` or `from_email_address` are omitted from both the constructor and the call to send_email.

## Command-Line Interface
A cli is provided to test that the credentials are functional and that the system can send e-mails.

`send_test_email --email destination@example.com --server smtp.example.com --port 25 --username myusername --password mypassword --from_address source@example.com`

If everything works, then `destination@example.com` will receive an e-mail from `source@example.com` with the subject `Test e-mail from wmul_emailer` and body `This is the test e-mail from wmul_emailer.py. If you are reading this, the software is configured correctly.`
aws-recommendation-a18 0.1.8
Provides AWS recommendations
Requires Python: >=3.7

# aws_recommendations

aws_recommendations package gives recommendation for you aws account

Release Notes:
# v0.0.28
1. Bug fixes and stability improvements

# v0.0.10
1. Added methods for following recommendations:
   - Low Utilization Amazon EC2 Instances
   - Underutilized Amazon Redshift Clusters
   - idle ebs volumes
   - Idle elb
   - enable s3 bucket keys
   - rds_general_purpose_ssd
   - ebs_general_purpose_ssd
   - unused_ami

# v0.0.7
1. Added methods for new recommendations
2. Added following methods:
   1. reserved_instance_lease_expiration()
   2. unassociated_elastic_ip_addresses()
   3. rds_idle_db_instances()

# v0.0.3
1. Minor bug fixes

# v0.0.2
1. Improved code quality
2. Multi region now supported

# v0.0.1 - Initial Release