semvec/pypi-packages huggingface dataset:
lisp-utils 0.6.1
This package contains some Linkspirit classes such as Database, Configuration.
Requires Python: >=3

# Linkspirit Package

This package contains some useful functions and classes that can be used in Linkspirit's scripts.

## Database
This class can be used to comunicate with SQL database and running queries.

## Configuration
This class can be used to parse and utilize configuration files (in json format).
jipubetapi 0.0.3
This library makes it easier to access the API

# jipubetapi
## РЈСЃС‚Р°РЅРѕРІРєР° Р±РёР±Р»РёРѕС‚РµРєРё
```python
  pip install --upgrade jipubetapi
```
### Р‘РёР±Р»РёРѕС‚РµРєР° РїРѕР»РЅРѕСЃС‚СЊСЋ Р°СЃРёРЅС…СЂРѕРЅРЅР°
________
## РџСЂРёРјРµСЂ РёСЃРїРѕР»СЊР·РѕРІР°РЅРёСЏ
```python
import jipubetapi
from jipubetapi import ApiError
import asyncio
api = jipubetapi.JipubetKey()
async def main():
  try:
    print(await api.toad())
   except ApiError:
    print('api error')
asyncio.run(main())
```
#### РџРѕРґСЂРѕР±РЅРµРµ РјРѕР¶РµС‚Рµ РїСЂРѕС‡РёС‚Р°С‚СЊ РІ РґРѕРєСѓРјРµРЅС‚Р°С†РёРё: _СЃРєРѕСЂРѕ_
npm-analyser 1.0.0
A Python library to monitor an npm package!
Requires Python: >=3.9.7

# Overview
-----------------------------------------------------------------------------

npm_analyser is a Python library to monitor an npm package! 

## Package Installer 

    pip install npm-analyser==1.0.0

## Usage

    from npm_analyser import npm_analyser
    '''
      package_name -> string npm package name.
    '''
    package_details = npm_analyser(package_name)
    
    print(package_details.package_name)
    print(package_details.version)
    print(package_details.weekly_downloads)
    print(package_details.license)
    print(package_details.last_published)
    print(package_details.get_dev_dependencies)
    
**Utilities**

| Name           | Description  |
| ------------- | -----|
| package_name | Returns the npm package name! |
| version | Returns the npm package version! |
| last_published | Returns the npm package last published date! |
| total_versions | Returns the total versions of npm package! |
| number_of_dependents | Returns the total number of dependents of the npm package! |
| get_dev_dependencies | Returns the dev-dependencies of the npm package! |
| weekly_downloads | Returns the weekly downloads of the npm package! |
| license | Returns the license of the npm package! |
| unpacked_size | Returns the unpacked size of the npm package! |
| total_files | Returns the total files of the npm package! |

## Requirements

The `requirements.txt` file has details of all Python libraries for this package, and can be installed using 
```
pip install -r requirements.txt
```

## Organization

    ├── src
    │   ├── npm_analyser
              ├── init             <- init
              ├── npm_analyser     <- package source code for npm analyser
    ├── setup.py             <- setup file 
    ├── LICENSE              <- LICENSE
    ├── README.md            <- README
    ├── CONTRIBUTING.md      <- contribution
    ├── test.py              <- test cases for unit testing
    ├── requirements.txt     <- requirements file for reproducing the code package

## License

MIT

## Contributions

For steps on code contribution, please see [CONTRIBUTING](./CONTRIBUTING.md).
tf-convex-polygon-iou-atuleu 0.0.2
IoU computation for convex polygons
Requires Python: >=3.6

# tf-convex-polygon-iou

Convex Polygons Intersection over Union (IoU) computation for tensorflow.

This repository is a a generalization of https://github.com/lilanxiao/Rotated_IoU to convex polygons, and ported to tensorflow 2.


## Approach

The algorithm here may not be optimal, but only uses available tensorflow operations.

The most complex parts are to compute the intersection of two convex polygon.

As for the original work, it is based on [Livermore, Califf, 1977](https://www.osti.gov/servlets/purl/7309916/). which remarks:

* Intersection of two convex polygons is a convex polygon
* A vertex from a polygon that is contained in the other polygon is a vertex of the intersection shape. 
* An edge from a polygon that is contained in the other polygon is an edge in the intersection shape. 
* Edge intersections between two polygons are vertices in the intersection shape.

Therefore the algorithm here:
1. Finds all vertices in a polygon that lies within the other, by computing the [winding number](https://web.archive.org/web/20130126163405/http://geomalgorithms.com/a03-_inclusion.html).
2. Finds all intersection between edge other edges of the two polygons.
3. Sorts all vertices in trigonometric order arround a point inside the polygon (die to duplicates, it cannot be ensured that it is the centroid of the polygon).

To compute the IoU, one must finally compute the area of the intersection. The used formula is robust to duplicate vertices, if the order of vertices is right.

## Requirements

```
tensorflow >= 2.8.0 # it may be lower, but it is not tested
```
mrpypulse 1.0.0
Mr. PyPulse for Magnetic Resonance pulses
Requires Python: >=3.6s

### mrpypulse

Mr. Py Pulse for generation and manipulation of Magnetic Resonance pulses in Python.

### modules

  - pulse, for creation and manipulation of pulses
  - magnetization, for simulation of pulses effect on magnetization
  - sequence, for creation and manipulation of sequence of pulses

### installation

```
pip install mrpypulse
```

### tests

Require pytest, inside the top-level `mrpypulse` directory, run:

```
pytest tests\
```