semvec/pypi-packages huggingface dataset:
harmonized-telemetry-format 0.0.3a1
Core library for reading and writing the Harmonized Telemetry Format (HTF).
Requires Python: >=3.8

# Harmonized Telemetry Format (HTF)

Detailed description coming soon.

Exemplary HTF file content:
```htf
[static_metadata;s]12.51
[dim_metadata;index;delta]2;0.08;4;0.484
(channel;s;50;135)0=12.27;1=12.42;...
(empty_channel;m;50;135)0=;
```
anthropic-haystack 5.3.0
An integration of Anthropic Claude models into the Haystack framework.
Requires Python: >=3.10

# anthropic-haystack

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

- [Integration page](https://haystack.deepset.ai/integrations/anthropic)
- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/anthropic/CHANGELOG.md)
---

## Contributing

Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).

To run integration tests locally, you need to export the `ANTHROPIC_API_KEY` environment variable.
algomancy-gui 0.4.3
Dash components for the Algomancy library
Requires Python: >=3.14

### algomancy-gui

UI components and configuration utilities for Algomancy dashboards built on Plotly Dash and Dash Bootstrap Components.

#### Features
- `StylingConfigurator` to control layout, theme colors, button styles, and card highlighting
- Page modules (home, data, scenario, compare, overview, admin) with helpers for building common UI
- Utilities such as `SettingsManager` and data‑page filename matching tools

#### Installation
```
pip install -e packages/algomancy-gui
```

Requires Python >= 3.14. Dependencies: `dash`, `dash_bootstrap_components`.

#### Quick start: configure styling
```python
from algomancy_gui.stylingconfigurator import (
    StylingConfigurator,
    LayoutSelection,
    ColorConfiguration,
    CardHighlightMode,
    ButtonColorMode,
)

styling = StylingConfigurator(
    layout_selection=LayoutSelection.SIDEBAR,
    color_configuration=ColorConfiguration(
        background_color="#FFFFFF",
        theme_color_primary="#1F271B",
        theme_color_secondary="#6DA34D",
        theme_color_tertiary="#FEFAE0",
        text_color="#424242",
        text_color_highlight="#6DA34D",
        text_color_selected="#FFFFFF",
        button_color_mode=ButtonColorMode.UNIFIED,
        button_colors={
            "unified_color": "#6DA34D",
            "unified_hover": "#8FBE74",
        },
    ),
    logo_path="CQM-logo-white.png",
    button_path="cqm-button-white.png",
    card_highlight_mode=CardHighlightMode.SUBTLE_DARK,
)
```

Use this `styling` in your `AppConfiguration` (see `example/main.py`).

#### Related docs and examples
- Example application wiring: `example/main.py`
- Root documentation: UI is referenced throughout `documentation/3_dash_contents.md`
algomancy-data 0.4.3
Data management model for the Algomancy library
Requires Python: >=3.14

### algomancy-data

Data layer for Algomancy dashboards: schemas, extract/transform/load (ETL) primitives, validators, and data containers used by the GUI and scenario packages.

#### Features
- `DataSource` and `BaseDataSource` containers with table management and JSON (de)serialization
- Pluggable ETL pipeline building blocks: `Extractor`, `Transformer`, `Validator`, `Loader`
- `DataManager` orchestrators (stateful/stateless) to drive ETL and manage datasets
- Declarative `InputFileConfiguration` for file inputs (CSV, XLSX, JSON)

#### Installation
```
pip install -e packages/algomancy-data
```

Requires Python >= 3.14. Core dependency: `pandas`.

#### Quick start: use `DataSource` directly
```python
import pandas as pd
from algomancy_data import DataSource, DataClassification

ds = DataSource(ds_type=DataClassification.MASTER_DATA, name="warehouse")
ds.add_table("inventory", pd.DataFrame({"sku": ["A", "B"], "qty": [10, 5]}))

# JSON roundtrip
json_str = ds.to_json()
ds2 = DataSource.from_json(json_str)
assert ds2.get_table("inventory").equals(ds.get_table("inventory"))
```

#### Quick start: orchestrate ETL with a `DataManager`
`DataManager` wires `Extractor` → `Transformer` → `Validator` → `Loader`. You provide an `ETLFactory` that builds these parts for each input configuration.

```python
from typing import List
from algomancy_data import (
    DataSource, DataClassification,
    DataManager, StatelessDataManager, ETLFactory,
    SingleInputFileConfiguration, FileExtension
)

class MyETLFactory(ETLFactory):
    # Implement factory methods to build Extractor/Transformer/Validator/Loader
    ...

input_cfgs: List[SingleInputFileConfiguration] = [
    SingleInputFileConfiguration(
        tag="inventory", file_name="inventory", extension=FileExtension.CSV
    )
]

dm: DataManager = StatelessDataManager(
    etl_factory=MyETLFactory,
    input_configs=input_cfgs,
    save_type="json",  # or other configured type
    data_object_type=DataSource,
)

files = dm.prepare_files(file_items_with_path=[("inventory", "./data/inventory.csv")])
ds: DataSource = dm.etl_data(files=files, dataset_name="warehouse")
```

#### Documentation and examples
- Root docs: `documentation/1_data.md`
- End‑to‑end usage in the example app: `example/` (see `example/data_handling` and `example/main.py`)
algomancy-content 0.4.3
Placeholder content for quick start to the Algomancy library
Requires Python: >=3.14

### algomancy-content

Reusable content blocks (pages and callbacks) for Algomancy dashboards built with Dash. This package provides ready‑made creators for home, data, and overview pages, plus placeholder content to get you started quickly.

#### Features
- Standard page content creators (home, data, overview)
- Placeholder content for instant scaffolding
- Pairs naturally with `algomancy-gui` styling and the core launcher under `src/algomancy`

#### Installation
```
pip install -e packages/algomancy-content
```

Requires Python >= 3.14.

#### Quick start

```python
from algomancy_content import ShowcaseHomePage

# Plug into your AppConfiguration (see project root `example/main.py`)
home_content = ShowcaseHomePage.create_default_elements_showcase
home_callbacks = ShowcaseHomePage.register_callbacks
```

Use the prebuilt standard home page:

```python
from algomancy_content.pages.standardhomepage import StandardHomePage

home_content = StandardHomePage.create_content
home_callbacks = StandardHomePage.register_callbacks
```

#### Related docs and examples
- Example application: `example/main.py`
- Root documentation: `documentation/3_dash_contents.md`
algomancy-scenario 0.4.3
Scenario management model for the Algomancy library
Requires Python: >=3.14

### algomancy-scenario

Scenario modeling utilities for Algomancy: define algorithms and parameters, run scenarios against data, and compute KPIs.

#### Features
- `Scenario` lifecycle with statuses (`CREATED`, `QUEUED`, `PROCESSING`, `COMPLETE`, `FAILED`)
- `BaseAlgorithm` and parameter classes to define pluggable algorithms
- KPI framework (`BaseKPI`) to compute metrics from algorithm results
- Works with `algomancy-data` data sources and can be orchestrated from the GUI

#### Installation
```
pip install -e packages/algomancy-scenario
```

Requires Python >= 3.14.

#### Quick start
Define a simple algorithm and KPI, then run a `Scenario`:

```python
from algomancy_scenario import (
    Scenario, ScenarioStatus,
    BaseAlgorithm, BaseParameterSet, BaseKPI,
)
from algomancy_data import DataSource, DataClassification


# Minimal parameters type
class ExampleParams(BaseParameterSet):
    def serialize(self) -> dict:
        return {"hello": "world"}


# Minimal algorithm
class ExampleAlgorithm(BaseAlgorithm):
    def __init__(self):
        super().__init__(name="Example", params=ExampleParams())

    @staticmethod
    def initialize_parameters() -> ExampleParams:  # used by GUI tooling
        return ExampleParams()

    def run(self, data: DataSource) -> dict:
        # do something with data and return a result dictionary
        self.set_progress(100)
        return {"count_tables": len(data.list_tables())}


# Minimal KPI
class CountTablesKPI(BaseKPI):
    def __init__(self):
        super().__init__(name="Tables", improvement_direction=None)

    def compute_and_check(self, result: dict):
        self.value = result["count_tables"]


# Prepare data
ds = DataSource(ds_type=DataClassification.MASTER_DATA, name="warehouse")

# Build and run scenario
scenario = Scenario(
    tag="demo",
    input_data=ds,
    kpis={"tables": CountTablesKPI()},
    algorithm=ExampleAlgorithm(),
)

scenario.process()
assert scenario.status == ScenarioStatus.COMPLETE
print("Tables KPI:", scenario.kpis["tables"].value)
```

#### Related docs and examples
- Example app demonstrates scenario wiring: `example/pages/ScenarioPageContent.py`
- Algorithm/KPI examples: `example/templates/algorithm/` and `example/templates/kpi/`
algomancy-cli 0.4.3
CLI shell for Algomancy to exercise backend functionality without the GUI.
Requires Python: >=3.14

Algomancy CLI

Interactive terminal shell to exercise Algomancy backend functionality without the GUI. Useful for rapid development of ETL, algorithms, and scenarios.

Install / Run

```
uv run algomancy-cli --example
```

Or point to your own configuration factory:

```
uv run algomancy-cli --config-callback myproject.config:make_config
```

Where `make_config` returns an `AppConfiguration` instance.

Commands

- `help` — show help
- `list-data` / `ld` — list datasets
- `load-data <name>` — load example data into dataset `<name>`
- `etl-data <name>` — run ETL to create dataset `<name>`
- `list-scenarios` / `ls` — list scenarios
- `create-scenario <tag> <dataset_key> <algo_name> [json_params]` — create scenario
- `run <scenario_id_or_tag>` — run scenario and wait for completion
- `status` — show processing status
- `quit` / `exit` — exit shell

Parameters for `create-scenario` can be provided as a JSON object, e.g.:

```
create-scenario test1 "Master data" Fast "{\"duration\": 0.5}"
```

How it works

The CLI wraps `ScenarioManager` created via `AppConfiguration` just like the GUI launcher. See `src/algomancy/cli_launcher.py` for details.
Algomancy 0.4.3
A dashboarding framework for visualizing performances of algorithms or simulations in various scenarios.
Requires Python: >=3.14
Keywords: visualization, algorithm, simulation, scenario

# Algomancy

Algomancy is a lightweight framework for building interactive dashboards that visualize the performance of algorithms and/or simulations across scenarios. It brings together ETL, scenario orchestration, KPI computation, and a Dash-based UI with modular pages.

## Highlights
- Python 3.14+
- Dash UI with modular pages and a production-ready server
- Batteries-included packages: content, data, scenario, GUI, CLI

## Installation
- Using uv (recommended):
  ```
  uv add algomancy
  ```
- Using pip:
  ```
  pip install algomancy
  ```

## Minimal example
The following example launches a small placeholder dashboard using the default building blocks from the Algomancy ecosystem. Copy this into a file called `main.py` and run it.

## Set up folder structure
1. Create the following directory structure:
```text
root/
|── assets/ (*)
├── data/   (*)
├── src/
│   ├── data_handling/
│   ├── pages/
│   └── templates/
│       ├── kpi/
│       └── algorithm/
├── main.py  (*)
├── README.md
└── pyproject.toml
```
> Only the items marked (*) are required.

2. create `main.py`

```python
from algomancy_gui.gui_launcher import GuiLauncher
from algomancy_gui.appconfiguration import AppConfiguration
from algomancy_content import (
    PlaceholderETLFactory,
    PlaceholderAlgorithm,
    PlaceholderKPI,
    PlaceholderSchema,
)
from algomancy_data import DataSource


def main() -> None:
    host = "127.0.0.1"
    port = 8050

    app_cfg = AppConfiguration(
        etl_factory     = PlaceholderETLFactory,
        kpi_templates   = {"placeholder": PlaceholderKPI},
        algo_templates  = {"placeholder": PlaceholderAlgorithm},
        schemas         = [PlaceholderSchema()],
        host            = host,
        port            = port,
        title           = "My Algomancy Dashboard",
    )

    app = GuiLauncher.build(app_cfg)
    GuiLauncher.run(app=app, host=app_cfg.host, port=app_cfg.port)


if __name__ == "__main__":
    main()
```

## Run
- Save the file as `main.py` and start the app:
  ```
  uv run main.py
  ```
- Open your browser at http://127.0.0.1:8050

Examples
- A more complete example (including assets and templates) is available in the algomancy repository under `example/`. The entry point is `example/main.py`.

Requirements
- Python 3.14+
- Windows, macOS, or Linux

CLI
- This package also exposes a CLI entry point `algomancy-cli`. Run `algomancy-cli --help` for usage.

License
- See the `LICENSE` file included with this distribution.

Changelog
- See `changelog.md` for notable changes.
licenselynx 2.1.0
Deterministically map license strings to its canonical identifier
Requires Python: >=3.11

# LicenseLynx for Python

To use LicenseLynx in Python, you can call the ``map`` method from the ``LicenseLynx`` module to map a license name to its canonical form.
The return value is an object with the canonical name and the source of the license.

## Installation

To install the library, run following command:

```shell
pip install licenselynx 
```

## Usage

```python
from licenselynx.licenselynx import LicenseLynx

# Map the license name
license_object = LicenseLynx.map("licenseName")

print(license_object.id)
print(license_object.src)

# Map the license name with risky mappings enabled
license_object = LicenseLynx.map("licenseName", risky=True)

```

## License

This project is licensed under the [BSD 3-Clause "New" or "Revised" License](../LICENSE) (SPDX-License-Identifier: BSD-3-Clause).

Copyright (c) Siemens AG 2025 ALL RIGHTS RESERVED
omer-bio 0.1.0
Ce package contient un module d'Analyse Promethee et des fonctions necessaires pour cette analyse
Requires Python: >=3.9

# Python package: omerbio

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
<!--  [![MetaboHUB Logo](https://forge.inrae.fr/pfem/gitlab-tools/-/raw/init/projects-templates/logos/metabohub_logo-20x20.png)![MetaboHUB title](https://img.shields.io/badge/MetaboHub-Software-0066cc?style=flat-square)](https://www.metabohub.fr)  -->

## Metadata

- authors: <etienne.jules@inrae.fr> 
- creation date: `2025-08-19`
- main usage: This repo contains the code for the omerbio python package. A Promethee multi-criteria analysis weighted by PCA.

## Description

This package implements a multi-criteria analysis of data using Promethee method, with a weighing procedure based of principal components analysis (PCA).

## Features

The main functions are:
- `run_promethee_analysis`: Execute the multi-criteria analysis
- `generate_radar_plots`: Generates a pdf with radar plots of individuals on a set of criteria.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. 

### Prerequisites


Before you begin, ensure you have met the following requirements:

- **Operating System**: Windows 10+, macOS 10.14+, or Linux
- **Programming Language**: [Python] version 3.6 or higher
- **Package Manager**: [pip] version 24.1 or higher
- **Other dependencies**: Python packages: matplotlib, pandas, numpy, Promethee, sklearn

### Installing

Clone the repo and install the package localy (soon available via pip gitlab or pypi) :

```bash
git clone https://forge.inrae.fr/pfem/dev/libs/omerbio
cd src
pip install -e .
```


### Running the tests

In the root folder of this repository run:
```
python -m unittest
```
This runs the unit test of the package functions.

## Changelog

COMING SOON !

## Authors

- **Elfried Salanon** - *Initial idea and implentation* - MTH, INRAE, UNH, PFEM
- **Salomon Gouiri Loembe** - *First packaging work* - INRAE, UNH, PFEM
- **Marie Lefebvre** - *Project management* - MTH, INRAE, UNH, PFEM
- **Etienne Jules** - *Project management, final packaging, maintainer* - MTH, INRAE, UNH, PFEM

## License

**Omerbio** is distributed under the ~~MIT License~~.

Please refer to [LICENSE](LICENSE) file for further details.

## Support &amp; External resources

<!-- NOTE: this section is facultative; customize / remove useless / add relevant / ... items in the list below -->

- :book: **Documentation** - Coming soon !
- :bug: **Bug Reports** - [GitLab Issues](https://forge.inrae.fr/pfem/dev/libs/omerbio/-/issues)
- :email: **Email** - <etienne.jules@inrae.fr>

## Acknowledgments

<!-- NOTE: this section is required -->

- Thanks to Elfried Salanon, Salomon Gouiri Loembe, Marie Lefebvre and Etienne Jules for their valuable contributions
- Inspired by and built with [Promethee python package](https://pypi.org/project/Promethee/)
- Special thanks to the open-source community

---
aspen-pysys 0.0.13
Python interface for Aspen HYSYS
Requires Python: >=3.9

# aspen-pysys
Python interface for Aspen HYSYS

## Installation

Install via `pip install aspen-pysys` ([PyPI link](https://pypi.org/project/aspen-pysys/)).

## User guide

### Setup

1. Before you can use HYSYS, ensure that the simulation case you wish to work on is already open.
2. Once your simulation file is open, enter the following lines of code to set the package up.
3. An indicator that you have successfully connected with your simulation file is the printing of 'Aspen HYSYS' in the shell (or in a notebook cell if you are using a Jupyter cell or something similar).

```python
from aspen_pysys import *

Hysys.init()
```

To open a Aspen HYSYS simulation file (.hsc), use the `Hysys.open(sim_filepath)`, where `sim_filepath` is the filepath to your simulation file.

```python
from pathlib import Path
import os

current_filepath = Path(os.getcwd())
sim_filepath = current_filepath / "test_sim.hsc"

simcase = Hysys.open(sim_filepath)
simcase
```

4. You can now use the aspen-pysys package in your code! Please refer to the [tutorial folder](/tutorial/) for an interactive example.