semvec/pypi-packages huggingface dataset:
crimson-folder-sync 0.3.0
Your package description.
Requires Python: >=3.9

# Crimson Folder Sync

**Crimson Folder Sync** is a Python package designed to help you synchronize directories and automate certain system tasks with scripts.

## Installation

Install the package using pip:

```bash
pip install crimson-folder-sync
```

## Usage

### Directory Synchronization

To use the directory synchronization feature, import `MoveHandler` and `start_watching` from the package:

```python
from crimson.folder_sync.syncer import MoveHandler, start_watching

# Example usage
source_path = "/path/to/source"
base_source = "/path/to/base_source"
base_destination = "/path/to/base_destination"

start_watching(source_path, base_source, base_destination)
```

- **`MoveHandler`**: Handles file creation and modification events, copying the files from the source to the destination directory.
- **`start_watching`**: Watches the specified directory for changes and triggers the `MoveHandler` to copy files to the destination.

### Scripts

The package also includes utility scripts that can be accessed through the `Scripts` class.

```python
from crimson.folder_sync.load_script import Scripts

scripts = Scripts()

# Access the content of the linux_link_folders.sh script
print(scripts.linux_link_folders)
```

- **`linux_link_folders.sh`**: This script creates a symbolic link between two paths, allowing you to easily reference the target path from the symbolic path.

This package is designed to be a simple and effective tool for directory synchronization and basic system automation tasks.
localcloudforge 0.2.0
A tool for developing and testing AWS service integrations locally.
Requires Python: >=3.11.4

# LocalCloudForge

## Overview

**LocalCloudForge** is a library designed to simplify the process of working with AWS services in your local development environment. This library enables you to run your AWS service interactions locally, making it easier to test and develop your applications without incurring unnecessary costs. With just a simple decorator, you can enhance your development workflow, allowing you to focus on building your applications without worrying about cloud expenses.

## Features

- **Effortless Integration**: Simply decorate any function that instantiates an AWS service with @forge_local, and it will automatically execute in your local environment.
- **Support for Multiple AWS Services**: Integrate with various AWS services like S3, SNS, SQS, Lambda, and more without additional configuration. You can check for avaiable services [here](https://docs.localstack.cloud/user-guide/aws/feature-coverage/)

## Getting Started

### Requirements

To get started, ensure you have the following installed:

```bash
pip install boto3 localstack-client
```

### Running LocalStack

Start LocalStack using Docker with the following command:

```bash
docker run -p 4566:4566 -p 4571:4571 localstack/localstack
```

## Configuring AWS CLI for LocalStack

To interact with your LocalStack instance using the AWS CLI, you'll need to configure your AWS CLI settings. Add the following configurations to your AWS config and credentials files:

## Update your AWS Config:

Create or edit `~/.aws/config`:

```ini
[profile localstack]
region = us-east-1
output = json
endpoint_url = http://localhost:4566
```

## Update your AWS Credentials:

Create or edit `~/.aws/credentials`:

```ini
[localstack]
aws_access_key_id = test
aws_secret_access_key = test
```

## Using the AWS CLI with LocalStack

Once configured, you can execute AWS CLI commands using the LocalStack profile. Simply add the `--profile localstack` flag to your AWS CLI commands:

```bash
aws s3 ls --profile localstack
```

### Example Usage

Here's a quick example of how to use the `@forge_local` decorator:

```python
from local_cloud_forge import forge_local

@forge_local
def create_bucket(bucket_name):
    s3_client = boto3.client('s3')
    s3_client.create_bucket(Bucket=bucket_name)
    print(f"Bucket '{bucket_name}' created.")
```
nnbma 1.0.2
Neural network-based model approximation (nnbma)
Requires Python: >=3.8
Keywords: machine learning, neural network

# Neural network-based model approximation (nnbma)

[![PyPI version](https://badge.fury.io/py/nnbma.svg)](https://badge.fury.io/py/nnbma)
[![Documentation Status](https://readthedocs.org/projects/ism-model-nn-approximation/badge/?version=latest)](https://ism-model-nn-approximation.readthedocs.io/en/latest/?badge=latest)
![test coverage](./docs/coverage.svg)

Neural network-based model approximation `nnbma` is a Python package that handle the creation and the training of neural networks to approximate numerical models.
In \[1\], it was designed and used to derive an approximation of the Meudon PDR code, a complex astrophysical numerical code.

## Installation

To build your own neural network for your numerical model, we recommend installing the package.
The package can be installed with `pip`:

```shell
pip install nnbma
```

To reproduce the results from \[1\], clone the repo with

```shell
git clone git@github.com:einigl/ism-model-nn-approximation.git
```

Alternatively, you can also download a zip file.

This package relies on _PyTorch_ to build neural networks.
It enables to evaluate any neural network, its gradient, and its Hessian matrix efficiently.

If you do not have a Python environment compatible with the above dependencies, we advise you to create a specific conda environment to use this code (<https://conda.io/projects/conda/en/latest/user-guide/>).

## References

\[1\] Palud, P. & Einig, L. & Le Petit, F. & Bron, E. & Chainais, P. & Chanussot, J. & Pety, J. & Thouvenin, P.-A. & Languignon, D. & Beslić, I. & G. Santa-Maria, M. & Orkisz, J.H. & Ségal, L. & Zakardjian, A. & Bardeau, S. & Gerin, M. & Goicoechea, J.R. & Gratier, P. & Guzman, V. (2023). Neural network-based emulation of interstellar medium models. Astronomy & Astrophysics. 10.1051/0004-6361/202347074.