semvec/pypi-packages huggingface dataset:
qualiluma 0.1.0
Using modern LLMs for code quality review
Requires Python: >=3.11

# qualiluma
[![Tests status](https://github.com/savfod/qualiluma/actions/workflows/tests.yml/badge.svg)](https://github.com/savfod/qualiluma/actions/workflows/tests.yml)

Analyze codebase for potential issues with model LLMs.

## Usage

Currently only OpenAI models are supported, set API key with `OPENAI_API_KEY` environment variable.

```bash
pip install qualiluma
OPENAI_API_KEY=your_openai_api_key qualiluma your_code_path
```
xcengine 0.1.1
Create OGC Earth Observation Application Packages from Jupyter notebooks
Requires Python: >=3.11
Keywords: analysis ready data, data science, datacube, xarray, zarr

[![tests](https://github.com/xcube-dev/xcengine/actions/workflows/tests.yaml/badge.svg)](https://github.com/xcube-dev/xcengine/actions/workflows/tests.yaml)
[![codecov](https://codecov.io/gh/xcube-dev/xcengine/graph/badge.svg?token=dTPaJB6nR3)](https://codecov.io/gh/xcube-dev/xcengine)
[![docs](https://github.com/xcube-dev/xcengine/actions/workflows/publish-docs.yaml/badge.svg)](https://github.com/xcube-dev/xcengine/actions/workflows/publish-docs.yaml)

# xcengine: turn Jupyter notebooks into Application Packages

xcengine provides tools to convert a Jupyter notebook into one of several
parameterized, headlessly runnable forms:

-   A Python script
-   A Docker container image
-   An OGC [Earth Observation Application
    Package](https://docs.ogc.org/bp/20-089r1.html)

# Documentation

Documentation is hosted at <https://xcube-dev.github.io/xcengine/>.

# Defining parameters in a notebook

xcengine uses the same convention as
[papermill](https://papermill.readthedocs.io/)
for defining parameters in a notebook. All parameters should be set as
Python variables in the same notebook code cell, and that cell should be
designated as the parameter cell by giving it the tag `parameters`. In
JupyterLab, you can do this using the property inspector (⚙⚙ icon in the
right sidebar). See the [papermill
documentation](https://papermill.readthedocs.io/en/latest/usage-parameterize.html#designate-parameters-for-a-cell)
for more details.

During conversion, `xcetool` will detect any variables that are set in the
parameters cell and make them available as command-line parameters for the
output script and container, and as workflow parameters for the application
package.

# Customizing output formats

An xcengine-generated script or image can automatically write all
`xarray.Dataset` objects from the notebook code to disk, for example to be
staged out as EO Application Package outputs. By default, Zarr format is
used, but this can be changed to NetCDF on a per-dataset basis by applying
an attribute:

```python
my_dataset.attrs["xcengine_output_format"] = "netcdf"
```

# xcetool usage

xcengine provides a command-line tool called `xcetool`, which has several
subcommands for different functions. Use the `--help` option with these
subcommands to get more details on usage.

## `xcetool make-script`

Convert a Jupyter notebook to a non-interactive Python script.

## `xcetool image build`

Convert a Jupyter notebook to a Docker container image. This subcommand can
additionally produce a Common Workflow Language (CWL) file defining an OGC
[Earth Observation Application Package](https://docs.ogc.org/bp/20-089r1.html) which uses the container image.

## `xcetool image run`

Run a Docker container using an image converted from a Jupyter notebook.

# Acknowledgements

xcengine was developed as part of the Open-Earth-Monitor Cyberinfrastructure
project, which has received funding from the European Union's Horizon Europe
research and innovation programme under grant agreement No. 101059548.
pylibcue 0.5.1
CUE sheet parser library for Python.
Requires Python: >=3.10
Keywords: cue, libcue, cuetools, audio, music, cd, metadata

pylibcue
========

pylibcue is a CUE sheet parser library for python. It provides fast and reliable
CUE sheets parsing interfaces for python by wrapping `libcue
<https://github.com/lipnitsk/libcue>`_ C library with Cython.

*Note:* since v0.2.1, pylibcue uses libcue fork with custom patches (`Cycloctane/libcue
<https://github.com/Cycloctane/libcue>`_) instead of original libcue to provide
additional bugfixes and features.

Install
-------

.. code-block:: bash

    pip install pylibcue

Compile from source
^^^^^^^^^^^^^^^^^^^

Requirements: bison, flex, make.

Clone the repo with ``--recurse-submodules`` argument.

.. code-block:: bash

    pip install --upgrade setuptools Cython build
    make test
    make

Usage
-----

Create a CD instance by parsing a CUE sheet file or string:

.. code-block:: python

    import pylibcue

    cd = pylibcue.parse_file("./example.cue", encoding="utf-8")
    # or
    cd = pylibcue.parse_str("...")

Extract CD metadata and iterate through tracks in CD:

.. code-block:: python

    print("Title:", cd.cdtext.title)
    print("Artist:", cd.cdtext.performer)
    print("Date:", cd.rem.date)
    print("Tracks:")

    for tr in cd:
        print(f"TRACK {tr.track_number:02d}: {tr.cdtext.title} - {tr.cdtext.performer}")

cueprint
^^^^^^^^

pylibcue also provides a command line tool ``cueprint.py`` to dump all information
from CUE sheet. (python version of cuetools ``cueprint`` and ``cuebreakpoints``)

Use ``cueprint.py`` to see how many fields pylibcue can extract from CUE sheet:

.. code-block:: bash

    cueprint.py ./example.cue
    # or
    python3 -m pylibcue.cueprint ./example.cue

License
-------

pylibcue is licensed under the GNU General Public License v2.0.
hichi 0.5.0
A CLI tool for AI interactions (Groq & Gemini) with Supreme Agent for CP/DSA & DBMS, and Beast Mode for multimodal chat
Requires Python: >=3.8

# Hichi 🙏

A powerful CLI tool for interacting with Groq AI models through your terminal.

## Features

- 🔐 Secure password authentication
- 🔑 Encrypted API key storage
- 💬 Interactive chat sessions with session-only memory
- 🤖 Default model: openai/gpt-oss-120b
- � Fresh conversation each session (no persistent history)
- ⚙️ Easy model and API key management

## Installation

### From PyPI (when published)
```bash
pip install hichi
```

### From Source
```bash
git clone https://github.com/yourusername/hichi.git
cd hichi
pip install -e .
```

## Quick Start

1. **Initialize Hichi**
   ```bash
   hichi hi
   ```
   This will prompt you for the password and set up your Groq API key on first run.

2. **Start chatting**
   ```bash
   hichi chat
   ```

## Commands

### `hichi hi`
Initialize and verify setup. Required before using other commands.
- Prompts for hardcoded password
- Sets up Groq API key (first time only)
- Shows current configuration

### `hichi chat`
Start an interactive chat session with the AI.
- Session-only memory (fresh start each time)
- Remembers conversation within current session only
- Type `exit`, `quit`, or `bye` to end session
- Use Ctrl+C to interrupt

### `hichi key`
Update your Groq API key.
- Prompts for password verification
- Securely encrypts and stores new API key

### `hichi model [MODEL_NAME]`
View or change the AI model.
- Without arguments: shows current model
- With model name: updates to new model
- Default: "openai/gpt-oss-120b"

## Security

- API keys are encrypted using Fernet symmetric encryption
- Password verification required for all operations
- Configuration stored in `~/.hichi/`

## Configuration

Hichi stores its configuration in your home directory:
- `~/.hichi/config.json` - Main configuration
- `~/.hichi/key.key` - Encryption key

Note: Chat conversations are session-only and not saved to disk.

## Requirements

- Python 3.8+
- Groq AI API key

## Development

```bash
git clone https://github.com/yourusername/hichi.git
cd hichi
pip install -e ".[dev]"
```

## License

MIT License - see LICENSE file for details.