semvec/pypi-packages huggingface dataset:
pybalmorel 0.5.8
A package for convenient python functions when processing Balmorel data or results
Requires Python: >=3.10

# pybalmorel
Convenient python framework for pre-, post-processing or executing the GAMS framework Balmorel. Install into your virtual python environment with:

`pip install pybalmorel`

For more information on how to manage and install virtual environments check out [this resource](https://docs.python.org/3/library/venv.html), or if you are a conda user, [this resource](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html).

## Get Started

Check out the [documentation](https://balmorelcommunity.github.io/pybalmorel) for examples on how to use pybalmorel. The following notebooks can also be downloaded:
- [Pre-Processing](https://github.com/Mathias157/pybalmorel/blob/master/examples/PreProcessing.ipynb)
- [Execution](https://github.com/Mathias157/pybalmorel/blob/master/examples/Execution.ipynb)
- [Post-Processing](https://github.com/Mathias157/pybalmorel/blob/master/examples/PostProcessing.ipynb)

## Developer Notes

This package is distributed to [PyPI](https://pypi.org), and the distribution of a new version requires the following steps:
1. Update the pybalmorel version in pyproject.toml, environment.yaml, docs/conf.py and docs/get_started/installation.md (a find and replace in VS code will do)
2. Make sure that you have the most recent `build` and `setuptools` packages in your virtual environment and build the new distribution with `python -m build`
3. Make a user at PyPI.org and obtain a PyPI token.
4. Make sure that you have the most recent `twine` and `packaging` packages in your virtual envrionment and upload the newly created package in the dist folder with `python -m twine upload dist/pybalmorel-X.Y.Z.tar.gz`
liskCell 5.5.4
The official Python SDK for the LiskCell ecosystem and Deta LPT models.
Requires Python: >=3.8

# 🌟 liskCell Python SDK

Official Python library for the **LiskCell** ecosystem and **Deta LPT** models. Created by **liskasYR**.

## 🚀 Installation

```bash
pip install liskCell
```

## 💎 Quick Start

### Python Usage

```python
from liskcell import LiskCellSDK

# Initialize SDK
sdk = LiskCellSDK()

# Chat with Deta
response = sdk.chat("Tell me about liskasYR")
print(response['response'])

# Generate Branding
branding = sdk.create_branding("MyAwesomeProject")
print(branding)
```

### CLI Usage

```bash
# Get Deta's Identity
liskcell whoami

# Chat directly from terminal
liskcell chat -m "Hello Deta!"

# Generate project branding
liskcell branding -p "NewSite"
```

## 🛠 Features

- **LPT Model Access**: Seamless interaction with Deta AI.
- **Identity Control**: Built-in protocols for LiskCell personas.
- **Creative Suite**: Automated branding and design guidance.
- **Ecosystem Sync**: Integrated with xLYR and LiskCell projects.

## 🛡 License

MIT License - Copyright (c) 2026 LiskCell.
querymc 1.0.0
An implementation of the minecraft java (1.7+) query protocol
Requires Python: >=3.14

#### Java Edition (1.7+)
#### Only tested for Python 3.14
This is a python module for the minecraft java query protocol which implements methods for the basic stat and full stat requests as described on https://minecraft.wiki/w/Query and returns the structured reply in a dictionary.
For access to e.g. a server icon you will need to use the Server List Ping, which is NOT part of this module. (https://minecraft.wiki/w/Java_Edition_protocol/Server_List_Ping)

You may be interested in https://github.com/py-mine/mcstatus if you want complete functionality across versions.
elgato-decrypter 1.0.0
A tool to decrypt Elgato Stream Deck manifest files and plugin packages.
Requires Python: >=3.8

# Elgato Stream Deck Manifest Decrypter

A command-line tool to decrypt encrypted manifest files (`manifest.json`) used by the Elgato Stream Deck application. It supports decrypting standalone manifest files as well as in-place decryption of `.streamDeckPlugin` packages.

**Note:** This tool requires the `StreamDeck.exe` binary to be installed on your system, as it dynamically extracts the necessary decryption keys from the application binary at runtime. It does **not** contain any embedded secrets or proprietary keys.

## Features

- **Manifest Decryption**: Decrypts individual encrypted `manifest.json` files.
- **Plugin Decryption**: Handles `.streamDeckPlugin` (ZIP) files, decrypting the internal manifest in-place.
- **Dynamic Key Extraction**: Parses the installed `StreamDeck.exe` to retrieve cryptographic constants, ensuring compatibility across versions.
- **Safe**: No hardcoded keys or secrets are distributed with this tool.

## Installation

```bash
pip install elgato-decrypter
```

## Usage

### Decrypt a single manifest file

```bash
elgato-decrypter path/to/encrypted/manifest.json [output_file.json]
```

### Decrypt a plugin package (in-place)

```bash
elgato-decrypter path/to/plugin.streamDeckPlugin
```

### Specify custom Stream Deck binary path

By default, the tool looks for `StreamDeck.exe` in `C:\Program Files\Elgato\StreamDeck\StreamDeck.exe`. If you have it installed elsewhere:

```bash
elgato-decrypter path/to/manifest.json --binary "D:\Games\Elgato\StreamDeck.exe"
```

## Technical Details

The encryption scheme uses a combination of:
- Custom PCG-based XOR stream cipher
- X25519 Elliptic Curve Diffie-Hellman (ECDH) key exchange
- HKDF-SHA256 key derivation
- AES-256-GCM authenticated encryption

For full technical details, see the project documentation.

## License

MIT License
tagmapper 0.9.0
Python wrapper for Equinor SPD tag mapping database
Requires Python: <4.0,>=3.10.0

# tagmapper-sdk [![SNYK dependency check](https://github.com/equinor/tagmapper-sdk/actions/workflows/snyk.yml/badge.svg)](https://github.com/equinor/tagmapper-sdk/actions/workflows/snyk.yml)
Python package to get timeseries and constant value mappings for data models from SDP tag mapping library.

It supports SDP defined models for Separators and Wells as well as generic models with or without schema.

Authentication is done using Azure credentials and bearer tokens.


## Use
1. See [demo](examples/demo_well.py). Or try the following simple code.  
    ```python
    from tagmapper import Well
    w = Well("NO 30/6-E-2")  
    ```

2. Fetching the base view (well_attributes_mapped_to_timeseries_base) from the API: <br>
    Refer to examples/demo_api_func.py:<br>
    Fetch data for all facilities:<br>
    ```python
    from tagmapper.base_model import get_data_base_well
    df = get_data_base_well(limit=100000, offset=0) 
    print(df)
    ```
    Fetch data for selected facilities:
    ```python
    from tagmapper.base_model import get_data_base_well
    facility_names = ['STATFJORD B','JOHAN SVERDRUP RP']
    df = get_data_base_well(facility_names, limit=10000, offset=0) # More facilit
    print(df)
    ```

3. Getting a generic model with no schema from API:  
   See [demo](examples/demo_generic_model.py). Example usage:
     ```python
     from tagmapper import Model

     # Create a model
     model = Model.get_model(
     model_owner="example_owner",
     model_name="example_model",
     object_name="example_object")
     model.print_report()
     ```

## Installing
Install from pypi using pip.  
``
pip install tagmapper
``


## Developing
Clone repo and run ``poetry install`` to install dependencies.


## Testing and code coverage
Run tests and check coverage using pytest-cov
``poetry run pytest --cov=. --cov-report=xml:coverage.xml``



Compare coverage with modified lines against main branch
``diff-cover coverage.xml --compare-branch=origin/main``