semvec/pypi-packages huggingface dataset:
munkres-rmsd 0.0.1.post4.dev0
Proper RMSD calculation between molecules using the Kuhn-Munkres Hungarian algorithm.
License: MIT
Keywords: RMSD,docking poses,atom mapping

# RMSD

Determining the Root Mean Square Deviation (RMSD) between the Maximum Common Substructures (MCS) of two molecules.

The Kuhn-Munkres Hungarian algorithm allows for a fast match of atoms based on:
- atomic symbol
- Sybyl atom types
- pharmacophoric types (i.e. H-bond donors and acceptors or charges)

# Installation

```bash
pip install munkres-rmsd
```

# Example

```python
from munkres_rmsd import CalcLigRMSD, AtomType
from munkres_rmsd.RMSD import get_example_molecules

# First, load 3D poses of molecules 
mol1, mol2 = get_example_molecules()

# Then compute the RMSD of the best atomic match
rmsd = CalcLigRMSD(mol1, mol2)

print(rmsd) # 10.76150...
```

Let's use Sybyl atom types to match atoms between the two molecules instead of the default, using atomic elements.

```python
# Then compute the RMSD of the best atomic match
rmsd = CalcLigRMSD(mol1, mol2, AtomType.Sybyl)

print(rmsd) # 11.59752...
```

Should you prefer pharmacophore types (i.e. H-bond donors & acceptors, charges and others):

```python
# Then compute the RMSD of the best atomic match
rmsd = CalcLigRMSD(mol1, mol2, AtomType.Pharmacophore)

print(rmsd) # 9.49120...
```

Finally to allow matching any atom whatever its type:

```python
# Then compute the RMSD of the best atomic match
rmsd = CalcLigRMSD(mol1, mol2, AtomType.Skeleton)

print(rmsd) # 8.96288...
```
NumIntM 0.0.2
Numerical integration using methods like: Trapezoidal method, Simpson rule, Newton cotes method and Compound trapezoidal method
License: MIT
Keywords: numerical integration aproximation

Hi!, with this package you can use different methods in order to aproximate the numerical integration of a function,
using methods like: Trapezoidal method, Simpson rule, Newton cotes method and Compound trapezoidal method.

You can invoke the following methods: 

1.- funcion(x) --- by defult is: funcion(x) = 1/(1+(x**2))

2.- trapecio(f,x_0,x_1,h)

3.- Simpson(f,x_0,x_1,x_2,h)

4.- NewtonCotOpen(f,x_1,x_2,x_3,x_4,h)

5.- trap_Comp(f,a,b,h,n):

6.- analitica(a,b)

7.- error(analitica, numerica)
pcdiff 1.0.1
Simple and small library to compute differential operators (gradient, divergence, Laplacian) on point clouds.
License: MIT
Requires Python: >=3.6

# `pcdiff`: Differential operators on point clouds
Simple and small library to compute differential operators (gradient, divergence, Laplacian) on point clouds.

## Installation
The recommended installation method is by using pip:
```bash
pip install pcdiff
```

## Example usage
See `demo.py` in `examples` for a full visual demo. For a quick start:
```python
import numpy as np
from pcdiff import knn_graph, estimate_basis, build_grad_div

# Random point cloud
pos = np.random.rand(1000, 3)

# Generate kNN graph
edge_index = knn_graph(pos, 20)
# Estimate normals and local frames
basis = estimate_basis(pos, edge_index)
# Build gradient and divergence operators (Scipy sparse matrices)
grad, div = build_grad_div(pos, *basis, edge_index)

# ... use gradient and divergence in any task you like
```

For sake of simplicity, every operation is written in Numpy and can be accelerated with Numba or Jax. If you would like to use these operators in PyTorch, please refer the github repository for [DeltaConv](https://github.com/rubenwiersma/deltaconv): `pip install deltaconv` and use the operators from `deltaconv.geometry`.

## Citation
If you find this library useful in your own work, please cite our paper on DeltaConv, a convolution for point clouds that uses these operators:

```bib
@Article{Wiersma2022DeltaConv,
  author    = {Ruben Wiersma, Ahmad Nasikun, Elmar Eisemann, Klaus Hildebrandt},
  journal   = {Transactions on Graphics},
  title     = {DeltaConv: Anisotropic Operators for Geometric Deep Learning on Point Clouds},
  year      = {2022},
  month     = jul,
  number    = {4},
  volume    = {41},
  doi       = {10.1145/3528223.3530166},
  publisher = {ACM},
}
```
proxy-ninja 0.1.0
Python3 library for scraping http/https and socks(4) proxies.
License: MIT
Keywords: proxy,free proxy,proxy grabber,http proxy,https proxy,socks proxy,socks4 proxy,socks5 proxy


# Proxy Ninja
Python3 Module to get https or socks(4) proxies by scraping the web.
## Installation
Before installing the module , please install the ChromiumDriver as following debian/kali
```bash
    sudo apt-get update && sudo apt-get full-upgrade -y
    sudo apt-get install chromium-driver
```
Use the package manager [pip](https://pip.pypa.io/en/stable/) to install the module.
if not installed, install it using the following command.
```bash
sudo apt-get install python3-pip
```

> It is advised to install the python requirements in a virtual environment, for that install the venv package.

```bash
    python3 -m pip install venv
    python3 -m venv env
    source env/bin/activate
```
After that run the following commands:
```bash
  python3 -m pip install <pkg> -U
```
    
## Usage/Examples
-----------------------------------------
#### Usage:

==> Download the proxies.

```python
#!/usr/bin/python3
from proxy_ninja import fetch_proxies

fetch_proxies(PROXY_TYPE, OUTPUT_FILENAME, OUTPUT_FORMAT)
```
- PROXY_TYPE: https/socks
- OUTPUT_FILENAME: Enter the filename
- OUTPUT_FORMAT: txt/json

-- proxies gonna save in parent dir.

#### Example:
```python
#!/usr/bin/python3
from proxy_ninja import fetch_proxies

fetch_proxies("socks", "socks_proxy", "json")
```

==> Get proxies as json
```python
#!/usr/bin/python3
from proxy_ninja import proxies_json

json_list = proxies_json(PROXY_TYPE)
print(json_list)
```
- PROXY_TYPE: https/socks

> This will gonna return a list.

#### Example:
```python
#!/usr/bin/python3
from proxy_ninja import proxies_json

json_list = proxies_json("https")
print(json_list)
```

## Features

- ChromeDriver to scrape the site.
- Stealth Profle implmented.
- Save output in txt or json format.
- User Friendly. :D


## License

[MIT](https://choosealicense.com/licenses/mit/)


## Feedback

If you have any feedback, please reach out to us at akalucifr@protonmail.ch


Change Log
==========

0.1.0 (17/8/2022)
-------------------
- initial release
fsdev 0.1.2
A super simple filesystem dev server
License: MIT
Requires Python: >=3.10,<4.0

# fsdev

A super simple filesystem dev server.

## Usage

Absolutely zero configuration. Just type `fsdev` in the directory you want to serve. Static files go in `static` and templates go in `templates`. You can make templates *private* (hide from server) by prepending with an underscore (e.g., `_header.html`). This is great for partials.

## Known Issues

-   Import warning on serve

## Documentation

Documentation in Markdown. Configured to use pdoc documentation tool:

```
poetry run pdoc fsdev.py
```
psh 0.2.12
Process management library
License: MIT

psh allows you to spawn processes in Unix shell-style way.

Unix shell is very convenient for spawning processes, connecting them into
pipes, etc., but it has a very limited language which is often not suitable
for writing complex programs. Python is a very flexible and reach language
which is used in a wide variety of application domains, but its standard
subprocess module is very limited. psh combines the power of Python language
and an elegant shell-style way to execute processes.

Complete documentation is available at https://konishchevdmitry.github.io/psh/