semvec/pypi-packages huggingface dataset:
manip 0.2
A manipulation package to change whole folders.

# File manipulation

## Explanation:

<p>The idea is to transform a function that transform one text into another text and call it transforming the desired files with that function.</p>
<p>This is not a package made thinking about being used in a project, rather it's a package made to make a programmer's life easier.</p>

## INSTRUCTIONS:
<p>Decorator that transforms an <b>[str] = function( [str]:text, *args, **kwargs )</b> into an function that apllies itself into a folder.</p>
<p>The default values for the new function can be set at the decorator.</p>
<div class='params'>
<label><b>at</b> - regex to search target files</label>
<label><b>path</b> - folder with files to change (start folder on recursive mode)</label>
<label><b>recursive</b> - makes the function call itself on all folders inside the start folder</label>
<label><b>ignore</b> - ignore changes on file if function returns any error and continues to the next file</label>
<label><b>test</b> - creates a new file with the changes for test (NOT recommended with: recursive = True)</label>
<label><b>prefix/posfix</b> - strings added before and after test files</label>
<label><b>log</b> - shows on console steps</label>
</div>

<p>Default values on decorator are set to avoid writting over important files with broken functions.</p>

### !! ATENTION !!
<p>MAKE SURE TO ALWAYS TEST YOUR FUNCTIONS BEFORE APPLYING ANY TRUE CHANGES.</p>

### Simple functions:

<p>Imagine you want to comment all prints in your project:</p>

~~~
from manip import manip

@manip()
def comment_print(text):
    return text.replace('print(', '# print(')
~~~

<p>Now we can call the function on a folder like:</p>

~~~
comment_print(path='./target')
comment_print(path='./target', test=False) # to save changes on original files
~~~

<p>If you wanna just call a single line function on the command line you can import manipulate:</p>

~~~
from manip import manipulate

manipulate(lambda text: text.replace('print(', '# print('), path='./target', test=False)
~~~

<p>up to change whole files with json data, maybe:</p>

~~~
from manip import manip
import json

@manip(at='.json$')
def join_props(text, prop1='key', prop2='value', new_prop='new'):
    obj = json.loads(text)
    obj[new_prop] = (prop1, prop2)

    del(obj[prop1])
    del(obj[prop2])

    return json.dumps(obj)
~~~

### More info:

[GitHub](https://github.com/Flipecs/file_manip)

<style>
p {
    font-size: 19px;
}

.params {
    display: flex;
    flex-direction: column;
    margin-left: 3%;
    font-size: 17px;

    margin-bottom: 15px;
}
</style>
corels 1.1.29
Python binding of the CORELS algorithm
Requires Python: >=2.7

Welcome to the Python binding of the Certifiably Optimal RulE ListS (CORELS) algorithm! 

Documentation for this package is hosted at: https://corels.eecs.harvard.edu/corels/pycorels/

For information on CORELS, please visit our website: https://corels.eecs.harvard.edu.

For the code of this package, visit: https://github.com/fingoldin/pycorels

CORELS uses Python, Numpy, GMP, and a C++ compiler (g++ is a great choice).
GMP (GNU Multiple Precision library) is not required, but it is *highly recommended*, as it improves performance. If it is not installed, CORELS will run slower.
snowy 0.0.9
Small Image Library for Python 3
Requires Python: >=3.6

[![Build Status](https://travis-ci.org/prideout/snowy.svg?branch=master)](https://travis-ci.org/prideout/snowy)

## Snowy

This is a tiny Python 3 module for manipulating and generating images.
- Simple and flat API. See the [documentation](https://prideout.net/snowy/).
- Supports resize and blur with a variety of filters.
- Honors a specified wrap mode for proper boundary behavior.
- Supports simple OpenEXR images (never clamps colors).
- Written purely in Python 3 and accelerated using [numba](https://numba.pydata.org/).
- Efficiently generates gradient noise and distance fields.

Snowy is somewhat similar to [pillow](https://python-pillow.org/) and
[scikit-image](https://scikit-image.org/), but has a small feature set with some unique abilities.
Painting and 2D paths are outside the scope of the library. See
  [pycairo](https://pycairo.readthedocs.io/en/latest/) or
  [skia-pathops](https://github.com/fonttools/skia-pathops).

<!--

add new section to the doc "Coordinate fields" : mentions CPCF and Warping
    add generate_coords function (should take a dtype)

add "apply_gradient" to color.py

compute_skylight should take wrapx and wrapy

Dithering

Replace "imageio" with "snowyio" which has minimal C code (tinyexr and stb_image)
    Try to support URL's in load
    Look at CairoSVG for inspiration, it takes url, fileobj, etc

CPCF's

Make a video with iterm2 and ipython (or bpython or ptpython)

express the popular "notestrink.py" in terms of snowy operations

prefiltering as seen in docs/hoppe

arbitrary rotation
    RShear: "A Fast Algorithm for General Raster Rotation" by Alan Paeth in Graphics Gems
    http://www.leptonica.com/rotation.html

variable radius blur (radius multiplier is a fn not a constant)
test with a distance field + gradient

tile-based functions (see libvips)

reduce_colors

io can have create_movie
    heat wave example
    brownian loop zoom example

io can have generate_gallery for making HTML, and optional forced width/height/filter

pixel art scaling algorithm(s)

add fractal.py
    mandelbrot example from numba
    also this: https://en.wikipedia.org/wiki/Buddhabrot

generate voronoi or triangulations, like the little test images here:
    http://agea.github.io/tutorial.md/

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Making a release:

  1. Update the version # in generate.py and setup.py, then run generate.py
  2. python3 setup.py sdist bdist_wheel
  3. twine upload dist/*
  4. git push

  consider using travis for this:
      https://docs.travis-ci.com/user/deployment/pypi/

Testing a release:

  open https://pypi.org/project/snowy/
  cd ~ ; python3 -m venv snowy_test
  source snowy_test/bin/activate
  pip install snowy
  python3
      import snowy; import numpy as np
      n = snowy.generate_noise(100, 100, frequency=4, seed=42, wrapx=True)
      snowy.show(n)
      deactivate
  see also:
      https://docs.python-guide.org/dev/virtualenvs/

-->
cusip-generator 0.0.3
Generate modified CUSIPs given Bloomberg Tickers

# cusip_generator
Generate modified CUSIPs given Bloomberg Tickers

# Usage
```bash
    # install the package
    pip install cusip_generator
```

```python
    # in your project
    from cusip_generator import Generator
    generator = Generator('AIH8 Index')
    cusip = generator.convert_to_cusip()
```

# Run Tests
`python -m unittest discover tests`
securitytrailsapi 0.0.1
A wrapper around the SecurityTrails API

# SecurityTrails API
[![Build Status](https://travis-ci.org/hangmansROP/securitytrails-api.svg?branch=master)](https://travis-ci.org/hangmansROP/securitytrails-api) 
[![Known Vulnerabilities](https://snyk.io//test/github/hangmansROP/securitytrails-api/badge.svg?targetFile=requirements.txt)](https://snyk.io//test/github/hangmansROP/securitytrails-api?targetFile=requirements.txt)

This is an initial version of a module that wraps the SecurityTrails API. This should allow you to query each endpoint listed [here](https://docs.securitytrails.com/v1.0/reference).
The API itself doesn't require any form of authentication and so should be fairly easy to use. The main point to bare in mind is on a free account you are limited to 50 requests per month!

It should be noted that this wrapper was tested with a free account. All functionality that requires premium accounts will be marked as *_Experimental_* as I couldn't test it fully. If there's any issues with these endpoints, let me know or feel free to open a PR!
convolution-overlap-add 0.1
Convolution using overlap-add method

# Convolution using Overlap-Add

Implements convolution using overlap-add (OA) method for efficient way to evaluate the discrete convolution of a very long signal. Just for fun. Probably numpy already does that.

[This link explains the overlap-add method.](https://en.wikipedia.org/wiki/Overlap%E2%80%93add_method)

This code is inefficient when compared to pure numpy.convolve ([see this example](example_timing.py)). However, I belive someday we can defeat them.