semvec/pypi-packages huggingface dataset:
chemfp 1.6.1
Reference baseline for high-performance cheminformatics fingerprint search benchmarking
License: MIT

This version of chemfp includes command-lines tools to generate
cheminformatics fingerprints and search those fingerprints by
Tanimoto similarity, as well as a Python library which you can use
to build new tools.

It is the no-cost/open source chemfp release track. It only supports
Python 2.7. It is being maintained only to provide a good reference
baseline for benchmarking other similarity search tools.

The commercial track, currently chemfp 3.4, includes faster
performance, many new features, and support for Python 3.

Chemfp is designed for the dense, 100-10,000 bit fingerprints which
occur in small-molecule/pharmaceutical chemisty. The Tanimoto search
algorithms are implemented in C and assembly for performance, and
support both threshold and k-nearest searches using the BitBound
algorithm of Swamidass and Baldi.
  
Fingerprint generation can be done either by extracting existing
fingerprint data from an SD file or by using an existing chemistry
toolkit. chemfp supports the Python libraries from Open Babel,
OpenEye, and RDKit toolkits. Be aware that those vendors no longer
support Python 2.7.
  
The main web site is https://chemfp.com/ .
  
Extensive documentation is at https://chemfp.readthedocs.io/ .
  
To cite chemfp use:
  Dalke, Andrew. The chemfp project. J. Cheminformatics 11, 76
  (2019). https://doi.org/10.1186/s13321-019-0398-8
  https://jcheminf.biomedcentral.com/articles/10.1186/s13321-019-0398-8
python-optiEncoder 2.0.1
A python package to optimally encode a list
License: MIT

### Description
This is an easy to use library to encode categorical data in a feature into optimized set of 
features with each categorical value mapping to a unique bitstring.

```sh
>>> import optiEncoder
>>> enc = optiEncoder.Encoder(["France","Canada","England"])
>>> print("Mappings : ", enc.getMappings())
{'France':[0,0],'Canada':[0,1],'England':[1,0]}
>>> print("Encoded List : ", enc.getEncodedList())
[[0,0],[0,1],[1,0]]
```

### Usage in Data Preprocessing
```sh
>>> import optiEncoder
>>> import pandas
>>> d = pd.read_csv('data.csv').dropna()
        Performance Measure  BRATS 2018  
0          Dice Coefficient       90  
1       Jaccard Coefficient       80  
2            Area under ROC       90  
4        Hausdorff Distance       10  
5               Sensitivity       90  
6               Specificity       90  
7                 F-Measure       90  
8                 Precision       80  
9   Vol Similarity Distance       90  
10                  Fallout        7  
12                       TP     1900  
13                       FP      200  
14                       TN     2500  
15                       FN      600  

>>> enc = optiEncoder.Encoder(list('Performance Measure'))
>>> enc.getEncodedList()
[[1, 0, 0, 1], [1, 1, 0, 0], [1, 0, 0, 0], [0, 1, 1, 1], [0, 1, 0, 0], [1, 0, 0, 0], [0, 1, 1, 0], [1, 0, 1, 0], [0, 0, 1, 1], [1, 0, 1, 1], [1, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [1, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 0, 0], [1, 0, 0, 0], [1, 1, 0, 0]]
>>> d = d.iloc[:,1:]
>>> d
    BRATS 2018  
0        90  
1        80  
2        90  
4        10  
5        90  
6        90  
7        90  
8        80  
9        90  
10        7  
12     1900  
13      200  
14     2500  
15      600  

>>> encodedList = enc.getEncodedList()
>>> for i in range(0,len(encodedList[0])):
...     d[str(i)]=pd.DataFrame(encodedList).iloc[:,i]
...
>>> d
    BRATS 2018  0  1  2  3
0        90  1  0  0  1
1        80  1  1  0  0
2        90  1  0  0  0
4        10  0  1  0  0
5        90  1  0  0  0
6        90  0  1  1  0
7        90  1  0  1  0
8        80  0  0  1  1
9        90  1  0  1  1
10        7  1  1  0  0
12     1900  0  0  1  0
13      200  1  1  0  0
14     2500  1  0  1  0
15      600  0  1  0  1

```

### License
MIT
### Author
Sahil Ahuja
fancy-eventbus 0.1.0a0
a event bus
License: MIT
Requires Python: >=3.6
Keywords: event

# fancy-event

# Usage

```python
import fancy.eventbus as fe


class MyEvent:
    value: int

    def __init__(self, value):
        self.value = value


class MyEvent2:
    pass


class Target:
    def __init__(self):
        fe.register(self)

    @fe.SubscribeEvent()
    def on_start(self, event: fe.StartEvent):
        print("start!")
        fe.post(MyEvent(1))

    @fe.SubscribeEvent()
    def my_event(self, event: MyEvent):
        print("my_event", event.value)
        fe.post(MyEvent2())
        fe.post(self)

    @fe.SubscribeEvent()
    def my_event2(self, event: MyEvent2):
        print("my_event2")
        raise RuntimeError("an error")

    @fe.SubscribeEvent(priority=fe.EventPriority.HIGHEST)  # execute before my_event2
    def self_as_event(self, event: "Target"):  # forwarding ref
        print("self_as_event", event is self)

    @fe.SubscribeEvent()
    def error_handler(self, e: RuntimeError):
        print("handle by runtime error", e)

    @fe.SubscribeEvent(priority=fe.EventPriority.LOW)  # method name should different
    def error_handler2(self, e: Exception):
        print("handle by exception", e)
        return False  # returned false will cancel the event

    @fe.SubscribeEvent(priority=fe.EventPriority.LOWEST)
    def error_handler3(self, e: BaseException):
        print("this should be canceled.", e)


loop = fe.EventLoop()
# registers
Target()

loop.start()

```


```output
start!
my_event 1
self_as_event True
my_event2
handle by runtime error an error
handle by exception an error
```