semvec/pypi-packages huggingface dataset:
logfrog 1.0.0
A simple and efficient logging package in python with async support

# FrogLog

FrogLog is an efficient, thread-safe logging library in Python. This nimble logger, designed with simplicity, offers non-blocking, asynchronous logging, making it perfect for applications that prioritize performance.

## Features

- **Asynchronous Logging:** Dispatch logs to a separate thread, freeing your application from waiting on IO operations.
- **Log Levels:** Differentiate the importance of messages with `INFO`, `DEBUG`, `WARNING`, `ERROR`, and `CRITICAL` levels.
- **Function Logging:** Automatically log function calls, tracking names, arguments, and return values.
- **Stack Tracing:** Log the current stack trace, invaluable for debugging and understanding complex code execution paths.

## Usage

```python
from froglog import FrogLog

logger = FrogLog(filename="app.log")

# Dispatch logs
logger.info("Info message")
logger.debug("Debug message")
logger.warning("Warning message")
logger.error("Error message")
logger.critical("Critical message")

# Log function calls
@logger.log_function
def test_function(a, b):
    return a + b

test_function(2, 3)

# Log current stack
logger.log_stack()

# Gracefully stop the logger
logger.stop()
```
## Contributing
Thanks for making it this far! Here are some pointers to get you started - 

### Feature Suggestions

- **Configurable Log Formats:** Allow users to customize the format of the log output, such as including the file name and line number, or changing the timestamp format.

- **Remote Logging:** Add support for logging to remote systems, such as logging servers or cloud storage.

- **Performance Metrics:** Log system performance metrics like memory and CPU usage.

- **Integration with Monitoring Tools:** Provide easy integration with popular monitoring and alerting tools.

- **Log Rotation:** Implement automatic log rotation to prevent logs from consuming too much disk space.

- **Filtering and Searching:** Provide capabilities to filter and search logs based on certain criteria, such as log level, timestamp, or content.

Thank you for your interest in FrogLog. We look forward to your contributions!
nlp2fn 0.0.4
With the ability to load and read Python functions from any specified location, `nlp2fn` brings all your automation tasks together.

# Python Automation Made Simple: [nlp2fn](https://pypi.org/project/nlp2fn/)

Welcome to `nlp2fn`, a seamless and intuitive software tool for Python automation. With the ability to load and read Python functions from any specified location, `nlp2fn` brings all your automation tasks together. Whether your functions reside in local directories or remote servers, `nlp2fn` fetches, loads, and prepares them for execution — as simple as a statement.


## The Magic of nlp2fn

A typical function for `nlp2fn` follows this format:

```python
# Write you execute statement, this shall be an 
# input by user to execute your events, make sure all the 
# parameters that are required by event is properly captured with {param_name}.
STATEMENT = "download {link} to {output_dir}"


# This shall be the main function for your event. once 
def execute(args):
    file = args[0]
    output_dir = args[1]
    
    # Complete the function.
    return True
```

The `execute` function is the heart of the operation where the actual task takes place.

## Quick Start Guide

Here's how to install and get started with [`nlp2fn`](https://pypi.org/project/nlp2fn/):

```bash
pip install nlp2fn
```

Next, add the source directory where your Python functions are located:

```bash
nlp2fn add-source /path/to/directory
```

or 

```bash
nlp2fn add-source https://github.com/{githubid}/{repo}
```

make sure repo is public.


Ready to launch `nlp2fn` as a chatbot? Use this command:

```bash
nlp2fn run
```

To run a single statement, use the `exec` command:

```bash
nlp2fn exec -m "statement"
```

If you need to reset your sources, simply use the `reset` command:

```bash
nlp2fn reset
```

If you need to remove any source your sources, simply use the `delete ` command:

```bash
nlp2fn delete
```

If you need to update the source, both remote or local use `update` command

```bash
nlp2fn update
```

## Join the Development

We welcome your contributions! Feel free to submit pull requests and create issues on our [GitHub page](https://github.com/dextrop/nlp2fn/issues).

## View ChangeLog

[GitHub Release page](https://github.com/dextrop/nlp2fn/blob/main/CHANGELOG.md).

## Contact

For questions, suggestions, or any kind of discussion, feel free to open an issue on our GitHub page.

Embrace the simplification of Python automation with `nlp2fn`.

## Events

- Langchain Automations : https://github.com/dextrop/evt-langchain
- https://medium.com/@askjennie/creating-your-own-automation-library-with-nlp2fn-6657b1276361
pythonabm 0.3.3
Framework for building Agent-Based Models (ABMs) in Python
Requires Python: >=3.7

# PythonABM
[![Documentation Status](https://readthedocs.org/projects/pythonabm/badge/?version=latest)](https://pythonabm.readthedocs.io/en/latest/?badge=latest)
[![PyPI version](https://badge.fury.io/py/pythonabm.svg)](https://badge.fury.io/py/pythonabm)
[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![GitHub](https://badgen.net/badge/icon/github?icon=github&label)](https://github.com/kemplab/pythonabm)



PythonABM makes complex agent-based modeling (ABM) simulations in Python accessible by providing an efficient base framework
for constructing ABMs. More information on PythonABM can be found below.

* Documentation:  [pythonabm.readthedocs.io](https://pythonabm.readthedocs.io/en/latest/index.html)
* PyPI:  [pypi.org/project/pythonabm](https://pypi.org/project/pythonabm/)

<p align="center">
    <img src="https://github.com/kemplab/pythonabm/blob/main/docs/front_image.png?raw=true" alt="" width="500">
<p>


## 
### Installation
Assuming you have Python 3.7-3.10, the latest version of the PythonABM library can be installed using the following command.
```
pip install pythonabm
```

PythonABM can also be built from [source](https://github.com/kemplab/pythonabm) once downloaded from GitHub.
```
python setup.py install
```

##

### Running a simulation
Calling the start() method in the Simulation class will launch the ABM platform and run it as follows.
(See the ***example.py*** script as a template for building a simulation.) A
text-based UI will prompt for a ***name*** of the simulation and a corresponding ***mode*** (described below).
- 0: New simulation
- 1: Continue a previous simulation
- 2: Convert a previous simulation’s images to a video
- 3: Archive (ZIP) a previous simulation’s outputs

To avoid the text-based UI, the name and mode can be passed at the
command line by using flags (without the parentheses). Note: the
simulation file does not have to be named “main.py”.
```
python main.py -n (name) -m (mode)
```

When continuing a previous simulation (mode=1), the ABM will prompt for
the updated end-step number, though this can be passed like above.
```
python main.py -n (name) -m (mode) -es (end-step)
```

##

### NVIDIA CUDA support
For GPU parallelization, PythonABM requires a CUDA compatible GPU and NVIDIA’s
CUDA toolkit. If you don’t have the toolkit, download the
toolkit either directly from NVIDIA
[here](https://developer.nvidia.com/cuda-downloads) or with [Anaconda's](https://www.anaconda.com/) conda
command show below.

```
conda install cudatoolkit
```

##
mia-api 0.0.4
A package to communicate with MIA API
Requires Python: >=3.6

# mia_api

## QuickStart

- If necessary you need insert PYTHONPATH variable in your bashrc
```python
export PYTHONPATH='/home/user/scripts/mia_api:$PYTHONPATH'
```
## First Login

- Create the file .mia_api in your home directory with your credentials sent to you by a mia_api admin

```
username: MIA_API_USERNAME
password: MIA_API_PASSWORD
```

- Alternatively you can set MIA_API_USERNAME and MIA_API_PASSWORD as environment variables

## Using the API

1. Import the package
```python
import mia_api
```

2. Connect
```python
mia_api.connect()
```
by default, the API stayed connected during 30 min.

3. knowing all the bar availables
```python
mybar=mia_api.JuiceBar('test') 
JuiceBar.available_bars()
```

4. Get bar
```python
mybar=mia_api.JuiceBar('MIABAR_stable_v1.2_tom3')
```

5. knowing all juice availables
```python
mybar.show_menu()
```

6. Get juice
```python
myjuice=mybar.get_juice('ons_VazaoNat_usinas')
```

7. Select if you want a historical or operational juice
```python
myjuice.historical() --> returns data xarray if dataset=True returns dataset

from datetime import datetime
myjuice.operational(rundate=datetime(2022,6,22,0,0,0))
myjuice.operational(rundate=[datetime(2022,6,1,0,0,0), datetime(2022,6,22,0,0,0)])
myjuice.operational()
```

# Function

Soon there will by examples