semvec/pypi-packages huggingface dataset:
plutonkit 1.0.31a2
Startkit for template project, for your desired structure of framework
License: MIT
Requires Python: >=3.9

# pluton-kit
Create your project from the current selection we had on the lobby, But in the future we are working to share your ideas with other developer.

[![PIP version][pip-image]][pip-url] 
[![Build Status](https://github.com/fonipts/pluton-kit/actions/workflows/cicd.yaml/badge.svg?branch=main)](https://github.com/fonipts/pluton-kit/actions)
[![Downloads](https://static.pepy.tech/badge/plutonkit)](https://pepy.tech/project/plutonkit)

[Site](https://plutonkit.codehyouka.xyz/) |
[Docs](https://plutonkit.codehyouka.xyz/api) |
[Architecture lobby](https://github.com/fonipts/pluton-lobby) |
[Readthedocs sources](https://pluton-kit.readthedocs.io/en/latest/) |

## Introduction
Building from scratch is quite a daunting task. Constructing your thought, looking for feature and research it will take alot of your time in figuring what will you do next. Therefore I decided to create application where you can choose in different framework, either zero or hero it will help you alot to visualize what framework will you choose.

## Installation
In your local machine
```
pip install -e .
```
In using Pip install
```
pip install plutonkit
```

## Why we need another project template
There are several template generator that is available public repository, but they lack of user control in favored of there likes.
- to have condition, for feature that you want and available in architecture.
- Custom template that makes this project unique.


## Roadmap
Currently we are in alpha phase had not reach 100% test coverage and some linter(due to feature I am currently in focused) but still committed to deliver the improvement if the tool.

## Available command you can use at your terminal
The commands must in this format  `plutonkit <Command type>` 
|Command type | Description| Example |
|------------- | ------------- | ------------- |
|clone_project | Clone your project from project.yaml file  | `plutonkit clone_project source=<directory name>`|
|create_achitecture | Start creating your own architecture from scratch  | `plutonkit create_achitecture`|
|create_project | Start creating your project in our listed framework  | `plutonkit create_project`|
|validate_blueprint | Validated your blueprint before shipping to production  | `plutonkit validate_blueprint <directory name>`|
|cmd | Executing command using plutonkit. the details of your command can be found at `command.yaml` | `plutonkit cmd start` or `plkcmd start`|
|help | See available command for plutonkit | `plutonkit help` |

![Alt text](https://raw.githubusercontent.com/fonipts/pluton-kit/refs/heads/main/resources/pluton-kit-terminal-design.gif "terminal")


## How to use the command
Structure of your command, should follow this format

in `command.yaml` 
```
env: {} 
script: 
  {command_name}:
    command:
    - {executed command}
   

```
For quick command execution, we had a new abbrevation that called
`plkcmd` instead of `plutonkit cmd`. 

[pip-url]: https://pypi.org/project/plutonkit/
[pip-image]: https://img.shields.io/badge/plutonkit-1.0.31a2-brightgreen
moirai-engine 0.0.26
The job processing engine that powers ananke
License: MIT
Requires Python: >=3.11

# moirai-engine

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

-----

## Table of Contents
<!-- TOC -->

- [moirai-engine](#moirai-engine)
  - [Table of Contents](#table-of-contents)
  - [Installation](#installation)
  - [Usage](#usage)
    - [Basic Example](#basic-example)
    - [Advanced Example](#advanced-example)
  - [About](#about)
  - [License](#license)

<!-- /TOC -->


> **NOTE:** This doc is still in progress. for now it was generated by AI (sorry).

## Installation

```console
pip install moirai-engine
```

## Usage

### Basic Example

Here is a basic example of how to use the `moirai-engine` library to create and run a simple job:

```python
import time
from moirai_engine.core.engine import Engine
from moirai_engine.utils.samples import hello_world

# Create and start the engine
engine = Engine()
engine.start()

# Create a job using the hello_world sample
job = hello_world()

# Add the job to the engine
engine.add_job(job)

# Let the engine run for a while
time.sleep(5)

# Stop the engine
engine.stop()
```

### Advanced Example

Here is an advanced example that includes real-time notifications and job cancellation:

```python
import asyncio
from moirai_engine.core.engine import Engine
from moirai_engine.utils.samples import hello_world


# Create an async function
async def notification_listener(notification):
    print(f"Received notification: {notification}")


async def main():
    engine = Engine(max_workers=4, listener=notification_listener)
    await engine.start()

    # Add jobs to the engine
    await engine.add_job(hello_world(), notification_listener)

    # Let the engine run for a while
    await asyncio.sleep(2)

    await engine.stop()


if __name__ == "__main__":
    asyncio.run(main())

```

## About

`moirai-engine` is the engine that powers [Ananke](https://github.com/fcrozetta/ananke), but it was planned to be used as a processing engine. This project is still in progress, and features like task registry and autodiscover are still in development.

## License

MIT License
fast-vertex-quality-inference 1.0.15
Inference code for fast generation of vertex quality variables
License: MIT
Requires Python: <4.0,>=3.9
Keywords: inference, vertex-quality, fast-generation

# Fast Vertexing Variables at LHCb - Inference Library

Full documentation is avalibale [**here**](https://fastvertexing.docs.cern.ch/index.html
).

## Description

This tool provides a quick approximation of the LHCb reconstruction process. Built on top of [**RapidSim**](https://github.com/gcowan/RapidSim), the `run` function automatically communicates with RapidSim to generate kinematic information which is then smeared before predictions of high-level vertexing variables are generated.

The software utilizes **Variational Autoencoders** (VAEs) to estimate these variables. These VAEs are trained on output from the LHCb simulation software.

Generated tuples can be integrated with other tools such as [**TriggerCalib**](https://pypi.org/project/triggercalib/) and [**PIDCalib2**](https://pypi.org/project/pidcalib2/), completing the full chain of estimation of reconstruction efficiencies and mass shapes for background studies at LHCb.

### Disclaimer

This tool is not designed to replace the full simulation software. It is designed to quickly return reasonable estimates of mass shapes and efficiencies.  

## Environment Setup

RaidSim is required to use the full functionalty of this library. The environment variables $RAPIDSIM_ROOT and $EVTGEN_ROOT that are used by the code to access the install. 

- `RAPIDSIM_ROOT`: The root directory for RapidSim.
- `EVTGEN_ROOT` (optional): The root directory for EVTGEN, if applicable.

## Example Usage

### `run()`

The `run()` function is the primary method to execute FastVertexing. It handles several key operations in the vertexing and event simulation process:

```python
from fast_vertex_quality_inference import run

run(
    events=1000,
    decay="B+ -> { D0b -> K+ e- anti-nue } pi+",
    naming_scheme="B_plus -> { NA -> K_plus e_minus NA } e_plus",
    decay_models="PHSP -> { ISGW2 -> PHSP PHSP PHSP } PHSP",
    mass_hypotheses={"e_plus": "e+"},
    intermediate_particle={"Jpsi": ["e_minus", "e_plus"]},
)
```

### `run_from_tuple()`

The `run_from_tuple()` function only executes the vertexing network on an existing tuple and can be used without a RapidSim installation.

```python

from fast_vertex_quality_inference import run_from_tuple

run_from_tuple(
    file="decay_tree.root",
    mother_particle="MOTHER",
    daughter_particles=["DAUGHTER1", "DAUGHTER2", "DAUGHTER3"],
    fully_reco=False,
    nPositive_missing_particles=0,
    nNegative_missing_particles=0,
    mass_hypotheses={"DAUGHTER2": "e+"},
    intermediate_particle={"INTERMEDIATE": ["DAUGHTER2", "DAUGHTER3"]},
    branch_naming_structure={"true_momenta_component": "{particle}_TRUE_P{dim}"},
)
```