semvec/pypi-packages huggingface dataset:
pyeasypay 0.2.10
Make money from your Python projects the easy way.
Requires Python: >=3.8


<div align="center" style="display: flex; flex-flow: column wrap;">
<br><br>
<img src="/assets/img/pyeasypay.svg" alt="easypay" style="width: 300px"/>
<br><br>

[![Get on pypi](https://img.shields.io/pypi/v/pyeasypay.svg)](https://pypi.org/project/pyeasypay/)
[![Last commit](https://img.shields.io/github/last-commit/nichind/pyeasypay.svg)](https://github.com/nichind/pyeasypay)
[![Pip module installs total downloads](https://img.shields.io/pypi/dm/pyeasypay.svg)](https://pypi.org/project/pyeasypay/)
[![GitHub stars](https://img.shields.io/github/stars/nichind/pyeasypay.svg)](https://github.com/nichind/pyeasypay)
<br>
[![Telegram](https://img.shields.io/badge/Telegram-Telegram-0088cc?logo=telegram&logoColor=white)](https://t.me/pyeasypay)
[![Discord](https://img.shields.io/badge/Discord-Discord-5865F2?logo=discord&logoColor=white)](https://discord.gg/nichind)
</div>

# Installation

Install package with pip:

```commandline
pip install pyeasypay
```

or

```commandline
python3 -m pip install pyeasypay
```

# Example usage

Example on creating invoice and waiting for it to be paid:

```python
from asyncio import run, sleep
from pyeasypay import EasyPay, Provider


async def main():
    cryptobot = Provider(name='cryptobot', api_key='')
    crystalpay = Provider(name='crystalpay', login='', secret='')
    pay = EasyPay(providers=[cryptobot, crystalpay])
    invoice = await pay.create_invoice(15, 'RUB', 'cryptobot')
    
    print(f"Invoice URL: {invoice.pay_info}")
    
    while invoice.status != 'paid':
        await sleep(5)
        await invoice.check()
        
    if invoice.status == 'paid':
        print('Invoice paid! 🎉')
        
if __name__ == '__main__':
    run(main())
```

# Supported providers

List of supported providers:

| Provider       | Status | Kwargs for Proiver (* is required)  |
|------------|---------|-------------------|
| CryptoBot  | ✅       | `api_key`\*, `network`         |
| CrystalPay | ✅       | `login`\*, `secret`\* |
| AAIO       | WIP    |                                           |

# Contributors

Contributions are welcomed!

<img src="https://contrib.rocks/image?repo=nichind/pyeasypay" alt="Contributors" style="max-width: 100%;"/>
raster-to-vector 0.0.1
convert GIS WMTS tile image to polygon and point using computer vision
Requires Python: >=3.8

# raster_to_vector
convert GIS WMTS tile image to polygon and point using computer vision

### define your tile image request function
the function should cache images to speed up
```python
from raster_to_vector import GetTile

get_tile = GetTile('https://my-wmts/{z}/{y}/{x}')
```

### (lng lat zoom) to polygon
expand tile from given point until bounded by area
```python
from raster_to_vector import find_polygon_from_point

polygon = find_polygon_from_point(lng=120.67, lat=24.171, z=9, get_tile=get_tile)
print(polygon.wkt)
```

### find all text (lng lat) in bounded area
recognize text based on rapidocr-onnxruntime engine
```python
from raster_to_vector import find_text_in_area

found, queue = find_text_in_area(bound=polygon, z=9, get_tile=get_tile)
for point, text in found:
    print(text, point.wkt)
```

### convert raster to vector in bounded area
the algorithm will zoom in if the unknown area does not show text
```python
from raster_to_vector import find_polygon_in_area

results = find_polygon_in_area(bound=polygon, z=9, maxz=10, get_tile=get_tile)
for polygon, text in results:
    print(text, polygon.wkt)
```
pyhora2 3.6.3
A Python package for generating Indian style calendar, panchang, horoscope and compatibility. Advanced, clean, and well-packaged version of PyHora
Requires Python: >=3.8

Pyhora 2
=================
Python package containing almost all the features described in the book

Vedic Astrology - An Integrated Approach - by PVR Narasimha Rao
 
Observational Indian lunisolar calendar, horoscope and matching using the Swiss ephemeris (Hindu
Drig-ganita Panchanga).

Installation
=================
```pip install pyhora2```

Features
--------
See - package_structure.md for package structure

Using the GUI
-------------

Enter Name, and Place with country name (e.g. Chennai, IN)
If you get an error, enter latitude, longitude and time zone manually.
If you want to be precise, enter the lat/long of the exact place (e.g. hospital)
You can use google to find the latitude, longitude, time zone of the place

Type the Date in YYY,MM,DD format in the 'Date' field. Negative value for YYYY are
interpolated as proleptic Gregorian calendar (Before Christ BC).

Enter Time of birth, choose chart style, ayanamsa mode, language of display

Click Show Chart to display the birth (Raasi and Navamsam) charts

Click Show PDF to save the screen as a PDF file

Using the Code / command line
------------------------------
```sample.py
from hora.ui import horo_chart

App = QApplication(sys.argv)
chart_type = 'North'
chart = horo_chart.ChartSimple(chart_type=chart_type)
chart.language('Tamil')
chart.name('Krishna')
chart.place('Mathura,IN')
chart.date_of_birth('-3229,6,17')
chart.time_of_birth('23:59:00')
chart.time_zone('5.5')
chart.chart_type(chart_type)
chart.compute_horoscope()
chart.minimum_compatibility_score(20.0)
chart.mahendra_porutham(False)
chart.vedha_porutham(False)
chart.rajju_porutham(False)
chart.sthree_dheerga_porutham(False)
chart.show()
chart.save_as_pdf('delme.pdf')
```
Accuracy
--------

The program is as accurate as the Swiss Ephemeris installed on your system. So generally it is
accurate for years 13000 BCE to 16800 CE. The
computational speed stays the same no matter which date you enter. Required swiss ephimeres files are also /ephe/ folder of this repository.
Overall size of these files is more than 100 MB. To reduce your application size, you can restrict the dates within a range and could remove those ephimeres files from the folder.

Personal Opinion:
------------------
When using BC dates (such as mahabharatha dates) it is advised to use `SURYA_SIDHANTHA` or `SUNDAR_SS` as ayanamsa styles, as ayanamsa values of every other ayanamsa types such as `LAHIRI, KP` etc are inaccurate. 
`SUNDAR_SS` is a sine curve forcing zero ayanamsa every 3200 years from -3101 BCE and 27 degrees as peak ayanamsa.

API Documents
-------------
API are in README.md of respective folders. HTML links are provided here below: 

License
-------
See LICENSE file.
scase 0.3.6
Spectral Embedding Using Deep Neural Networks
Requires Python: >=3.11

# ScaSE

<p align="center">

[//]: # (    <img src="https://github.com/shaham-lab/SpectralNet/blob/main/figures/twomoons.png">)

ScaSE is The official PyTorch implementation of ScaSE from the paper ["Scalable and Generalizable Spectral Embedding via deep neural networks]().<br>
One of many applications of ScaSE is UMAP initialization, as shown in the following figure:<br>
<br><img src="docs/umap_plot.png">
Initializing UMAP with ScaSE results in a similar embedding to the one obtained by UMAP itself (initialized with Spectral Embedding), but with a much faster runtime for a large number of samples.<br>

[//]: # (## Installation)

[//]: # (You can install the latest package version via)

[//]: # (```bash)
[//]: # (pip install spectralnet)
[//]: # (```)

## Installation
To install the package, simply use the following command:

```bash
pip install scase
```

## Usage

The basic functionality is quite intuitive and easy to use, e.g.,

```python
from scase import ScaSE

scase = ScaSE(n_components=10)  # n_components is the number of dimensions in the low-dimensional representation
scase.fit(X)  # X is the dataset and it should be a torch.Tensor
X_reduced = scase.transfrom(X)  # Get the low-dimensional representation of the dataset
Y_reduced = scase.transform(Y)  # Get the low-dimensional representation of a test dataset

```

You can read the code docs for more information and functionalities.<br>

Out of many applications, ScaSE can be used for UMAP initialization, Fiedler vector and value approximation, and Diffusion Maps approximation. The following is examples of how to use ScaSE for each of these applications:
### UMAP initialization

```python
from scase import ScaSE
from umap import UMAP

scase = ScaSE(n_components=2)
se = scase.fit_transform(X)
umap = UMAP(n_components=2, init=se)
X_reduced = umap.fit_transform(X)
```

### Fiedler vector and value approximation

```python
from scase import ScaSE

scase = ScaSE(n_components=1)
fiedlerVector = scase.fit_transform(X)
fiedlerValue = scase..get_eigenvalues()
```

### Diffusion Maps approximation

```python
from scase import ScaSE

scase = ScaSE(n_components=10)
diffusionMaps = scase.fit_transform(X, t=5)  # t is the diffusion time
```

## Running examples

In order to run the model on the moon dataset, you can either run the file, or using the command-line command:<br>
`python -m examples.reduce_moon`<br>
This will run the model on the moon dataset and plot the results.

The same can be done for the circles dataset:<br>
`python -m examples.reduce_circles`<br>




[//]: # (## Citation)

[//]: # ()
[//]: # (```)

[//]: # ()
[//]: # (@inproceedings{shaham2018,)

[//]: # (author = {Uri Shaham and Kelly Stanton and Henri Li and Boaz Nadler and Ronen Basri and Yuval Kluger},)

[//]: # (title = {SpectralNet: Spectral Clustering Using Deep Neural Networks},)

[//]: # (booktitle = {Proc. ICLR 2018},)

[//]: # (year = {2018})

[//]: # (})

[//]: # ()
[//]: # (```)