semvec/pypi-packages huggingface dataset:
skelvis 0.165
3D skeleton visualizer package

**Edit a file, create a new file, and clone from Bitbucket in under 2 minutes**

When you're done, you can delete the content in this README and update the file with details for others getting started with your repository.

*We recommend that you open this README in another tab as you perform the tasks below. You can [watch our video](https://youtu.be/0ocf7u76WSo) for a full demo of all the steps in this tutorial. Open the video in a new tab to avoid leaving Bitbucket.*

---

## Edit a file

You’ll start by editing this README file to learn how to edit a file in Bitbucket.

1. Click **Source** on the left side.
2. Click the README.md link from the list of files.
3. Click the **Edit** button.
4. Delete the following text: *Delete this line to make a change to the README from Bitbucket.*
5. After making your change, click **Commit** and then **Commit** again in the dialog. The commit page will open and you’ll see the change you just made.
6. Go back to the **Source** page.

---

## Create a file

Next, you’ll add a new file to this repository.

1. Click the **New file** button at the top of the **Source** page.
2. Give the file a filename of **contributors.txt**.
3. Enter your name in the empty file space.
4. Click **Commit** and then **Commit** again in the dialog.
5. Go back to the **Source** page.

Before you move on, go ahead and explore the repository. You've already seen the **Source** page, but check out the **Commits**, **Branches**, and **Settings** pages.

---

## Clone a repository

Use these steps to clone from SourceTree, our client for using the repository command-line free. Cloning allows you to work on your files locally. If you don't yet have SourceTree, [download and install first](https://www.sourcetreeapp.com/). If you prefer to clone from the command line, see [Clone a repository](https://confluence.atlassian.com/x/4whODQ).

1. You’ll see the clone button under the **Source** heading. Click that button.
2. Now click **Check out in SourceTree**. You may need to create a SourceTree account or log in.
3. When you see the **Clone New** dialog in SourceTree, update the destination path and name if you’d like to and then click **Clone**.
4. Open the directory you just created to see your repository’s files.

Now that you're more familiar with your Bitbucket repository, go ahead and add a new file locally. You can [push your change back to Bitbucket with SourceTree](https://confluence.atlassian.com/x/iqyBMg), or you can [add, commit,](https://confluence.atlassian.com/x/8QhODQ) and [push from the command line](https://confluence.atlassian.com/x/NQ0zDQ).
classy-events 0.3.4
Pythonic event-driven programming.
Requires Python: >=3.8.0

# Classy Events

Pythonic event-driven programming.

## Dependencies

Python 3.8, 3.9

## Install

```bash
pip install classy-events
```

## Usage

The main ingredient is an *event handler* instance:

```python
from classy_events import EventHandler
event_handler = EventHandler()
```

You can register *event listeners* for *events* of any type.
In this example we use string events.
An event listener is a callable, like a function or a method. 
The registered event handlers for a specific event are called if 
that event is dispatched by the event handler. 
Any keyword arguments that accompany the event are passed to the event 
listeners. 

### Function listeners

The listener for the event `"spam"`, no callbacks needed!

```python
@event_handler.on("spam")
def spam(value):
    print(f"on 'spam': '{value}'")
```

When the `"spam"` event is dispatched from anywhere in the code, `def spam` will be called:

```jupyterpython
event_handler.dispatch("spam", value="ham and eggs")
```

Now `on 'spam': 'ham and eggs'` is printed.

### Classy listeners

To use instance methods as listeners, only one extra step is needed:

```python
class Spam:
    def __init__(self):
        event_handler.bind(self)

    @event_handler.on("classy_spam")
    def spam(self, value):
        print(f"on '{type(self).__name__}.spam': '{value}'")

spam_instance = Spam()
```

In `__init__`, the instance is bound to the handler. Note that this 
`event_handler.bind` call is not required to be within the `__init__`.

To see this in action, we dispatch the `"classy_spam"` event:

```python
event_handler.dispatch("classy_spam", value="the classiest")
```

And we see the output `on 'Spam.spam': 'the classiest'`.
rdchiral 1.1.0
Wrapper for RDKit's RunReactants to improve stereochemistry handling
Requires Python: >=3.5

[![PyPI version](https://badge.fury.io/py/rdchiral.svg)](https://badge.fury.io/py/rdchiral)

# rdchiral
Wrapper for RDKit's RunReactants to improve stereochemistry handling

## Requirements

* RDKit (version >= 2019)
* Python (version >= 3.5)

## Installation

To install RDChiral run

```pip install rdchiral```

To get the most recent version reflected by this git repo, install with

```pip install -e "git://github.com/connorcoley/rdchiral.git#egg=rdchiral"```

## Fast C++ version (rdchiral_cpp)

A fast C++ implementation ([rdchiral_cpp](https://gitlab.com/ljn917/rdchiral_cpp)) is available as a drop-in replacement. It provides ~10x speedup. To install from anaconda, run

```conda install -c conda-forge -c ljn917 rdchiral_cpp```

## Documentation

See ```rdchiral/main.py``` for a brief description of expected behavior and a few basic examples of how to use the wrapper. 

See ```rdchiral/test/test_rdchiral.py``` for a small set of test cases described [here](https://pubs.acs.org/doi/abs/10.1021/acs.jcim.9b00286)
fa2rs 0.3.2
Bindings to full Rust ForceAtlas2 implementation
Requires Python: >=3.6
Keywords: forceatlas2 graph force-directed-graph force-layout

# ForceAtlas2 Python bindings from Rust

Python 3 bindings for Rust [forceatlas2](https://framagit.org/ZettaScript/forceatlas2-rs) crate: fast force-based graph spacialization layout, with optional multithread and SIMD.

![Example graph spacialized with ForceAtlas2](https://txmn.tk/img/wot-fa2rs.png)

Note: Cross-compiling with PyO3 is hard, so the distributed binary only works for GNU/Linux with latest versions of glibc (typically not Debian). Any help with cross-compilation or static glibc linking is welcome. :)

# Example

```
import fa2rs

edges = [(0,1), (1,2), (2,0), (2,3)]
layout = fa2rs.Layout.from_graph(edges, fa2rs.Settings(ka=0.1, kg=0.1, kr=0.1), nb_nodes=4)

for i in range(100):
    layout.iteration()

print(layout.points)
```

You may need to tweak the settings to fit your data. The most important parameter is the ratio between `ka` and `kr`. If the ratio has too low or high values, the graph will collapse or explode (resulting in zero or infinite values).

* `ka`: attraction coefficient (all neighbor nodes attract each other)
* `kg`: gravity coefficient (all nodes are attracted to the origin) (can be set to `0`)
* `kr`: repulsion coefficient (all nodes repulse each other)
* `chunk_size`: decrease to use more threads, increase to use fewer threads. Tune it to minimize both thread management time and unparallelized time. Set to `None` to disable parallelization.

# Build & install

Build:

    sh build_wheel.sh

Install:

    pip3 install target/wheel/dist/fa2rs-0.2.1-py3-none-any.whl --upgrade

More information about optimizations on [the Rust repository](https://framagit.org/ZettaScript/forceatlas2-rs).

`Layout` and `Settings` are aliases for `Layout32` and `Settings32`. The `32` and `64` versions refer to the size of the floats. 64-bit floats are more precise, but when SIMD is available, the layout is approximately twice slower than with 32-bit floats.

SIMD is only available on `x86` and `x86_64` with `avx2` feature. (check with `grep avx2 /proc/cpuinfo`)

## License

GNU AGPL v3, CopyLeft 2020-2021 Pascal Engélibert  
The ForceAtlas2 paper was released under CC BY, Copyright 2014 Jacomy et al.

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, version 3 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License along with this program. If not, see https://www.gnu.org/licenses/.