semvec/pypi-packages huggingface dataset:
wrought 0.0.1
Wrought by FluxForge AI — Engineering and operations control system. Full package coming soon.
Requires Python: >=3.10
Keywords: ai, control-system, engineering, incident-management, mcp

# Wrought

**Engineering and operations control system by [FluxForge AI](https://github.com/fluxforgeai).**

Wrought is a full-lifecycle control system for AI-assisted engineering and production operations — standardizing feature delivery, incident response, RCA, and governance into repeatable workflows with durable artifacts.

*If it ain't Wrought, it's fraught.*

Full package coming soon.
polaris-studio 26.2.21.dev1
Transportation System Simulation Tool
Requires Python: >=3.10

# polaris-studio

The polaris-studio package is th Python gateway for all things Polaris. The package is
divided in several submodules varying from data preparation to result analysis and is
the source of truth for the data model required by Polaris.

For the package's full description and documentation, see: https://polaris.taps.anl.gov/polaris/index.html

For release notes, see: https://polaris.taps.anl.gov/polaris/releases/index.html

The standard installation of Polaris-Studio brings a minimum set of dependencies, which are those required
for running a simulation. For a full installation, please install

    pip install polaris-studio[builder]

We recommend using virtual environments to prevent dependency clashes. In the root folder of the repo you will find 
a script called `setup_venv.sh` (linux) or `setup_venv.bat` (windows) which will create a virtual environment 
into a sub-directory `venv` of the repo and install that as a kernel (named "polaris-studio") which can be used 
with any jupyter notebooks you are running.

```bash
./setup_venv.sh
```

## Documentation

Polaris-studio is also responsible for building the documentation website (https://polaris.taps.anl.gov). The
steps for building are outlined in the `ci/documentation_ci.yml` gitlab CI definition file and require the 
cloning of the `polaris-linux` and `QPolaris` repositories. This can be achieved in a local environment by running 

```bash
./docs/build_all_locally.sh
```

There are a number of example notebooks in the documentation that require additional datafiles to run, these can be
downloaded and run locally using the following command

```bash
./docs/build_consolidated_docs.sh grab
./docs/build_consolidated_docs.sh run_notebooks [optional_pattern]
```

The optional pattern can be used to only run one notebook if you are adding a new one or debugging one that has 
developed a problem.
pydotaconstants 1.0.0b1
Add your description here
Requires Python: >=3.14

# PyDotaConstants

PyDotaConstants is a Python library designed to provide structured access to Dota 2 hero and ability data. It allows developers to easily retrieve hero and ability information based on their code names and display names. This project is particularly useful for creating applications and tools that require detailed insights into Dota 2's capabilities and characters.

## Features
- Retrieve hero information by codename, ID, or display name.
- Access ability information similarly through codename or display name.
- Data is loaded from pre-compiled binary files, ensuring fast access and processing.
- Supports a structured schema for hero and ability data that can be easily navigated.

## Installation and Setup
To install the PyDotaConstants library, simply clone the repository and ensure the necessary data files are in place. The current data files must be compiled as `.pkl` files as represented in the `src/pydotaconstants/data` directory. 

```bash
git clone https://github.com/yourusername/pydotaconstants.git
cd pydotaconstants
```

Make sure to run the `_update.py` script to generate the necessary data files if they are not already provided.

```bash
python src/_update.py
```

## Basic Usage
To use the library, you can import the desired classes and access hero or ability data as shown below:

```python
from pydotaconstants import Hero, Ability

# Get hero by codename
hero = Hero.getByName("npc_dota_hero_axe")
print(hero.displayName)  # Output: Axe

# Get ability by display name
ability = Ability.getByDisplayName("Hex")
print(ability.displayDescription)
```

## Configuration
This library expects certain pre-compiled data files:
- `heroes.pkl`: Contains data for all Dota 2 heroes.
- `abilities.pkl`: Contains data for all Dota 2 abilities.
- `locals.pkl`: Contains localization strings for heroes and abilities.

Make sure these files are located in the `src/pydotaconstants/data` directory for the library to function correctly.

## Contributing Guidelines
Contributions to PyDotaConstants are welcome. To contribute:
1. Fork the repository.
2. Create a new branch (`git checkout -b feature-branch`).
3. Make your changes and commit them (`git commit -m 'Add some feature'`).
4. Push to the branch (`git push origin feature-branch`).
5. Open a Pull Request detailing your changes.

Please ensure any new features include tests and documentation updates as necessary.

## License
This project is licensed under the MIT License. See the `LICENSE` file for more details.