semvec/pypi-packages huggingface dataset:
verbs 0.4.1
Ethereum ABM Library
Requires Python: >=3.8
Keywords: ethereum, agent-based modelling, simulation, defi

# VERBS

Python ABM library built around Rust backend.

Full documentation can be found [here](https://simtopia.github.io/verbs/).

## Getting Started

### Installation

VERBS can be installed via pip using

```
pip install verbs
```

### Building from Source

Building VERBS requires [maturin to be installed](https://www.maturin.rs/installation).

> :warning: On OSX ``patchelf`` should be manually installed using
  [homebrew](https://brew.sh)

The Python package can be built using [hatch](https://hatch.pypa.io/latest/)
by running

```
hatch run dev:build
```

### Jupyter Notebook

A jupyter notebook with VERBS installed as a dependency can be
run using [hatch](https://hatch.pypa.io/latest/)

```
hatch run notebook:jupyter
```

### Git Dependency

VERBS can be added as a direct dependency to your projects `pyproject.toml`
but requires maturin to be added as a build requirement, for example

```
[build-system]
requires = ["setuptools >= 61.0", "maturin>=1.2,<2.0"]
build-backend = "setuptools.build_meta"
```

## Examples

Examples of models implemented using VERBS can be
found in `/examples`. Larger examples can also be found in this
[repo](https://github.com/simtopia/verbs-examples).

## Developers & Contributing

VERBS is under active development, if you notice a problem
or have a suggestion please [open an issue](https://github.com/simtopia/verbs/issues).

We welcome contributions to this project, see [here](https://github.com/simtopia/verbs/blob/main/.github/docs/developers.md)
for developer notes.

## Rust Package

The core rust simulation engine can be used to write simulation
purely in Rust, with a significant gain in performance over
Python in most cases. See [here](https://docs.rs/verbs-rs/latest/verbs_rs/)
for the Rust package API documentation and
[here](https://github.com/simtopia/verbs/blob/main/.github/docs/rust.md)
for usage notes.

## Acknowledgements

VERBS simulation environments make extensive use of [revm](https://github.com/bluealloy/revm) a
Rust implementation of the Ethereum virtual machine, and [alloy](https://github.com/alloy-rs/)
Rust Ethereum libraries.
siglent-scpi 1.0.3
A package to automate Siglent equipment
Requires Python: >=3.11

# siglent_scpi

Use networked Siglent devices from a computer over SCPI over ethernet.

This package lets users control and read Siglent devices which are connected by ethernet through the SCPI protocol. Some highlevel functions are included, like collecting a waveform, performing its FFT, and calculating the total harmonic distortion.

With this package automated measurements can be done. Advantages of taking automated measurements are:

- repeatability
- timesaving
- automated logging

The next plot shows an example experiment which has been performed with the library, showing the total harmonic distortion of a demodulated FM signal in three different scenario's. These measurements in total take about 15 minutes, while doing them manually would take several hours.

![Alt text](resources/thd_vs_modfreq.png)


## SDS

Class to connect to a Siglent oscilloscope. Currently the class has only been tested on a SDS1202X-E oscilloscope. It connects to the oscilloscope using sockets over ethernet.


## SDG

Class to connect to a Siglent signal generator. Currently the class has only been tested on a SDG1032X signal generator. It connects to the signal generator using sockets over ethernet.


## Example program

The example program thd_ch1.py shows how to get a continuously updated display of the FFT spectrum of channel 1 while also calculating and showing the total harmonic distortion.

An example output of the sample program is showing the output for a 1kHz signal from a signal generator (gif, low quality).

![Alt text](resources/Screencast-from-2024-04-06-21-19-27.gif)


## Installation

Installation from pypi.org in your Python environment with:

```
python3 -m pip install siglent_scpi
```


## Things to be done:

- eror checking
- implement selection of windowing methods in SDS.fft()
- in SDS class, get equal parameters for channel selection in different methods (now a mix of string and int). This will break API.
lambda-calculus 3.1.0
Implementation of the Lambda calculus
Requires Python: >=3.10

# lambda_calculus

[![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
![Tests](https://github.com/Deric-W/lambda_calculus/actions/workflows/Tests.yaml/badge.svg)
[![codecov](https://codecov.io/gh/Deric-W/lambda_calculus/branch/main/graph/badge.svg?token=SU3982mC17)](https://codecov.io/gh/Deric-W/lambda_calculus)
[![Documentation Status](https://readthedocs.org/projects/lambda-calculus/badge/?version=stable)](https://lambda-calculus.readthedocs.io/en/stable/?badge=stable)

The [`lambda_calculus`](https://pypi.org/project/lambda-calculus/) package contains classes which implement basic operations of the lambda calculus.

To use it, simply import the classes `Variable`, `Abstraction` and `Application` from this package
and nest them to create more complex lambda terms.

You can also use the `visitors` subpackage to define your own operations on terms or
use predefined ones from the `terms` subpackage.

More information is available on [Read the Docs](https://lambda-calculus.readthedocs.io/).

## Notice

This package is intended to be used for educational purposes and is not optimized for speed.

Furthermore, it expects all terms to be finite, which means the absence of cycles.

`RecursionError` may be raised if the visitors get passed an infinite term or the evaluation is too complex.

## Requirements

Python >= 3.10 is required to use this package.

## Installation

```sh
python3 -m pip install lambda-calculus
```

## Examples

(λy.(λx.(λy. + x y)) y 3) 4

### Nesting

```python
from lambda_calculus import Variable, Abstraction, Application

term = Application(Variable("+"), Variable("x"))
term = Application(term, Variable("y"))
term = Abstraction("y", term)
term = Abstraction("x", term)
term = Application(term, Variable("y"))
term = Application(term, Variable("3"))
term = Abstraction("y", term)
term = Application(term, Variable("4"))
```

### Utility Methods

```python
from lambda_calculus import Variable, Abstraction, Application

x = Variable.with_valid_name("x")
y = Variable.with_valid_name("y")

term = Application.with_arguments(Variable.with_valid_name("+"), (x, y))
term = Abstraction.curried(("x", "y"), term)
term = Application.with_arguments(term, (y, Variable.with_valid_name("3")))
term = Abstraction("y", term)
term = Application(term, Variable.with_valid_name("4"))
```

### Method Chaining

```python
from lambda_calculus import Variable, Abstraction, Application

x = Variable.with_valid_name("x")
y = Variable.with_valid_name("y")

term = Variable("+") \
    .apply_to(x, y) \
    .abstract("x", "y") \
    .apply_to(y, Variable("3")) \
    .abstract("y") \
    .apply_to(Variable("4"))
```

### Evaluation

```python
from lambda_calculus import Variable, Application
from lambda_calculus.visitors.normalisation import BetaNormalisingVisitor

assert BetaNormalisingVisitor().skip_intermediate(term) == Application.with_arguments(
    Variable("+"),
    (Variable("4"), Variable("3"))
)
```