semvec/pypi-packages huggingface dataset:
nipiezojenapy 1.0.4
A package for controlling Jena PiezoSystem NV40 3CLE amplifier vi NIDAQMX.
Requires Python: >=3.8
Keywords: qt3,National Instruments,Jena,piezo,stage,control

# Control of PiezoSystemJena NV40/3CLE via NI DAQmx

Control of the Jena's piezo accuators via their multi-channel amplifier.
https://www.piezosystem.com/products/amplifiers/multi-channel/40ma-multi-channel-amplifiers/

Uses NIDAQ device to read and write analog voltages between 0 and 10 to
three input and output voltage channels connected to a Jena NV40/3CLE
amplifier. Each input/output channel controls one of three axis (x, y, or z).

When using this software, one must at least provide three analog channels on
the NIDAQ that are connected to the NV40/3CLE amplifier that control (write)
the location of the piezo stage.

This program does not *need* to read voltages from the amplifier. If no read
channels are provided, this program will report the last written values when
reporting the current location.  

This controller does *NOT* lock out usage of analog input and output channels
on the NI-DAQ card. It writes or reads to the analog channels and then releases
the resource. This would allow external programs to access those channels, so
long as the access is not simultaneous.

## Installation

#### Requirements

This python package depends upon National Instruments driver and NI DAQ card
that contains three analog input and output channels.

You must first install the NI DAQmx driver.
[http://www.ni.com/downloads/](http://www.ni.com/downloads/).

PIP should install the rest of the dependencies.

### Local Installation

```
pip install nipiezojenapy
```

## Usage

### GUI Application

From the shell prompt, launch

```
> qt3piezo
```

For help on hardware configuration use the help option (`qt3piezo -h`)

### Programmatically

```
import nipiezojenapy
pcon = nipiezojenapy.PiezoControl(device_name = 'Dev1',
                                  write_channels = ['ao0','ao1','ao2'],
                                  read_channels = ['ai0','ai1','ai2'])
```

### Read Position

```
print(pcon.get_current_position())
[39.953595487425225, 40.047631567251806, 39.9510191567554]
```

### Go To Position

```
pcon.go_to_position(x = 20, y = 20, z = 20)
pcon.get_current_position()
[19.935887437291537, 19.94876864898489, 19.872769502734947]
```

Note that each axis can be set independently. That is, one may move along
a single axis without specifying the other axis values.

```
pcon.go_to_position(z = 40)
pcon.get_current_position()
[19.913989377848296, 19.988700406441584, 39.91623869419529]
```

# LICENSE

[LICENCE](LICENSE)
tympy 0.1.1
A Python library for observing output and execution times of scripts.
Requires Python: >=3.6

The `compare` function is designed to compare the execution speed of different Python functions on a set of files. It takes three arguments:

1. `FILES` (List of Strings): This argument accepts a list of file names. Each file should point to a Python file that you want to run.

2. `FUNCTIONS` (Single String or List of Strings): This argument can be either a single function name (as a string) or a list of function names (as a list of strings). If you pass a single function name, it will be applied to all files. If you pass a list of function names, the number of function names should match the number of files.

3. `ARGS` (Single String, List of Strings, Tuple, or List of Tuples): This argument can be one argument (as a string), one argument (as a tuple), or multiple arguments (as a list of tuples). If you pass a single argument, it will be applied to all functions. If you pass multiple arguments, the number of arguments should match the number of functions, and each argument should be passed as a tuple.

Here is an example of how to use the `compare` function:

First install and import the package:
```python
import tympy as TO
```

**Example 1: Compare Execution Speed of Multiple Functions in Multiple Files**
```python
TO.compare(["example_1.py", "example_2.py", "example_3.py"],
           ["sum", "SuM", "SuMIT"],
           [(5, 9), (9, 5), (5, 9)])
```


**Example 2: Compare Execution Speed of a Single Function Across Multiple Files**
```python
TO.compare(["example_1.py", "example_2.py"],
           "subtract",
           [(5, 9), (9, 5)])
```

**Example 3: Compare Execution Speed of Multiple Functions with Single Argument**
```python
TO.compare(["example_1.py", "example_3.py"],
           ["sum", "SuMIT"],
           (5, 9))
```

**Example 4: Compare Execution Speed of Multiple Functions with Single String Argument**
```python
TO.compare(["example_1.py", "example_2.py"],
           ["printNOW", "printNoW"],
           "Hello World!")
```

When comparing multiple files that perform similar tasks, it's important to note that they may have slight differences. Here's a suggested approach:

- **File Selection**: Select the files you wish to compare.
- **Function Identification**: Verify if the functions within these files have similar names. If not, create a list that maps the functions to their corresponding files based on their positioning.
- **Argument Verification**: Check if there are any arguments that need to be passed to these functions.
crontab-py 0.0.5
cron tab handler
Requires Python: >=3.8

# Crontab_py

## Introduction
Crontab_py is a Python module designed to simplify the management of cron jobs. It enables easy addition, removal, and listing of scheduled tasks.

## Example
```python
from crontab_py import Crontab

ct = Crontab()
ct.add_job(
    cmd="echo 'hello world'",
    frequency="* * * * *",
    path_to_log="/tmp/crontab.log",
    id="my_job",
    description="my job"
)
```

## Sphinx Documentation
Explore the [complete documentation](https://anglisano.github.io/crontab_py/) for detailed usage instructions and advanced features.

## Get Started
For installation and additional details, refer to the [official website](https://anglisano.github.io/crontab_py/) or check out the [API Guide](https://anglisano.github.io/crontab_py/api_guide.html).

Feel free to contribute, report issues, or suggest improvements by [raising an issue](https://github.com/anglisano/crontab_py/issues)
monotonic-stack 0.1.1
A monotonic stack
Keywords: monotonic,stack

# Monotonic Stack

The monotonic increasing stack and monotonic decreasing stack, namely monotonic stack, is a very powerful tool for finding next greater/smaller element.
More specifically, always **use monotonic increasing stack when we are trying to find the next smaller element, vice versa.**
The typical usage of monotonic stack is to find the next greater/smaller element in an array.

```
pip install monotonic_stack
```


This monotonic stack:
- works with any Python sequence, not just strings, if the items are hashable
- is implemented in pure Python

PyPi: https://pypi.org/project/monotonic-stack/

## Usage

``` py
>>> from monotonic_stack import MonotonicStack
>>> MS = MonotonicStack([1, 2, 3, 4, 5])
>>> MS.next_greater_on_right()
[2, 3, 4, 5, -1]
>>> MS.next_greater_on_left()
[-1, 1, 2, 3, 4]
>>> MS.next_smaller_on_right()
[-1, -1, -1, -1, -1]
>>> MS.next_smaller_on_left()
[-1, -1, -1, -1, -1]
```