semvec/pypi-packages huggingface dataset:
woom 2025.10.1
Workflow manager for ocean models
Requires Python: >=3.9

Workflow manager for ocean models
=================================

|ci| |docs|

woom is designed to help you submit workflows for running ocean models.
Organize and run your tasks with only three configurations files.


Installation
------------

From sources::

   pip install .

Documentation
-------------

The woom documentation:
https://woom.readthedocs.io/

Sources
-------

Sources are available on the woom gitlab page:
https://github.com/shom-fr/woom

Contributing
------------

Please feel free to contribute to the project!
Start by taking a look at the project's contributing guide.

License
-------

woom is a property of `Shom <https://www.shom.fr>`_ and is published under the
`Apache 2.0 license <https://www.apache.org/licenses/LICENSE-2.0>`_.

.. |ci| image:: https://github.com/shom-fr/woom/actions/workflows/ci.yml/badge.svg
   :alt: Continuous Integration Tests
   :target: https://github.com/shom-fr/woom/actions/workflows/ci.yml

.. |docs| image:: https://app.readthedocs.org/projects/woom/badge/?version=latest&style=default
    :alt: Documentation Status
    :target: https://woom.readthedocs.io/en/latest/
crunch-encrypt 0.1.0
crunch-encrypt - Encryption module for the CrunchDAO Platform
Requires Python: >=3
Keywords: package development template

# Crunch Encrypt Tool

[![PyTest](https://github.com/crunchdao/crunch-encrypt/actions/workflows/pytest.yml/badge.svg)](https://github.com/crunchdao/crunch-encrypt/actions/workflows/pytest.yml)

This Python library is designed for the [CrunchDAO Platform](https://hub.crunchdao.com/), exposing the encryption tools in a very small CLI.

- [Crunch Encrypt Tool](#crunch-encrypt-tool)
- [Installation](#installation)
- [Usage for ECIES](#usage-for-ecies)
  - [Generate a Key Pair](#generate-a-key-pair)
  - [Encrypt a file](#encrypt-a-file)
  - [Decrypt a file](#decrypt-a-file)
- [Contributing](#contributing)
- [License](#license)

# Installation

Use [pip](https://pypi.org/project/crunch-encrypt/) to install the `crunch-encrypt`.

```bash
pip install --upgrade crunch-encrypt
```

# Usage for ECIES

This encryption requires two keys: 
- a private key for decryption
- and a public key for encryption.

An ephemeral key is also derived from the public key for each file. In order for the file to be decrypted, this ephemeral key must be provided.

## Generate a Key Pair

```bash
crunch-encrypt ecies key-pair
```

## Encrypt a file

```bash
crunch-encrypt ecies encrypt hello.txt hello.txt.enc
```

> [!TIP]
> To generate a dummy file, do the following:
> ```bash
> echo 'Hello World!' > hello.txt
> ```

## Decrypt a file

```bash
crunch-encrypt ecies decrypt hello.txt.enc hello.txt.dec
```

> [!TIP]
> Use the `diff` tool to validate the decryption:
> ```bash
> diff hello.txt hello.txt.dec
> ```

# Contributing

Pull requests are always welcome! If you find any issues or have suggestions for improvements, please feel free to submit a pull request or open an issue in the GitHub repository.

# License

[MIT](https://choosealicense.com/licenses/mit/)
task-tracker-cli-bryandev 0.1.4.2
Simple project for the creation and management of tasks by CLI
Requires Python: >=3.9

# Task Tracker CLI app

This is a light app for the administration of tasks from the Command-Line Interface (CLI).

## Features

* Add a new task with your description.
* Update the description of an existing task.
* Change the status of a task such as: "todo", "in-progress" or "done".
* Eliminate a task for your ID.
* List all tasks or list for your status.

## Installation

```bash
pip install task-tracker-cli-bryandev
```


## Usage

**Add a task**
```bash
# Adding a new task
taskcli add "Buy groceries"
# ouput: Task added successfully (ID: 1)
```

**Update a task**
```bash
# Updating a task
taskcli update 1 "Buy groceries an cook dinner"
```

**Mark task status**
```bash
# Marking a task as in progress or done
taskcli mark-in-progress 1
taskcli mark-done 1
```
**Delete a task**
```bash
# deleting a task
taskcli delete 1
# ouput: Task 1 delete
```

**List tasks**
```bash
# list all tasks
taskcli list

# list tasks by status:
# todo
taskcli list todo

# in progress
taskcli list in-progress

# done
taskcli list done
```

**Help**
```bash
taskcli -h
taskcli --help
```
icij-worker 0.18.2
Create asynchronous tasks from Python functions
Requires Python: ~=3.10

# ICIJ's async worker library [![Test for icij-worker](https://github.com/ICIJ/icij-python/actions/workflows/tests-worker.yml/badge.svg)](https://github.com/ICIJ/icij-python/actions/workflows/tests-worker.yml)

## Installation

With AMQP:
```bash
pip install icij-worker["amqp"]
```

With neo4j:
```bash
pip install icij-worker["neo4j"]
```

## Usage

### Create an async app and register tasks

Create asynchronous task tailored for long running Python functions:

Given the following pure Python function inside the `app.py` module:

```python
def long_running_task(greeted: str) -> str:
    greeting = f"Hello {greeted} !"
    return greeting
```

decorate your function with `ICIJApp` class and register a new task:

```python
from icij_worker import AsyncApp

my_app = AsyncApp(name="my_app")

@my_app.task
def long_running_task(greeted: str) -> str:
    greeting = f"Hello {greeted} !"
    return greeting
```

this will register the `long_running_task` function under the `long_running_task` task name.

Optionally add progress handlers for a better task monitoring:

```python
@my_app.task
async def long_running_task(
    greeted: str,
    progress: Optional[Callable[[float], Awaitable]] = None
) -> str:
    if progress is not None:
        await progress(0.0)
    greeting = f"Hello {greeted} !"
    if progress is not None:
        await progress(100.0)
    return greeting
```

### Launch a async worker pool

Start a worker pool using:

```bash
icij-worker workers start "app.my_app"
```

provide worker pool options using:

```bash
icij-worker workers start -c worker_config.json -n 2 --backend multiprocessing "app.my_app"
```

**depending on the worker configuration additional setup might be required**.

## Async worker implementations

- [Neo4j](https://neo4j.com/docs/api/python-driver/current/)
- [AMQP](https://www.amqp.org/) (`v0.9.1` based on [RabbitMQ](https://www.rabbitmq.com/))

## Worker asynchronous backends

### Implemented

- [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) for CPU bound tasks

### To be implemented

- [asyncio](https://docs.python.org/3/library/asyncio.html) for I/O bound tasks