semvec/pypi-packages huggingface dataset:
storm-lists 1.0.3
Implementations of geomagnetic storm list algorithms, including Walach & Grocott (2019).
Requires Python: >=3.9
Keywords: geomagnetic storms

# storm-lists

[![PyPI badge](https://badge.fury.io/py/storm-lists.svg)](https://badge.fury.io/py/storm-lists)
[![Zenodo badge](https://zenodo.org/badge/1088748199.svg)](https://doi.org/10.5281/zenodo.17521944)

This package compiles Python implementations of various geomagnetic storm lists.

## Citations

When using this software, please cite [the Zenodo record](https://doi.org/10.5281/zenodo.17521944) as well as the paper corresponding to the list you are using:

- [Noora Partamies et al. (2013), Statistical properties of substorms during different storm and solar cycle phases, _Annales Geophysicae_, 31(2), 349–358. https://doi.org/10.5194/angeo-31-349-2013](https://doi.org/10.5194/angeo-31-349-2013)
- [Maria-Theresia Walach and Adrian Grocott (2019). Superdarn observations during geomagnetic storms, geomagnetically active times, and enhanced solar wind driving, _Journal of Geophysical Research: Space Physics_, 124(7), 5828–5847. https://doi.org/10.1029/2019JA026816](https://doi.org/10.1029/2019JA026816)

## Funding

John C Coxon was supported during this work by Science and Technology Facilities Council (STFC) Ernest Rutherford Fellowship ST/V004883/1.

## Installation

To install and test the model, simply type:

```
pip install storm-lists
```

## Usage

For examples of how to use the models, see the Jupyter notebooks in the `notebooks` directory.

## Model-specific notes

### Walach and Grocott (2019)

The Walach and Grocott (2019) implementation in this module is directly based on the IDL code used to generate the list
for that paper.

### Partamies et al. (2013)

The Partamies et al. (2013) implementation in this module is based on the description in the paper, and it makes 
assumptions outlined below.

1. The rate of change at a timestamp is calculated between Dst at the timestamp and Dst at the previous timestamp.
2. The recovery phase start is set to the last timestamp at which the rate of change is still under the threshold.
3. If there is only one hour where the rate of change is below the threshold, the main phase and recovery phase are set 
to the same timestamp.
4. When a local minimum in Dst is not associated with a rate of change below the threshold, it is ignored and the 
algorithm runs again neglecting that minimum Dst. (This implies that Dst can theoretically still continue to decrease 
during the recovery phase before starting to recover.)  
5. When looking back to the point at which Dst exceeded the start threshold, if that point has already been labelled as 
belonging to the storm, the start of the storm under consideration is set to one hour after the previous storm end 
and the storm type is set to 2 (as opposed to the default value of 1).
valve-gfx-ci.executor.server 0.0.3
Valve GFX CI's executor
Requires Python: >=3.10

# CI-tron executor

The CI-tron executor is the service that coordinates different services to
enable time-sharing test machines, AKA devices under test (DUTs).

This service can be interacted with using
[executorctl](https://gitlab.freedesktop.org/gfx-ci/ci-tron/-/blob/main/executor/client/),
our client, and/or our
[REST API](https://gfx-ci.pages.freedesktop.org/ci-tron/docs/executor.html#id1).

Take a look to our full documentation at
[https://gfx-ci.pages.freedesktop.org/ci-tron/](https://gfx-ci.pages.freedesktop.org/ci-tron/)
delos-unichunking 1.2.0
Universal chunking functions to extract LLM-friendly chunks from any file type.
Requires Python: <4.0,>=3.9.1

# Unichunking

Extract LLM-friendly chunks from any file type.

Supported file types are :

 - DOCX & DOCX-like (DOC, ODT)
 - PPTX & PPTX-like (PPT, ODP)
 - XLSX & XLSX-like (XLS, ODS)
 - TXT, MD, CSV
 - IPYNB

# Installation

To install, run the following command:

```bash
python3 -m pip install delos-unichunking
```

# How to use

The main functions are :

 - `extract_subchunks` returns a list of all the text particles in the file.
 - `split_chunks_with_overlap` transforms a list of subchunks on a given page into a list of chunks following default or specified parameters for minimum/maximum token size and overlap.
 - `build_chunked_pages` returns a list of "pages", which are lists of formated chunks, following the structure of the document.
 - `compute_pages` approximates the pagination of a file that does not have a native pagination system (such as DOCX) by comparing it to a PDF version.

# Specificities

Please note that the package requires a LibreOffice installation to run `soffice` commands, used during file conversions : for instance, DOC/ODT are first converted to DOCX format and processed as such.

The page numbers computed for DOCX files are an approximation and can be off by a few pages for large files.

Artifical page numbers are used for page-less structures such as TXT files, or to split large XLSX sheets into multiple pages, to follow a tokens-per-page limit.
bruggeman 0.1.0
Repository for the Bruggeman equations from Analytical Solutions of Geohydrological Problems (1999)
Requires Python: >=3.12

# Bruggeman: Analytical Solutions of Geohydrological Problems

This repository contains implementations of Bruggeman's analytical solutions in Python.

The philosphy behind this repository is to collect implementations of
analytical solutions so they are readily available for use in projects or for
benchmarking other computations or models.

Very much a work in progress. Any contributions are welcome.

## Installation

Normal install:

`pip install bruggeman`

Development install:

`pip install -e .`

## Documentation

The documentation is available [here](https://bruggeman.readthedocs.io/en/latest/index.html).

To build the documentation locally:

1. Install the optional documentation dependencies `pip install bruggeman[docs]`
(or `pip install -e ".[docs]"`).
2. Navigate to `docs/`
3. Enter the command `make html`.
4. The documenation is contained in the `docs/_build` folder. Open `index.html` in
your browser to view the documentation.

## Contributing

Any contributions are welcome! For the best results please follow the guidelines below:

- The analytical solutions are generally stored in the `bruggeman/*.py` files. Please
  select the appropriate python file for your solution. E.g. 1D flow solutions should be
  stored `flow1d.py`. Create a new file if your solution does not fit into the currently
  available files.
- Create a notebook showcasing your solution. Put the notebook in `docs/examples/`.
- Add the notebook under the appropriate section in `docs/examples/index.rst`. Follow
  the examples in the file to add your notebook. Don't forget to add your notebook to the
  table of contents as well.
- Consider decorating your function with latexify by importing
  `from bruggeman.general import latexify_function`. Follow the examples already present
  in the python files. This will allow you to render your formulas with LateX in a notebook.
JythonMusic 0.0.0
A Python-based software environment for developing algorithmic art projects.
Requires Python: >=3.9
Keywords: algorithmic art, algoart, interactive art, creative coding, live coding, music, audio, gui, graphics, multimedia, midi, osc, learning, iannix, markov, zipf

# JythonMusic

JythonMusic is a software environment for learning and developing algorithmic art projects.  It is a Python port of [JythonMusic ](https://jythonmusic.me/api-reference/), powered by [PySide6](https://wiki.qt.io/Qt_for_Python) and [portaudio](http://portaudio.com/).

- [Homepage](https://jythonmusic.me/)

JythonMusic is distributed under the MIT License.
This package is still under development.
mafw-tools 1.0.0
A set of commonly used tools to be used with MAFw and others
Requires Python: >=3.8
Keywords: data-analysis

# MAFW Tools

[![PyPI](https://img.shields.io/pypi/v/mafw-tools)](https://pypi.org/project/mafw-tools/)
[![License](https://img.shields.io/badge/license-EUPL--1.2-blue)](https://github.com/eea/mafw-tools/blob/main/LICENSE.txt)
[![pipeline status](https://gitlab.jrc.ec.europa.eu/jrc-projects/autorad/mafw-tools/badges/main/pipeline.svg)](https://gitlab.jrc.ec.europa.eu/jrc-projects/autorad/mafw-tools/-/commits/main)
[![coverage report](https://gitlab.jrc.ec.europa.eu/jrc-projects/autorad/mafw-tools/badges/main/coverage.svg)](https://gitlab.jrc.ec.europa.eu/jrc-projects/autorad/mafw-tools/-/commits/main)

A set of commonly used tools to be used with MAFw and other data analysis frameworks.

This package is often used as an incubator for tools that sooner or later will gain the stability and the required 
completeness to be included into [MAFw](https://code.europa.eu/kada/mafw).

## Table of Contents

- [Installation](#installation)
- [Features](#features)
- [Usage](#usage)
- [Documentation](#documentation)
- [Contributing](#contributing)
- [License](#license)

## Installation

Install the package using pip:

```bash
pip install mafw-tools
```

Or install in development mode:
```bash
pip install -e .
```

## Features 

This package provides utility functions for:
* File Operations: Pickle serialization/deserialization with support for compressed files
* Plotting Tools: Flexible image plotting with customizable axes, titles, and colorbars
* Generic Utilities: Helper functions for common operations like nested attribute retrieval

## Usage

Import the package or the modules to enjoy the tools. 

### File tools example

```python
from mafw_tools.file_tools import save_to_pickle, load_from_pickle

# Save multiple objects to a pickle file
data = {'key': 'value'}
save_to_pickle('data.pkl', zipped=True, my_data=data)

# Load objects from pickle file
loaded_data = load_from_pickle('data.pkl')
```

### Plotting tools example

```python
import matplotlib.pyplot as plt
import numpy as np
from mafw_tools.plotting_tools import plot_image

fig, ax = plt.subplots()
data = np.random.rand(10, 10)
plot_image(data, ax, title="Sample Image", attach_colorbar=True)
plt.show()
```

### Generic tools example
```python
from mafw_tools.generic_tools import getattr_nested

class First:
    def __init__(self, a):
        self.a = a

class Second:
    def __init__(self, b):
        self.b = First(b)

m = Second(3)
value = getattr_nested(m, 'b.a')  # Returns 3
```

## Documentation
Full documentation is available at https://gitlab.jrc.ec.europa.eu/jrc-projects/autorad/mafw-tools

## Contributing
Contributions are welcome! Please follow these steps:
* Fork the repository
* Create a feature branch
* Commit your changes
* Push to the branch
* Create a Pull Request