semvec/pypi-packages huggingface dataset:
OniApiHelper 1.0
Helper para consumo de APIs
Keywords: onimusic

# OniDev's Helper Para Consumo das API's

Retorna objeto json da requisição das API's trabalhadas até o momento.

A documentação completa do pacote está disponível em: [Pypi:oni_api_helper](https://pypi.org/project/oni-api-helper/).

## Como testar sua contribuíção antes de enviar uma PR
Primeiramente faça a desinstalação do pacote presente em sua `venv`.

```bash
pip uninstall oni_api_helper
```

Após a desinstalação, instale o pacote atráves do código fonte modificado.

```bash
pip install -e <path>/oni_api_helper/
```

Teste a implementação feita em um projeto terceiro ou até mesmo usando os códigos de teste disponíveis. Após testar o código atual faça a desinstalação do pacote novamente.

```bash
pip uninstall oni_google_api_helper
```

Após o teste crie sua PR e envie para avaliação.
Se deseja que sua PR vire uma nova release, não se esqueça de mudar no `setup.py` na opção version adicione o nome da
próxima versão proposta para o pacote.

## Como criar uma nova release do projeto
Uma vez que sua contribuição for aprovada via PR você está preparado para criar uma nova release do projeto.

O primeiro passo é criar uma nova tag com base no commit que foi aprovado. Para isso na branch master execute o comando:

```bash
git tag -a <tag_name> -m "<comentário descritivo da tag>"
```

Exemplos de `tag_name`: `v1.2`, `v1.2.3` ou `v1.2-beta`

Com a tag criada faça o seu envio para o repositório no `GitHub`.

```bash
git push origin <tag_name>
```

Com a tag enviada podemos seguir para a criação de uma release.
Essa pode ser criada diretamente pelo github com os seguintes passos:
 - Vá no repositório do projeto no GitHub na aba Code.
 - Acesse o menu Releases presente, normalmente, no lado direito.
 - Clique na opção Tags para ver a listagem de tags.
 - Clique nos três pontinhos a direita na tag que você acabou de criar.
 - Selecione a opção create release.
 - Adicione um nome na release (pode ser o mesmo nome da tag) e uma descrição para as novas features da tag.
lattice-addons-lightning 0.1.1
Lattice Add-ons
Requires Python: >=3.7

# State Needed from Agent
The addons use a set of environment variables that are passed from the agent to understand where they should write checkpoints and how often.
It utilizes the following:

`LATTICE_CHECKPOINT_ENDPOINT`

This is a string which indicates where the add-ons should write and look for checkpoints.
If using S3 for example, it takes the following format: `s3://breeze-checkpoint/path/to/storage/`
It will then use this endpoint to find the S3 bucket and the storage path and save the checkpoints there.

`LATTICE_RUN_ID`

This is a string which indicates the current rendezvous ID.
This is taken from the agent's `LATTICE_RDZV_ID` so that when storing checkpoints they can be stored
safely without conflicting with checkpoints stored by other jobs using the same storage backend.
Continuing the example above, the worker would store its checkpoints at
`s3://breeze-checkpoint/path/to/storage/<run_id>/checkpoint/`.
TODO: Make the usage of `run_id` and `rdzv_id` consistent.

`LATTICE_STEPS_PER_CHECKPOINT`

This is passed to the agent to tell it how often to write checkpoints.
This can be configured by the agent's --steps-per-checkpoint CLI arg or environment variable.


## How to pass state
There are two ways to pass state to the worker:

1. Add it to the `extra_env` dictionary seen [here](https://github.com/breezeml/lattice-agent/blob/8571870de3e2635819edeb4f48b289c9e0eb3b01/src/lattice/torch/launcher/api.py#L227)

2. Add it to the `worker_env` dictionary seen [here](https://github.com/breezeml/lattice-agent/blob/8571870de3e2635819edeb4f48b289c9e0eb3b01/src/lattice/elastic/agent/server/lattice_agent.py#L58)

    **Warning** Make sure all state passed through this dict is a string!
# How to use Lightning Addons
Use the import:
```python
from lattice_addons.lightning.elastic import ElasticityProvider
```

Then add this as a callback to your Trainer:
```python
trainer = Trainer(
    default_root_dir='.',
    max_epochs=30,
    devices=int(os.environ['LOCAL_WORLD_SIZE']),
    accelerator='gpu',
    num_nodes=int(os.environ['WORLD_SIZE']),
    strategy='ddp',
    callbacks=[ElasticityProvider(storage_location, every_n_steps=10, batch_size=local_batch_size)],
)
```
+ **Note**: For now the only supported storage locations are S3 buckets
lattice-agent 0.1.2
Lattice Agent
Requires Python: >=3.7

# Lattice Agent

## Lattice Agent for PyTorch

Basic usage:

```shell
python -m lattice.torch.run YOUR_TRAINING_SCRIPT.py
```

### Configure agent using arguments

The first way to pass arguments to the agent is to pass them directly to the training script, for example:
```
python -m lattice.torch.run --nnodes 1:8 --nproc_per_node 1 --rdzv_backend etcd YOUR_TRAINING_SCRIPT.py
```

The arguments include:

```
nnodes:                     (required) Number of nodes, or the range of nodes in form <min_nodes>:<max_nodes>
nproc_per_node:             (not required; default=1) Number of workers per node

rdzv_backend:               (not required; default=etcd) Backend used for rendezvous (currently only supports etcd)
rdzv_client_service_host:   (required) Rendezvous backend endpoint
rdzv_client_service_port:   (not required; default=2379) Rendezvous backend port
rdzv_id:                    (required) User-defined identifier for this job
rdzv_conf:                  (not required; default="") Additional rendezvous configurations in form (<key1>=<val1>,<key2>=<val2>,...)

checkpoint_endpoint:        (required) Path to directory or URI indicating where to store checkpoints
steps_per_checkpoint:       (not required; default=20) The number of training steps run before saving a checkpoint

trainin_script:             (required) Your training script
training_script_args:       (requirement depends on training_script) Args to the training script
```


### Configure agent using environments variables

The second way is to pass the args to the training script through environment variables.
For every arg listed above, the corresponding environment variable to set it can be found
by using the following rule: The argument name is capitalized and preceded by "LATTICE_".
For example: `nnodes = LATTICE_NNODES`.

Therefore, you can use the following example to run the agent and set all its arguments:

```
LATTICE_NNODES=1:8                          \
LATTICE_NPROC_PER_NODE=1                    \
LATTICE_RDZV_CLIENT_SERVICE_HOST=localhost  \
LATTICE_RDZV_CLIENT_SERVICE_PORT=2379       \
LATTICE_RDZV_BACKEND=etcd                   \
LATTICE_RDZV_ID=test-id                     \
LATTICE_CHECKPOINT_ENDPOINT=s3://bucket/    \
LATTICE_STEPS_PER_CHECKPOINT=30             \
python -m lattice.torch.run YOUR_TRAINING_SCRIPT.py
```