semvec/pypi-packages huggingface dataset:
hotWater 3.3
The program uses a residual deep learning model to predict water hot-spots on the surface of proteins
License: MIT

hot_water: a residual deep learning model for predicting water hot-spots on protein surfaces. 
####################################################################################################################################################

How it works
=============

Supply a pdb file (or just the accession code) and rank the water molecules within it or scan the surface of the whole protein for most likely water hot spots. 

Installation
============

Note: This tool relies on EDTSurf, therefore runs only on Linux. 
If you have a linux system, install via pip from `PyPi <https://pypi.org/project/hotWater/>`_
(recommended):

.. code-block:: bash

    $ pip2 install --user hotWater


If your system lacks pip, `install it first <https://www.makeuseof.com/tag/install-pip-for-python/>`_. 


Python version
--------------

The tool was developed using Python 2.7.




Usage
=====


Python 2.7 shell


.. code-block:: bash

    >>> from hotWater import *
    >>> rank_waters('3m1k')
    Creating mesh around protein surface using EDTSurf
	[...other output messages...]
    Ranked water positions along with scores have been written out to a file



For the scan mode, you need to use a high performance server (depending on size of protein, can require up to 64GB RAM per core). You will be testing several million of points so please be aware that this will take some time. If your job dies (for e.g. due to insufficient memory resources), rerun it (using fewer threads) in the same folder. The calculation will restart from the last checkpoint. 

.. code-block:: bash

    >>> scan_surface('3m1k', threads=4, threshold=0.999)

The points predicted above the threshold will be written out to a PDB file ('<input>_predicted_waters.pdb'). You can append this output with the original PDB for viewing in pymol etc. The predicted waters are chain 'W'. If you wish to see more predictions, decrease the 'threshold' parameter (hint - not too drastically, a threshold of 0.99 will already yield several thousands of positive predictions and any threshold below 0.9 will yield very many false positive predictions). If you wish to remove excess waters (positively predicted water molecules that clash with one another), run:

.. code-block:: bash

    >>> cluster_predicted_waters('3m1k_predicted_waters.pdb', threshold = 1.4)

Licence
-------

MIT


Authors
-------

`Jan Zaucha <trelek2@gmail.com>`_
tokenhmac 1.0.0
Fast JWT
License: MIT
Keywords: jwt,token,HMAC,HS256,HS384,HS512,encryption

# Token HMAC
Like JWT but more faster as it possible.

About 4x times faster than [PyJWT](https://github.com/jpadilla/pyjwt).

## Installation
```
$ pip install tokenhmac
```

## Examples

```python
import tokenhmac

KEY = "Secret Key"

token = tokenhmac.TokenHMAC(KEY)

value = "Message"
encoded = token.encode(value.encode("utf-8"))
print(encoded)
# b'TWVzc2FnZQ==.aKA0izCttsIOAWvblvsB5xdY17DlaOzlMVeKG1f0u0o='

token.decode(encoded).decode("utf-8")
# "Message"
```


```python
import tokenhmac

KEY = "Secret Key"

token = tokenhmac.TokenHMAC(KEY)

value = 123
encoded = token.encode(value.to_bytes(8, "big"))
print(encoded)
# b'AAAAAAAAAHs=.FAqptzNnojMDx_bfoH6PKTBWP7tFpo4CQyGseVUM9vA='

int.from_bytes(token.decode(encoded), "big")
# 123
```

```python
import tokenhmac
import json

KEY = "Secret Key"

token = tokenhmac.TokenHMAC(KEY)

value = {"id": 123, "msg": "Message"}
encoded = token.encode(json.dumps(value).encode("utf-8"))
print(encoded)
# b'eyJpZCI6MTIzLCJtc2ciOiJNZXNzYWdlIn0=.NlnFLagfGDSn5XmSBmVnmDgqAsBApGx6GFXuvYtjPb4='

json.loads(token.decode(encoded).decode("utf-8"))
# {"id": 123, "msg": "Message"}
```
## License
`tokenhmac` is offered under the MIT license.
peepy 0.0.2
A simple Observer Pattern implementation with decorators
License: MIT
Requires Python: >=3.6

# peepy
A simple Observer Pattern implementation with decorators

## Installation

Simply instasll from pypi:

``` bash
pip3 install peepy
```

### Usage

Observables can be connected to bserver callbacks siply by callling the bind_to method or by using the observe, observe_dict and observer_function decorators

``` python
from peepy.Observables import Observable, ObservableDict, observe, observe_dict

foo = Observable('important object')
foo2 = Observable('important object 2')

@observe(foo, foo2)
def observer(label, old, new):
    print('Changing {0}\'s value from {1} to {2}'.format(label, old, new))

foo.value = 'bar'
foo.value = 'baz'

foo2.value = foo

foo_dict = ObservableDict({'foo': 1, 'bar':{}})

@foo_dict.observer_function
def dict_observer(label, old, new):
    print('Changing key {0} from {1} to {2}'.format(label, old, new))

foo_dict['foo'] = 2
foo_dict['foo2'] = 20
foo_dict['bar'] = {'baz':None}
```