semvec/pypi-packages huggingface dataset:
convertable 0.1.0
CLI tools for converting between different formats such as JSON, YAML, and TOML
Requires Python: <4.0,>=3.12


# A set of CLI tools for converting between different data formats

## CLI Tools


### yamltojson
```
usage: yamltojson.py [-h] [-f FILE] [-p PATH] [-i INDENT] [--no-color] [-r]

options:
  -h, --help            show this help message and exit
  -f FILE, --file FILE  File path to open.
  -p PATH, --path PATH  Return a specific path, in dotted notation.
  -i INDENT, --indent INDENT
                        Number of spaces for indentation of JSON.
  --no-color            Don't print color to terminal
  -r, --reverse         Operate in reverse, converting JSON to YAML.
```
mercadolivresdk 0.0.3
biblioteca para integração com a API do Mercado Livre de forma facilitada
Requires Python: >=3.6

# MercadoLivre SDK
Este SDK oferece uma interface para gerenciar produtos na plataforma MercadoLivre usando Python.

## Funcionalidades
- Criação de produtos, 
- atualização e exclusão de produtos 
- Busca de produtos
- Fechamento de produtos
- Obtenção e atualização de descrições de produtos


## Instalação
Para instalar o SDK, use pip:

```bash

pip install mercadolivresdk
```
## Uso
```python
from mercadolivresdk import ProductManager, ProductCreate, ProductUpdate

# Inicialize o gerenciador de produtos
pm = ProductManager(access_token='seu_access_token')

# Exemplo de obtenção de um produto
product = pm.get_product(product_id='123456')
print(product)

# Exemplo de criação de um produto
new_product = ProductCreate(...)
created_product = pm.create_product(new_product)
print(created_product)

# Exemplo de atualização de um produto
updated_product = ProductUpdate(...)
pm.update_product(product_id='123456', product=updated_product)

# Exemplo de fechamento de um produto
pm.close_product(product_id='123456')

# Exemplo de exclusão de um produto
pm.delete_product(product_id='123456')

# Exemplo de obtenção da descrição de um produto
description = pm.get_product_description(product_id='123456')
print(description)

# Exemplo de atualização da descrição de um produto
new_description = ProductDescription(...)
pm.update_product_description(product_id='123456', description=new_description)
```

## Estrutura do Projeto
```markdown
mercadolivresdk/
│
├── __init__.py
├── product_manager.py
├── product_model.py
├── tests/
│   ├── test_product.py
├── .gitignore
├── LICENSE
├── README.md
├── requirements.txt
└── setup.py
```

## Contribuindo
Contribuições são bem-vindas! Por favor, abra uma issue ou envie um pull request.

## Licença
Este projeto está licenciado sob a licença MIT. Veja o arquivo LICENSE para mais detalhes.

## Contato
Para quaisquer dúvidas, por favor, abra uma issue neste repositório.
rolimons 2.8.5
Rolimons API Wrapper
Requires Python: >=3.7

# Rolimons
*An unofficial Python API wrapper for Rolimons*

rolimons.py is an api wrapper for [rolimons](https://rolimons.com) It allows you to fetch data from the official rolimons api as well as data that can only be scraped. 

**Getting Started**<br>
`pip install rolimons`

**Quick Start 🛠️**
```py
import rolimons

# Fetches full user data for Roblox
player = rolimons.player(username='Roblox')
print(player.rap, player.value)

# Fetches statistics for Valkyrie Helm
item = rolimons.item(1365767)
print(item.rap, item.value)

# Gets sales data for Valkyrie Helm
sales = item.get_recent_sales()
for sale in sales:
  print(sale.timestamp, sale.old_rap, sale.new_rap)
  
# Gets basic user data for users on the leaderboard
for player in rolimons.utils().get_leaderboard():
  print(player.name, player.value, player.rap)
```
magms 1.0.3
PyTorch training manager (v1.0.3)
Requires Python: >=3.9

# MAGNET: The First Attempt Towards Modality-Agnostic Networks for Medical Image Segmentation
Currently under review for *ISBI 2023*

## Pre-request
* Python >= 3.9
* [torchmanager](https://github.com/kisonho/torchmanager) >= 1.0.4
* Monai >= 0.9.0

## Get Started
1. Convert multiple datasets to a `magnet.data.TargetDataset` and use `magnet.data.TargetedDataLoader` to load the data
```
import ...
import magnet

# load data
train_dataset_1, val_dataset_1 = ...
train_dataset_2, val_dataset_2 = ...
...
target_dict = {0: "m1", 1: "m2", ...}
training_dataset = magnet.data.TargetedDataset(train_dataset_1, train_dataset_2, target_dict=target_dict)
training_dataset = magnet.data.TargetedDataLoader(training_dataset, batch_size=batch_size, shuffle=True, num_workers=1, pin_memory=True)
validation_dataset = {
    "m1": data.DataLoader(val_dataset_1, batch_size=batch_size, shuffle=False),
    "m2": data.DataLoader(val_dataset_2, batch_size=batch_size, shuffle=False),
	...
}
```

2. Simpy build the MAGNET (UNETR backbone) with `magnet.build` function
```
num_modalities: int = ...
num_classes: int = ...
img_size: Union[int, Sequence[int]] = ...
model = magnet.build(num_modalities, num_classes, img_size, target_dict=target_dict)
```

3. Or use the deeper `magnet.nn` framework to share layers in a `torch.nn.Module` by given names manually
```
model1: torch.nn.Module = ...
model2: torch.nn.Module = ...
shared_modules = {
	"layer1": model_to_share.layer1,
	"layer2": model_to_share.layer2,
	...
}
model = magnet.nn.share_modules([model1.some_layers, model2.some_layers], shared_modules, target_dict=target_dict)
```

4. Compile manager and train/test
```
optimizer = ...
loss_fn = ...
metric_fns = ...

epochs = ...
callbacks = ...

manager = magnet.Manager(model, optimizer, loss_fn=loss_fn, metric_fns=metric_fns)
manager.fit(training_dataset, epochs, val_dataset=validation_dataset, callbacks=callbacks)
summary.test(validation_dataset)
print(summary)
```

## Monai Support
* Using `magnet.MonaigManager` instead of `Manager` 
* Post processing support with `post_labels` and `post_predicts`
```
post_labels = [...]
post_predicts = [...]

manager = magnet.MonaigManager(model, post_labels=post_labels, post_predicts=post_predicts, optimizer=optimizer, loss_fn=loss_fn, metric_fns=metric_fns)
```
Easy-NLP-Augmentation 1.0
A package for augmenting text data using NLP techniques
Requires Python: >=3.6

# Text Augmenter

Text Augmenter is a Python package for augmenting text data directly on your pandas dataframe using various NLP techniques. 
There are only 3 techniques now : 
- augment_random_word
- augment_random_character
- augment_word_bert

### augment_random_word


## Installation

```bash
pip install text_augmenter
jinn-ai 0.0.1
TBD
Requires Python: >=3.8

# jinn-ai

[![PyPI - Version](https://img.shields.io/pypi/v/jinn-ai.svg)](https://pypi.org/project/jinn-ai)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/jinn-ai.svg)](https://pypi.org/project/jinn-ai)

-----

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install jinn-ai
```

## License

`jinn-ai` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
jetset 1.3.0
A framework for self-consistent modeling and fitting of  astrophysical relativistic jets SEDs
Requires Python: >=3.8


JetSeT is an open source C/Python framework to reproduce radiative and accelerative processes acting in relativistic jets, and galactic objects (beamed and unbeamed), 
allowing to fit the numerical models to observed data. The main features of this framework are:

 * handling observed data: re-binning, definition of data sets, bindings to astropy tables and quantities
   definition of complex numerical radiative scenarios: Synchrotron Self-Compton (SSC), external Compton (EC) and EC 
   against the CMB 
 
 * Constraining of the model in the pre-fitting stage, based on accurate  and already published phenomenological trends. 
   In particular, starting from phenomenological parameters, such as spectral indices, peak fluxes and frequencies, and 
   spectral  curvatures, that the code evaluates automatically, the pre-fitting algorithm is able to provide a good 
   starting model,following the phenomenological trends that I have implemented. fitting of multiwavelength SEDs using  
   both frequentist approach (iminuit) and bayesian MCMC sampling (emcee)
 
 * Self-consistent temporal evolution of the plasma under the effect of radiative and accelerative processes, both first  
   order and second order (stochastic acceleration) processes.



## Acknowledgements

If you use this code in any kind of scientific publication please cite the following papers:

* `Tramacere A. 2020`  https://ui.adsabs.harvard.edu/abs/2020ascl.soft09001T/abstract
* `Tramacere A. et al. 2011` http://adsabs.harvard.edu/abs/2011ApJ...739...66T
* `Tramacere A. et al. 2009` http://adsabs.harvard.edu/abs/2009A%26A...501..879T
* `Massaro E. et. al 2006`   http://adsabs.harvard.edu/abs/2006A%26A...448..861M

## Licence

JetSeT is released under a 3-clause BSD  license,  for deatils see
[License](https://github.com/andreatramacere/jetset/blob/master/LICENSE.txt) file 


# Documentation
visit: https://jetset.readthedocs.io/en/latest/

visit: https://github.com/andreatramacere/jetset