semvec/pypi-packages huggingface dataset:
pyanc350 0.9.1
Windows wrapper for attocube systems AG's ANC350 control DLL

# pyanc350 attocube ANC350 Python library

pyanc350 is a Python wrapper for controlling attocube systems AG's ANC350 piezoelectric control electronics. It contains an implementation of the C++ header for the attocube ANC350 controller (ANC350lib) plus a more Pythonesque reimagining (PyANC350). It suppports DLL versions 2, 3, and 4.

The original implementation by Rob Heath (rob@robheath.me.uk) was updated to support later ANC350 libraries by Brian Schaefer (bts72@cornell.edu). Both of these were updated for Python 3.x and packaged as a proper Python module in December 2018.

## Installation

The package is on PyPI. To install via pip:

`pip install pyanc350`

Alternatively, you can download the repository and use it directly.

## Usage

The wrapper needs the attocube-provided DLLs to talk to the ANC350 hardware.

#### If using v2 of the ANC350 library:

Put `anc350v2.dll`, `nhconnect.dll`, and `libusb0.dll` in the same folder as your program.

#### If using v3 or v4 of the ANC350 library:

Put `anc350v3.dll` or `anc350v4.dll` and `libusb0.dll` in the same folder as your program.

### Import syntax:

If using v2: `from pyanc350.v2 import Positioner`

If using v3: `from pyanc350.v3 import Positioner`

If using v4: `from pyanc350.v4 import Positioner`

If using multiple, the cleanest way is to import the top-level module and use that:

```python
import pyanc350

p2 = pyanc350.v2.Positioner()
p3 = pyanc350.v3.Positioner()
p4 = pyanc350.v4.Positioner()
```
lnet 0.0.5
Utilities to define and bootstrap lightning networks for testing

# lnet -- Simplified Lightning Network Setup

Have you ever tried setting up a small Lightning Network on regtest to
develop or demo against, and found it frustrating and confusing?
`lnet`'s goal is to make it easy to spin up any network topology for
testing or demoing, all you need to do is describe the network in the
graphviz `dot` format.

Take the following example, which will spin up two nodes, called
`client` and `server` respectively, connect them and fund a
channel. It'll also create an invoice on the server to balance the
channel by sending over 500'000msat. You describe it, we make it
happen.


```dot
graph g {
  client -- server [capacity="10000000:500000"];
}
```

A more complicated setup could be a star topology and some multi-hop paths:

```dot
graph g {
  client1 -- server [capacity="10000000"];
  client2 -- server [capacity="10000000"];
  client3 -- server [capacity="10000000"];
  client4 -- server [capacity="10000000"];
  client5 -- server [capacity="10000000"];
  
  "client5-1" -- client5 [capacity="10000000"];
  "client5-2" -- client5 [capacity="10000000"];
  "client5-3" -- client5 [capacity="10000000"];

}
```



## Installation

`lnet` is just a simple `pip install` away:

```bash
pip3 install lnet
```

This will install the `lnet-cli` and `lnet-daemon` command line
utilities. `lnet-daemon` starts, monitors and provides access to
`bitcoind` and any number of `c-lightning` nodes, while `lnet-cli` is
used to interact with the daemon and the nodes.

## Usage

All operations are performed through `lnet-cli`, which will start
`lnet-daemon` if required. `lnet-cli` has the following commands:

 - `start [dotfile]` parses the `dotfile`, extracting nodes and
   channels, and tries to recreate the desired topology. It'll open
   channels and confirm them to make the usable, however it currently
   requires that the network topology is not partitioned. See below
   for attributes that are defined.
 - `stop` stops the currently running topology
 - `shutdown` stops the running topology and shuts down the `lnet-daemon`
 - `node [nodename] [rpc_method] [params...]` executes `rpc_method` on
   the node with name `nodename` and the specified `params`. This is
   mainly used as a shorthand to give access without having to
   configure your shell.
 - `alias` configures your shell with a number of aliases to make it
   easy to interact with the daemons without going through
   `lnet-cli`. You can use it with `eval $(lnet-cli alias)`.
bullock 1.0.0
Distributed lock using Redis

=======
Bullock
=======

A distributed lock using Redis. Inspired by `Sherlock <https://github.com/RealGeeks/sherlock>`_.

.. image:: https://travis-ci.org/jbochi/bullock.svg?branch=master
    :target: https://travis-ci.org/jbochi/bullock


Installation
------------

.. code:: bash

    $ pip install bullock


Usage
-----

.. code:: python

    from bullock import Bullock
    lock = Bullock(host="redis-hostname", key="my-first-lock", ttl=3600)
    lock.acquire(blocking=True)
    # do critical work here
    lock.release()

You can also use the with statement:

.. code:: python

    from bullock import Bullock
    with Bullock(host="redis-hostname", key="my-first-lock", ttl=3600):
        # do critical work here

Also supports using redis cluster:

.. code:: python

    from bullock import Bullock
    lock = Bullock(host="redis-hostname", key="my-first-lock", ttl=3600, redis_cluster=True)
    lock.acquire(blocking=True)
    # do critical work here
    lock.release()

For more examples, see tests_.

.. _tests: https://github.com/jbochi/bullock/blob/master/tests/test_bullock.py