semvec/pypi-packages huggingface dataset:
goat-sdk-example-langchain-uniswap 0.1.0
Goat example for Langchain with uniswap
Requires Python: <4.0,>=3.12
Keywords: goat, sdk, web3, agents, ai

# Langchain web3 Example

## Setup

Copy the `.env.template` and populate with your values.

```
cp .env.template .env
```

Install dependencies

```
poetry install
```

## Usage

```
poetry run example.py
```
upy2 2.3.4
Uncertainty propagation of intercorrelated multidimensional quantities

Measurements are precise only up to a particular *uncertainty*.  Such
measurement results are thus called *uncertain quantities*.  When
performing calculations with uncertain quantities, the uncertainties of the
results depend on the uncertainties of the operands involved.  The
quantification of uncertainties resulting from a mathematical operation
involving uncertain operands is called *uncertainty propagation*.

From a programmer's point of view, uncertainties might be associated with
the respective nominal values, such that the propagation of uncertainties
happens automatically, and existing algorithms can be re-used with the
*uncertain quantities* as arguments.  Here I am proposing a Python package
to define uncertain operands, to carry out calculations using such operands
*with uncertainty propagation*, and to provide string representations of
uncertain quantities involved.

Complex numbers can be used to define uncertain quantities; for such
complex-valued uncertainties no net uncertainty can be calculated.

The objects holding uncertain values have array properties, though scalar
arrays can be used; elements of an uncertain array behave as if they were
uncertain quantities on their own.

When requesting a string representation of an uncertain quantity, the
typeset result depends on the number of standard deviations to use and on
the chosen precision, given by the number of digits with respect to the
uncertainty.  Furthermore, when typesetting multidimensional arrays with
uncertainty, the decimal fractions are aligned to improve readability of
the results.

``upy`` uses *algorithmic differentiation* (also known as *automatic
differentation*) to track uncertainties through the operations.  Uncertain
values might be used in calculations together with other uncertain values
as well as with any numeric Python or ``numpy.ndarray`` objects.  A range
of mathematical functions is supported.

``upy`` provides several syntactic conventions appropriate to the
subject.  For instance, defining uncertain quantities is possible by
writing:

.. code:: python

    uvalue = nominal +- u(uncertainty)

where ``u`` is a function provided by ``upy``.  Uncertain values
constructed in this way will be independent of each other with respect to
their uncertainties; ``upy`` will keep track of the correlations arising
from combination of uncertain quantities in mathematical operations.  All
functionality is suited both for use in the interactive Python shell as
well as in programs for numerical analysis.
wqferr-image-processing 0.1.1
An example package wrapping simple functionality from skimage.
Requires Python: >=3.8

# wqferr_image_processing

Description.
The package wqferr_image_processing is used to:

- Resize images given a proportion;
- Match histograms from one image to another.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install wqferr_image_processing

```bash
pip install wqferr_image_processing
```

## Usage

```python
from wqferr_image_processing.processing import combination
combination.find_difference(im1, im2)
```

## Author

William Q Ferreira

## License

[MIT](https://choosealicense.com/licenses/mit/)
rse-api-client 0.1.2
A client for RSE API

# RSE API CLIENT

Este es un módulo para interactuar con la API RSE. Es una implementación básica para simplemente agregar el módulo, instalar las dependencias, agregar los valores correspondienetes en el archivo .env para luego hacer uso de la funcionalidad.

## Visita el repositorio en Github
Link al repo: [GitHub](https://github.com/danicode/rse-api-client)

## Instalación

### 1. Crear y Activar un Entorno Virtual

Primero, crea y activa un entorno virtual:

```bash
# Crear un entorno virtual
python -m venv venv
```

```bash
# Activar el entorno virtual (Windows)
venv\Scripts\activate
```

```bash
# Activar el entorno virtual (MacOS/Linux)
source venv/bin/activate
```

```bash
# Desactivar el entorno virtual (Windows)
deactivate
```

### 2. Instala las dependencias

Las dependencias que se instalarán son:
* requests
* python-dotenv

Para ello ejecuta el siguiente comando:
```bash
pip install .
```

## Configuración

Ejecuta el siguiente comando o copia tu editor el archivo .env.example y renombralo .env

Dentro estan los valores que se necesitan para realizar las peticiones RSE API.

### Comando
```bash
cp .env.example .env
```

### Valores dentro de .env.example 
En tu nuevo archivo .env, cambia por los que correspondan. Esto es lo básico la idea sería ir agregando los endpoints que necesites para luego pasarle a la función para realizar la petición.

```bash
URL=https://api.rse.example.com
USERNAME=tu_usuario
PASSWORD=tu_clave
ENDPOINT_JOBS=jobs
```

## Uso del Módulo
Para hacer uso del módulo en cualquier script de Python y especificar el endpoint que deseen:

from rse_api_client import RSEAPIClient

```python
client = RSEAPIClient()
response = client.make_request('get', 'jobs')
print("Response:", data)
```

## Ejecutar Test
```bash
python -m unittest discover -s tests
```