semvec/pypi-packages huggingface dataset:
FireCaptcha 0.0.2.2
Highly customizable captcha generator, written in python
Keywords: captcha,security

# FireCaptcha

Python random captcha package, which is very customizable

## Instalation

- FireCaptcha uses Pillow to generate images, on linux distros you have to install Pillow dependencies alone

```bash
sudo apt-get install libtiff5-dev libjpeg8-dev zlib1g-dev libfreetype6-dev liblcms2-dev libwebp-dev tcl8.6-dev tk8.6-dev python3-tk
```

- then / 1st step on windows

```bash
pip install FireCaptcha
```

## Usage

```python
from FireCaptcha import ImageCaptcha

#initialize captcha instance, specify captcha parameters
p = ImageCaptcha(width=600,
            height=200,
            char_number=5,
            char_color='#13cdc7',
            char_type=3,
            bg_color='#000',
            gradient='#13c',
            misleading_lines=3,
            misleading_dots=20,
            misleading_color='#444444')

#generate captcha, no parameters needed
captcha = p.Generate()

#assign image and answer to separate variable
image = captcha.image
answer = captcha.answer

#saves image to file
image.save('images/test.png')

#prints answer to the captcha
print(answer)
```

## Parameters

```
width: int - width of captcha in px
height: int - height of captcha in px
char_number: int - how many characters should be on captcha
char_color: str - color of characters in hex (with #) e.g: #ff0000
char_type: int<1,4> - type of characters:
    1 - 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
    2 - 'ABCDEFGHIJKLMNOPQRSTUVWXY'
    3 - 'abcdefghijklmnopqrstuvwxyz'
    4 - '0123456789'
bg_color: str - color of background in hex (with #) e.g: #ff0000
gradient: str - color of gradient in hex (with #) e.g: #ff0000 (this color on top, bg_color on botton)
    (if not specified no   gradient)
misleading_lines: int - amount of misleading lines
misleading_dots: int - amount of misleading dots/circles
misleading_color: str - color of misleading components in hex (with #) e.g: #ff0000
```

## Examples

![example 1](https://raw.githubusercontent.com/Memetelve/FireCaptcha/master/images/ex_1.png)
![example 1](https://raw.githubusercontent.com/Memetelve/FireCaptcha/master/images/ex_2.png)
![example 1](https://raw.githubusercontent.com/Memetelve/FireCaptcha/master/images/ex_3.png)
fits2comp 0.0.1
Create composite color images from FITS files
Requires Python: >=3.5

# fits2comp

fits2comp creates composite color images from FITS files using the algorithm of
Lupton et al. ([2004][L04]).  Though the algorithm has been implemented in
Astropy since I wrote the first version of this program,  the main benefit of
fits2comp is that you can call it with a number of options that will take care
of a number of things for you -- no need to code things up.

[L04]: https://ui.adsabs.harvard.edu/abs/2004PASP..116..133L/abstract

You will need to create FITS images in up to three filters by yourself.  The
FITS images need to be on the same grid and are combined pixel by pixel, WCS
information is ignored for this purpose.  The WCS of the red channel is used
for more advanced functionality: drawing a ruler and a compass, and marking
source positions from a file readable as an Astropy table.  For my own science
with the MUSE integral-field spectrograph, I use the `exp_combine` recipe or
the command `muse_cube_filter` to create images in several filters from a data
cube.

fits2comp is a Python 3 package, installable via `pip install fits2comp`.  It
requires Astropy, NumPy, and Pillow-PIL, which will be automatically installed.
It uses argparse, so it accepts the `--help` option.  The most important
options are `-c|--cutoff` and `-s|--softening`, which together set the color
scale of the output image.  You will have to try a few values to get an image
that you like.

Pre-released versions of this package were used to create the images in
Zoutendijk et al. ([2020][PaperI], Fig. 1; [2021a][PaperII], Fig. 1;
[2021b][PaperIII], Fig. 1) As an example, I created the Antlia B image in
Zoutendijk et al. ([2021b][PaperIII], Fig. 1) with

```
fits2comp \
    --cutoff 10 --softening 1 \
    --ruler "30 arcsec" "196 pc" --name "Ant B" --compass \
    --source-list AntB.csv --offset 5 5 \
    AntB_im/DATACUBE_exp_combine-nomask-noautocal_SDSS_i.fits \
    AntB_im/DATACUBE_exp_combine-nomask-noautocal_SDSS_r.fits \
    AntB_im/DATACUBE_exp_combine-nomask-noautocal_SDSS_g.fits \
    AntB_gri.png
```

[PaperI]: https://ui.adsabs.harvard.edu/abs/2020A%26A...635A.107Z/abstract
[PaperII]: https://ui.adsabs.harvard.edu/abs/2021A%26A...651A..80Z/abstract
[PaperIII]: https://ui.adsabs.harvard.edu/abs/2021arXiv211209374Z/abstract

You can find the options used to create a composite image in the
image metadata, in case you forget what options you used after
painstakingly finding the optimal combination for your target.

## Contact

In case of bugs or questions, please file an issue on GitHub or
send me an e-mail: `zoutendijk@strw.leidenuniv.nl`.

## License

This project is licensed under the terms of the [MIT License](LICENSE).
pipedt-hanjing 0.0.1
An unified engine for training and inference for large-scale models
Requires Python: >=3.8

# PDT: Pipeline Decision Transformer

![arch](./arch.png)
<p align="center"><font size=4>Framework Architecture</font></p> 

## TODO
  - [ ] Pipeline model with data scheduler
  - [ ] Performance experiments
  - [ ] Decoupling components from starcraft
backpropagation 0.0.3
Backpropagation Algorithm

# Backpropagation
This module contains the implementation of the backpropagation algorithm

# Usage
```python
    from backpropagation.NeuralNetwork import NeuralNetwork

    from backpropagation.Backpropagation import Backpropagation
    from backpropagation.HyperbolicTangent import HyperbolicTangent
    from backpropagation.ReLU import ReLU
    from backpropagation.Sigmoid import Sigmoid

    nn = NeuralNetwork(input_units, hidden_units, output_units)
    nn.initalize_weights(bais -> boolean)

    bp = Backpropagation(NeuralNetwork, epochs, learning_rate, activation_fuction)
    bp.train(input, target)
    bp.predict(input, actual_output)
```