semvec/pypi-packages huggingface dataset:
certiGenerator 1.0.2
Easily generate participation certificates using this package
Requires Python: >=3.0

# certiGenerator

Now easily generate participation certificates digitally using this package.

The package takes following six inputs --
1. Certificate template path
2. Organization's logo
3. Participant's name
4. Event name
5. Organization name
6. Issuer name
7. Output Path to save the generated certificate


# Libraries required

This package requires opencv to write information onto the certificates.


# Sample Code

import certiGenerator <br />
api = certiGenerator.certiGenerator() <br />

api.generate_certificate("certificate_template.png","google.png","Yatharth Arora","Software Development","Google","Google India")

# Refer to github link for the template certificate and generated certificate

https://github.com/yathartharora/event_certificates
SpamBotz 1.0.0
A simple and easy to use Spam Bot
Requires Python: >=3.6

# Spam-Botz
<p align="center">
    <img src="https://i.ibb.co/LtzC9DM/Logo.png" alt="Logo" border="0">
    <br>A simple and easy to use Spam Bot
</p>

## Table of Contents

- [Motivation](#Motivation)
- [Usage](#Usage)
- [Contributing](#Contributing)
- [License](#License)

## Motivation

This application was built to well, spam. 

There is no real motivation behind building a spam bot but to simply annoy people.<br>
Or at times even crash the application. 

This application allows you to spam in variations, like : 
- Spamming a fixed static message.
- Spamming random words from a dictionary.
- Sending sequences of numbers.
- Randomly spamming large numbers.
- Good old Rage spam, but this time without breaking your keyboard.

## Usage

For the latest Stable version, go to <a href="https://github.com/SVijayB/Spam-Botz/releases">Releases</a>

Extract the files and run `Spam_botz.py` file present in the `src` folder.

As an alternative, you could also clone the repository using.
<pre>
git clone https://github.com/SVijayB/Spam-Botz.git
</pre>

**NOTE :** It is best to open your messaging window before launching `Spam_botz.py`.

**NOTE :** Make sure your cursor is pointing to the correct text box after you set your preferences.
You have only **15 Seconds** before the automation process begins.

Sometimes you might get banned from the server for spamming too many messages in a short period. To avoid this,
This application has a custom time delay feature. Make sure you enter the appropriate value.

## Contributing 

To contribute to Spam-Botz, fork the repository, create a new branch and send us a pull request. Make sure you read [CONTRIBUTING.md](https://github.com/SVijayB/Spam-Botz/blob/master/docs/CONTRIBUTING.md) before sending us Pull requests. 

Also, thanks for contributing to Open-source!

## License 

Spam-Botz is Licensed under MIT. Read the [LICENSE](https://github.com/SVijayB/Spam-Botz/blob/master/LICENSE) file for more information
petyr 0.0.8
Affine, Similarity Transformations and Homography for Python
Requires Python: >=3.6

# petyr
[![Build Status](https://travis-ci.org/safwankdb/petyr.svg?branch=master)](https://travis-ci.org/safwankdb/petyr)       [![codecov](https://codecov.io/gh/safwankdb/petyr/branch/master/graph/badge.svg)](https://codecov.io/gh/safwankdb/petyr)

Affine, Similarity Transformations and Homography for Python. Fast and chainable inplace operations. Produced matrix can be used with ```cv2.warpAffine``` and ```cv2.warpPerspective```.

## Installation
For stable release
```bash
pip3 install petyr
```
Or, build from source
```bash
pip3 install git+https://github.com/safwankdb/petyr
```
## Usage
```python
from petyr import Similarity, Affine, Homography
```
```Affine```, ```Similarity``` and ```Homography``` derive from the ```Transform2D``` base class which implements all the basic operations.

## Applying Transformation
```python
p = np.array([[0,0],[1,0],[1,1],[0,1]])

rotate_and_move = Affine().rotate(90).translate(2,1)
q = rotate_and_move * p

pt = Homography.from_elements([1,0,0,0,1,0,0.1,0.2,1])
r = pt * p
```
## Finding Transformation
```python
at = Affine.from_points(p, q)
pt = Homography.from_points(p, q)
st = Similarity.from_points(p, q)
```

  
## Basic Operations
These operations modify the object in-place except for ```invert()``` which return a new object.
- Translation
- Scaling
- Shearing
- Rotation
- Inversion
- Reset

```python
at = Affine()
at.translate(1, 3)
at.scale(1.05, 2)
at.rotate(45, degrees=True)
at.shear(10, 45)
at_inv = at.invert()
```
Same goes for ```Homography``` and ```Transform2D``` objects.
## Chaining
### Chaining Operations
Mutiple operations can be chained together.
```python
at = Affine()
at.scale(2,2).rotate(90)
at.shear(10, 0).translate(-3, 4)
```

### Chaining Transforms
Multiple transforms can be multiplied together. This is a **non-commutative** operation. The rightmost transform will be applied first.
```python
a = Affine()
a.translate(2,3)
b = Homography()
b.scale(4,5)
c = a * b
```

## Testing
To run the inbuilt unit tests,

```bash
git clone https://github.com/safwankdb/petyr
cd petyr
python3 -m unittest -v
```

## Maitainers
- [Mohd Safwan](https://github.com/safwankdb)

## TODO
- [x] Implement ```petyr.Homography```.
- [x] Add unit tests.
- [x] Vectorize ```from_points```.
- [x] Add unit tests for ```Affine``` and ```Homography``` classes as well.
- [x] Add ```Similarity``` class for similarity transforms.
- [x] Update all tests for similarity transform
- [ ] Update README with Similarity Transform
- [ ] Generate complete documentation.
- [ ] Move documentation to somwhere other than README.
tweetshot 0.0.1
Take a tweet screenshot
Requires Python: >=3.6
Keywords: keyframes iframes video extractor

# Tweetshot
Tweetshot is a python library to take screenshots of tweets.

# Quick guide
## Installation
    pip install tweetshot
## Usage
Open a command line, or a terminal, and run:

    tweetshot [TWEET-URL]

For example, try the following command:

    tweetshot https://twitter.com/hideo_kojima_en/status/1002107372091817984

You should see a new image file called `screenshot.png` in the directory from where you run the command.
The image should the following one:

![](examples/screenshot.png?raw=true)
filecache 0.81
Persistent caching decorator


filecache

filecache is a decorator which saves the return value of functions even
after the interpreter dies. For example this is useful on functions that download
and parse webpages. All you need to do is specify how long
the return values should be cached (use seconds, like time.sleep).

USAGE:

    from filecache import filecache

    @filecache(24 * 60 * 60)
    def time_consuming_function(args):
        # etc

    @filecache(filecache.YEAR)
    def another_function(args):
        # etc


NOTE: All arguments of the decorated function and the return value need to be
    picklable for this to work.

NOTE: The cache isn't automatically cleaned, it is only overwritten. If your
    function can receive many different arguments that rarely repeat, your
    cache may forever grow. One day I might add a feature that once in every
    100 calls scans the db for outdated stuff and erases.

NOTE: This is less useful on methods of a class because the instance (self)
    is cached, and if the instance isn't the same, the cache isn't used. This
    makes sense because class methods are affected by changes in whatever
    is attached to self.

Tested on python 2.7 and 3.1

License: BSD, do what you wish with this. Could be awesome to hear if you found
it useful and/or you have suggestions. ubershmekel at gmail


A trick to invalidate a single value:

    @filecache.filecache
    def somefunc(x, y, z):
        return x * y * z

    del somefunc._db[filecache._args_key(somefunc, (1,2,3), {})]
    # or just iterate of somefunc._db (it's a shelve, like a dict) to find the right key.