semvec/pypi-packages huggingface dataset:
image-tiling 0.1.0
ImgTiler is a Python library for tiling and retiling images. It can be used for splitting large images into smaller tiles for other applications like Training Deep Learning models, inference on large images, etc.

# Image Tiler

Image Tiler is a Python package that allows you to split an image into tiles based on a grid and overlap between tiles. It also provides functionality to combine the tiles back into the original image.

## Installation

You can install Image Tiler using pip:

```shell
pip install ImgTiler
```

## Usage
### SplitImage Class
The `SplitImage` class is used to split an image into tiles based on a grid and overlap between tiles. The class takes in an image path, the number of rows and columns in the grid, and the overlap between tiles.

#### CombineTiles Class
The `CombineTiles` class is used to combine tiles back into the original image. The class takes in a list of tiles, the number of rows and columns in the grid, and the overlap between tiles.

#### Example
```python
from ImgTiler import SplitImage, CombineTiles
import cv2

img = cv2.imread('image.jpg')
grid = (3, 4) #3 rows, 4 columns
overlap = 30 #30 pixels
show_rects = True
show_image = True

splitter = SplitImage(img, grid, overlap) # Create SplitImage object
tiles = splitter.split_image(show_rect=show_rect, show_tiles=show_image) # Split image into tiles

combiner = CombineTiles(tiles, grid, overlap) # Create CombineTiles object
img2 = combiner.combine_tiles(show_image=show_image) # Combine tiles into original image
```
#### Original Image
![Orignal Image](images/img.jpg)

#### Split Result
![Split Image without Rectangle](images/split_wo_rect.jpg)
![Split Image with Rectangle](images/split_w_rect.jpg)

#### Combined Image
![Combined Image without rectangle](images/recon_wo_rect.jpg)
![Combined Image with rectangle](images/recon_w_rect.jpg)

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

## License
This project is licensed under the [MIT](https://choosealicense.com/licenses/mit/) license.
tvm-valuetypes 0.0.12
Collection of utils for handling Telegram Open Network Virtual Machine value types

# TVM value types
Telegram Open Network Virtual Machine has 7 value types:
1. Integer
2. Cell
3. Tuple
4. Null
5. Slice
6. Builder
7. Continuation

This library is collection of utilits for handling those types.

# Cell and Slice
`tvm_valuetypes.cell` has class `Cell` and functions to work with cells:
`deserialize_boc`, `cell.serialize_boc`, `cell.serialize_to_object`, `cell.serialize_to_json`, `deserialize_cell_from_json`
```
from tvm_valuertypes.cell import Cell, deserialize_boc
serialized_cell = bytes.fromhex("B5EE9C72410102010007000102000100024995C5FE15")
cell1 = deserialize_boc(serialized_c1)
cell1
serialization_with_index = cell1.serialize_boc(has_idx=True, hash_crc32=True, has_cache_bits=False, flags=0 )
serialization_with_index
cell2 = deserialize_boc(serialized_c2)
cell2 == cell1
cell2.serialize_to_object()
```
## HashMaps (Dictionaries)
Cell may represent special 'virtual' value type, HashMap, which can be used for storing key-value container in the Cell.

`tvm_valuetypes.dict_utils` has special method `parse_hashmap` for dealing with hashmaps. Note the difference between `Hashmap` and `HashmapE`.

```
from tvm_valuertypes.cell import Cell
from tvm_valuertypes.dict_utils import parse_hashmap
test_dict = bytes.fromhex("B5EE9C7241010A01002D00020120010202014803040003FC0202014805060003F5FE02014807080003DB24020120090900035FF800030020CB8CA892")
dict_cell = deserialize_boc(test_dict)
parsed_dict = {}
parse_hashmap(dict_cell, 8, parsed_dict)
parsed_dict
```
alireza 0.0.5
Comprehensive Toolkit for Boosting Productivity in Python Frameworks Development
Requires Python: >=3.6
Keywords: python,tools,framework,django

This extensive toolkit is specifically designed to enhance productivity and streamline the development process 
when working with Python frameworks. With a wide range of powerful and time-saving tools at your disposal, it empowers developers to tackle 
complex challenges efficiently and effectively.From scaffolding projects to automating repetitive tasks, this toolkit offers an array of features that 
simplify common development workflows. It provides seamless integration with popular Python frameworks, 
offering an extensive collection of utilities, libraries, and modules tailored to enhance the capabilities of your chosen framework.
Unlock the potential of this comprehensive toolkit and enjoy benefits such as code generation, 
and much more. Whether you are working on web development, data science, or any other domain, this toolkit serves as a 
valuable companion throughout the entire development lifecycle.
Accelerate your Python framework projects, reduce development time, and increase code quality with this indispensable toolkit that caters 
to the diverse needs of developers, allowing them to focus on delivering exceptional results.
njord 0.0.2
A Python package for programmatically controlling NordVPN.
Requires Python: >=3.6

# Njord Python Package
## Overview
The njord python package provides a convenient wrapper to programmatically working with NordVPN servers on Mac/Linux via OpenVPN.

## Prerequisites
- `sudo`
- `openvpn`

Because njord relies on `sudo` and `openvpn`, it only works on OSX (including Apple silicone) and Linux. Linux is currently untested. Nord has an [official client](https://support.nordvpn.com/Connectivity/Linux/) that may better serve your needs on Linux. Windows isn't supported.

### Installing OpenVPN
#### OSX
`$ brew install openvpn`

#### Ubuntu
`$ sudo apt-get install openvpn`

## Installation

`$ pip install njord`

## Usage
#### Authentication
Authentication is handled via *service credentials*. Generate these via your Nord account at `Services > NordVPN > Manual Setup`

Copy the service credentials username and password. It's reccomended that you use a .env file for storing them. Njord will check for a .env file on initialization as well as os env variables. Authentication can also be done explicitly during init.



```
# .env
NORD_USER=xxxxxxxxxxxxx
NORD_PASSSWORD=xxxxxxxxxxx
```

```python
from njord import VPN

# Using .env file or os env
vpn = VPN()

# Explicit
vpn = VPN(user="xxxxxxxx", password="xxxxxxxxx")
```

#### Connecting & Disconnecting
``` python
from njord import VPN
vpn = VPN()
vpn.connect()
vpn.protected()
>> True
vpn.disconnect()
vpn.protected()
>> False
```


MIT License

Copyright (c) 2023 Adam Smith

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
ImgTiler 0.1.1
ImgTiler is a Python library for tiling and retiling images. It can be used for splitting large images into smaller tiles for other applications like Training Deep Learning models, inference on large images, etc.

# Image Tiler

Image Tiler is a Python package that allows you to split an image into tiles based on a grid and overlap between tiles. It also provides functionality to combine the tiles back into the original image.

## Installation

You can install Image Tiler using pip:

```shell
pip install ImgTiler
```

## Usage
### SplitImage Class
The `SplitImage` class is used to split an image into tiles based on a grid and overlap between tiles. The class takes in an image path, the number of rows and columns in the grid, and the overlap between tiles.

#### CombineTiles Class
The `CombineTiles` class is used to combine tiles back into the original image. The class takes in a list of tiles, the number of rows and columns in the grid, and the overlap between tiles.

#### Example
```python
from ImgTiler import SplitImage, CombineTiles
import cv2

img = cv2.imread('image.jpg')
grid = (3, 4) #3 rows, 4 columns
overlap = 30 #30 pixels
show_rects = True
show_image = True

splitter = SplitImage(img, grid, overlap) # Create SplitImage object
tiles = splitter.split_image(show_rect=show_rect, show_tiles=show_image) # Split image into tiles

combiner = CombineTiles(tiles, grid, overlap) # Create CombineTiles object
img2 = combiner.combine_tiles(show_image=show_image) # Combine tiles into original image
```
#### Original Image
![Orignal Image](images/img.jpg)

#### Split Result
![Split Image without Rectangle](images/split_wo_rect.jpg)
![Split Image with Rectangle](images/split_w_rect.jpg)

#### Combined Image
![Combined Image without rectangle](images/recon_wo_rect.jpg)
![Combined Image with rectangle](images/recon_w_rect.jpg)

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

## License
This project is licensed under the [MIT](https://choosealicense.com/licenses/mit/) license.
worldvocoder 0.0.5
Python implementation of WORLD vocoder.
Requires Python: >=3.7

# PYTHON WORLD VOCODER: 
*************************************

This is a line-by-line implementation of WORLD vocoder (Matlab, C++) in python. It supports *python 3.0* and later.

# INSTALLATION
*********************

```
pip install worldvocoder
```

# EXAMPLE
**************

```python
import worldvocoder as wv
import soundfile as sf
import librosa

# read audio
audio, sample_rate = sf.read("some_file.wav")
audio = librosa.to_mono(audio)

# initialize vocoder
vocoder = wv.World()

# encode audio
dat = vocoder.encode(sample_rate, audio, f0_method='harvest')

```

in which, ```sample_rate``` is sampling frequency and ```audio``` is the speech/singing signal.

The ```dat``` is a dictionary object that contains pitch, magnitude spectrum, and aperiodicity. 

We can scale the pitch:

```python
dat = vocoder.scale_pitch(dat, 1.5)
```

Be careful when you scale the pich because there is upper limit and lower limit.

We can make speech faster or slower:

```python
dat = vocoder.scale_duration(dat, 2)
```

To resynthesize the audio:

```python
dat = vocoder.decode(dat)
output = dat["out"]
```

To use d4c_requiem analysis and requiem_synthesis in WORLD version 0.2.2, set the variable ```is_requiem=True```:

```python
# requiem analysis
dat = vocoder.encode(fs, x, f0_method='harvest', is_requiem=True)
```

To extract log-filterbanks, MCEP-40, VAE-12 as described in the paper `Using a Manifold Vocoder for Spectral Voice and Style Conversion`, check ```test/spectralFeatures.py```. You need Keras 2.2.4 and TensorFlow 1.14.0 to extract VAE-12.
Check out [speech samples](https://tuanad121.github.io/samples/2019-09-15-Manifold/)

# NOTE:
**********

* The vocoder use pitch-synchronous analysis, the size of each window is determined by fundamental frequency ```F0```. The centers of the windows are equally spaced with the distance of ```frame_period``` ms.

* The Fourier transform size (```fft_size```) is determined automatically using sampling frequency and the lowest value of F0 ```f0_floor```. 
When you want to specify your own ```fft_size```, you have to use ```f0_floor = 3.0 * fs / fft_size```. 
If you decrease ```fft_size```, the ```f0_floor``` increases. But, a high ```f0_floor``` might be not good for the analysis of male voices.


# CITATION:

Dinh, T., Kain, A., & Tjaden, K. (2019). Using a manifold vocoder for spectral voice and style conversion. Proceedings of the Annual Conference of the International Speech Communication Association, INTERSPEECH, 2019-September, 1388-1392.