semvec/pypi-packages huggingface dataset:
stressrunner 1.1.13
A stressrunner similar as TextTestRunner for stress test, support for html report.
License: MIT
Requires Python: >=3.4.0
Keywords: stress,stressrunner,html,unittest

# stress-runner
A runner similar as TextTestRunner for stress test, support for html report.
Based on unittest, support iterative exection, html report, send html report, etc.

# Install
```shell script
pip install stressrunner -U
```

# Quick Start:
A TestRunner for use with the Python unit testing framework. It
generates a HTML report to show the result at a glance.
The simplest way to use this is to invoke its main method. E.g.
```python
from stressrunner import runner
# define your tests

if __name__ == '__main__':
    runner.main()
```
For more customization options, instantiates a StressRunner object.
StressRunner is a counterpart to unittest's TextTestRunner. E.g.
```python
# output to a file
from stressrunner import StressRunner

runner = StressRunner(
    report_path='./report/test.html',
    test_title='My unit test',
    desc='This demonstrates the report output by StressRunner.'
)
```
hera-py 1.0.7
Interpreter for the Haverford Educational RISC Architecture (HERA) assembly language
License: MIT

# hera-py

[![Build Status](https://travis-ci.com/iafisher/hera-py.png)](https://travis-ci.com/iafisher/hera-py)
[![Coverage Status](https://coveralls.io/repos/github/iafisher/hera-py/badge.svg?branch=master)](https://coveralls.io/github/iafisher/hera-py?branch=master)
[![PyPI](https://img.shields.io/pypi/v/hera-py.svg?label=version)](https://pypi.org/project/hera-py/)

A toolkit for the [Haverford Educational RISC Architecture](http://cs.haverford.edu/resources/hera) (HERA) assembly language, comprising an interpreter, a debugger, an assembler, and a disassembler.

## Installation
You can install hera-py with pip:

```
$ pip3 install hera-py
```

## Usage
After installation, use the `hera` command to run a HERA program:

```
$ hera main.hera
```

Enter the interactive debugger with the `debug` subcommand:

```
$ hera debug main.hera
```

Assemble a HERA program into machine code:

```
$ hera assemble main.hera
```

Disassemble machine code back into the human-readable HERA syntax:
```
$ hera disassemble main.hera.lcode
```

You can also preprocess a HERA program without running it, to see how pseudo-instructions and labels are resolved to HERA code:

```
$ hera preprocess main.hera
```

## Comparison with HERA-C and Hassem
HERA-C is the current HERA interpreter used at Haverford. It is implemented as a shell-script wrapper around a set of C++ macros that expand HERA instructions into C++ code, which is then compiled by g++.

hera-py improves on HERA-C in the following areas:

  - Includes a purpose-built HERA debugger
  - Concise and accurate error messages
  - Ease of use
    - Cross-platform and easy to install
    - Configurable with command-line options
    - Does not create temporary files
    - Command name has six fewer letters than `HERA-C-Run`

hera-py also supports several features that HERA-C does not:
  - Setting registers to the value of a label
  - Detecting stack overflow
  - Multi-precision multiplication
  - Relative branching by a fixed integer value (e.g., `BRR(10)`)
  - Branching by the value of a register (e.g., `SET(R1, 20); BR(R1)`)
  - Detecting invalid relative branches

HERA-C has a few features that hera-py does not:
  - C-style #define macros (and more generally the ability to embed arbitrary C++ code in HERA programs)

Small to medium-sized programs generally run faster with hera-py than with HERA-C, while very large programs are typically faster with HERA-C.

Hassem is the current HERA assembler used at Haverford. hera-py has better error messages than Hassem, allows the user greater control of output (e.g., with the `--stdout` flag), and fixes some Hassem bugs.

## Acknowledgements
Thank you to [Christopher Villalta](https://github.com/csvillalta) for valuable feedback on early iterations of this project.
mvpa 1.0.0
Multi-voxel pattern analysis (MVPA) tool for fMRI data
License: MIT
Requires Python: >=3
Keywords: mvpa,fmri,correlation

# mvpa

`mvpa` is a multi-voxel pattern analysis tool for fMRI data. Given a subject's fMRI scans for two conditions (e.g. exposure to two different stimuli), this tool can identify distinct patterns of responses for each condition. It's adapted from the method described in _[Distributed and Overlapping Representations of Faces and Objects in Ventral Temporal Cortex](https://science.sciencemag.org/content/293/5539/2425)_, except searchlight spheres are analyzed instead of anatomical ROIs.

<p align="center">
  <img src="method.png" />
</p>

Notably, this tool is less computationally expensive than a SVM-based searchlight.

## Installation

`mvpa` can be installed from PyPi:

```bash
$ pip install mvpa
```

## Usage Example

### Load the Haxby dataset

```python
import pandas as pd
from nilearn.datasets import fetch_haxby

# We fetch 2nd subject from haxby datasets (which is default)
haxby_dataset = fetch_haxby()

fmri_filename = haxby_dataset.func[0]
labels = pd.read_csv(haxby_dataset.session_target[0], sep=" ")
y, session = labels["labels"], labels["chunks"]
```

### Restrict to faces and houses

```python
from nilearn.image import index_img

face_mask = y.isin(["face"]) # Condition A
house_mask = y.isin(["house"]) # Condition B

face_niimg = index_img(fmri_filename, face_mask)
house_niimg = index_img(fmri_filename, house_mask)
```

### Prepare input data

```python
from nilearn.image import load_img
from mvpa import even_odd_split

face_niimg_even, face_niimg_odd = even_odd_split(face_niimg)
house_niimg_even, house_niimg_odd = even_odd_split(house_niimg)

A = [(face_niimg_even, face_niimg_odd)]
B = [(house_niimg_even, house_niimg_odd)]
mask_img = load_img(haxby_dataset.mask)
```

### Run correlation searchlight

```python
from mvpa import correlation_searchlight, significance_map

score_maps = correlation_searchlight(A, B, mask_img, radius=3)
# t_map, p_map = significance_map(score_maps, mask_img) # Only used for datasets
                                                        # with multiple subjects
```

`score_maps` is a list of paths to NIfTI files, each representing the significance scores for each voxel in a subject's scan.

### Visualize results

```python
from nilearn.image import mean_img
from nilearn.plotting import plot_stat_map

score_map = load_img(score_maps[0])
plot_stat_map(score_map, bg_img=mean_img(fmri_filename), colorbar=True,
              display_mode="z")
```

<img src="demo.png" />
EAMetatrader 1.0.4
Metatrader library for python
License: MIT
Keywords: EAMetatrader,Metatrader,Metatrader4,Metatrader5,python+metatrader,MtApi,mql4,mql5

# EAMetatrader

![Python Version](https://img.shields.io/badge/Python%20Version-3-blue) \
![OS Support](https://img.shields.io/badge/OS%20Support-WIN--64-lightgrey) \
![GitHub](https://img.shields.io/github/license/EAScript/EAMT)

## Metatrader library for python powered by MtApi
This library currently only supports MetaTrader 4

## Installation
- Install the library with the `pip install EAMetatrader` command
- Copy and run the `MtApi.ex4` file in MetaTrader software
- Set up a `port` in Expert and Application for network connection
- and over
 
### Required libraries
```Python
from EAMetatrader import MT4Client,Color
from EAMetatrader.Enums import *
import datetime
```

### Connection
```Python
client = MT4Client(True)
client.Connect(8222)
```

### Copy Rates
```Python
start = datetime.datetime(2021,3,16)
end = datetime.datetime(2021,3,1)

mqlrate = client.CopyRates("EURUSD",ENUM_TIMEFRAMES.PERIOD_H1,start,end)
print(mqlrate.Time(2))
```

### Indicators
```Python
Symbol = "EURUSD"
Timeframe = 60
Period = 14
Appliedprice = 0  #Close
Shift = 0

RSI = client.iRSI(Symbol,Timeframe,Period,Appliedprice,Shift)
```

### Send Order
```Python
Lot = 0.01
Price = 1.18
SL = 1.17800
TP = 1.18400
Slippage = 5
Comment = "EAMT"
Magic = 2222
Expiration = datetime.datetime(2021,3,25)
color = Color()

Order = client.OrderSend("EURUSD",TradeOperation.OP_BUY,Lot,Price,Slippage,SL,TP,Comment,Magic,Expiration,color.Green())
```

## TODO
- Debug some functions
- Write MT5Client class
- Development of functions for working with artificial intelligence

## Issues
If you have a question or want to report a bug, send it in this section

## My social medias
[LinkedIn](https://www.linkedin.com/in/ehsan-akbari-0487ba187)

[Instagram](https://instagram.com/ea.forex.programmer)

[YouTube](https://youtube.com/channel/UCCmSFoxq8NNlmGs9I3T5QLA)

[Github](https://github.com/EAScript)

## Donating
[PyPal](https://www.paypal.me/eaforexprogrammer)

Bitcoin: `1LsuAxGGdfH43YpgSjY8CSZdX45r4BE4jx`

![QRCode](https://i.ibb.co/sQ4QqMk/My-Bit-Coin-Wallet.png)
galene-rtmp 0.1.0
Gateway to send RTMP streams to Galène videoconference server.
License: MIT
Keywords: galene,rtmp,webrtc,gstreamer

# Galène RTMP gateway

Gateway to send RTMP streams to
[Galène videoconference server](https://galene.org/).
It is based on Gstreamer RTMP and WebRTC support and implements the Galène
protocol.

## User guide

Real-time video conversion requires resources. If many users are going to use
this gateway simultaneously, you should scale your machine resources
accordingly.

### Installation using Python Virtualenv

Start by cloning the source code,

```bash
git clone https://github.com/erdnaxe/galene-rtmp
cd galene-rtmp
```

Then create a Python virtualenv and install galene-rtmp inside,

```bash
python -m venv venv --system-site-packages
source venv/bin/activate
pip install -e .
```

You need a NGINX RTMP server, you may remix the provided
[nginx.conf](./docs/nginx.conf).

```
nginx -c nginx.conf -p $PWD
```

You may now launch the gateway using:

```
python -m galene_rtmp --server "wss://galene.example.com/ws" --group test --username bot
```

## Contributing

See [contributing guidelines](./CONTRIBUTING.md).

## Authors

This gateway is currently developed by members from
[Crans](https://www.crans.org/)
and [Aurore](https://auro.re/) network organizations to build a self-hosted
free and open-source streaming server.

Main contributors:

-   Alexandre Iooss

## License

We believe in open source software.
This project is licensed under [MIT](./LICENSE.txt).
secure-password-generator 0.0.1
a short summary about the package
License: MIT
Keywords: password generator

this is a simple password generator, we have to give number of character for the password
"num" will the number of characters for the password 
example:
import secure-password-generator
num=8
password(num)


Change Log
==========

0.0.1 (29/03/2021)
-------------------
- First Release
grid-captcha 1.0.2
Python Grid Captcha Generator
License: MIT
Keywords: grid,captcha,generator

# Python Grid Captcha Generator

### Installation

    pip install grid_captcha

Or download the tarball / `git clone` and...

    python setup.py install

### Usage
```python
from grid_captcha import CaptchaBuilder

builder = CaptchaBuilder()  # Create builder
builder.build()  # Generate new image

word = builder.word

builder.show()

builder.save('1.jpeg')

image_jpeg = builder.base64()
image_png = builder.base64(image_format='PNG')
```

### Examples

![Example 3](examples/0.jpeg)

![Example 1](examples/1.jpeg)

![Example 2](examples/2.jpeg)

![Example 3](examples/3.jpeg)

![Example 3](examples/4.jpeg)

![Example 3](examples/5.jpeg)

![Example 3](examples/6.jpeg)

![Example 3](examples/7.jpeg)

![Example 3](examples/8.jpeg)

![Example 3](examples/9.jpeg)
recache 1.0.0
Cache functions to speed up recursion
License: MIT

# recache

Cache functions to speed up recursion

## install

From Pypi:

`python -m pip install recache`

From GitHub:

`python -m pip install git+https://github.com/donno2048/recache`

## Usage

```py
from recache import cache
def fib(n): # slow recursion
    if n < 0: return None
    if n <= 1: return 1
    return fib(n - 1) + fib(n - 2)
@cache
def cfib(n): # fast recursion
    if n < 0: return None
    if n <= 1: return 1
    return cfib(n - 1) + cfib(n - 2)
```

To see the exact timing see [The notebook](https://github.com/donno2048/recache/blob/master/fib.ipynb)