semvec/pypi-packages huggingface dataset:
cpymad-lhc 0.2.1
Helper functions to run LHC optics in cpymad.
Requires Python: >=3.10
Keywords: cpymad, hllhc, lhc

# cpymad LHC

[![Cron Testing](https://github.com/JoschD/cpymad_lhc/workflows/Cron%20Testing/badge.svg)](https://github.com/JoschD/cpymad_lhc/actions?query=workflow%3A%22Cron+Testing%22)
[![Coverage](https://raw.githubusercontent.com/JoschD/cpymad_lhc/python-coverage-comment-action-data/badge.svg)](https://github.com/JoschD/cpymad_lhc/tree/python-coverage-comment-action-data)
[![GitHub last commit](https://img.shields.io/github/last-commit/JoschD/cpymad_lhc.svg?style=popout)](https://github.com/JoschD/cpymad_lhc/)
[![GitHub release](https://img.shields.io/github/release/JoschD/cpymad_lhc.svg?style=popout)](https://github.com/JoschD/cpymad_lhc/)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5070986.svg)](https://doi.org/10.5281/zenodo.5070986)

This package provides LHC specific tools to use with [cpymad](https://hibtc.github.io/cpymad/).

## Installation

You can install the package via pip:

```bash
pip install cpymad_lhc
```

## License

This project is licensed under the `MIT License` - see the [LICENSE](LICENSE) file for details.
AtomicTrit 2.0.0
Tools for calculating the scattering cross sections of atomic tritium and hydrogen for Project 8 and similar experiments
Requires Python: <4,>=3.7

# Atomic T and H Cross Section Calculator

This package can be used to evaluate the cross sections for elastic and inelastic scattering of cold atomic 
hydrogen and tritium.  

It accompanies the paper: 

## Reference
If you use this code, please cite the paper:

"Elastic and Spin-Changing Cross Sections of Spin-Polarized Atomic Tritium"
M.G. Elliott and B.J.P. Jones

## Structure

The source code is in the /src/ folder, and the /examples/ folder contains a set of Jupyter notebooks 
that illustrate the use of code for various calculations.  

## Examples

The examples provided with the codeare the following:

**Elastic Cross Section**
Calculate the elastic scattering dd->dd cross section as a function of magnetic field and temperature

**Dipolar Losses**
Calculate the dipole (eg. dd->aa) loss rates in the zero temperature limit

**Spin Exchange**
Calculate the spin exchange (e.g. cc->aa) loss rates in the zero temperature limit.

**Potentials**
Compare the various potential shapes used in the calculations (see potentials.py to enable a different set)

**Potential Comparison**
Check the effects of the potential on some of the the cross sections

**Hyperfine levels**
Plot the Breit Rabi levels of H and T

**Higher partial waves**
Perform finite temperature calculations including the effects of higher partial waves than l=0

**Literature comparison**
Make a set of plots to compare predictions to published data

**Adiabatic correction**
Check the effect of the adiabatic correction to the potential

**Make Tables**
Generate cross section tables as a function of channel, B field and temperature

**Plot Tables**
Pull data from the above tables and plot it

**Fractional Uncertainty**
Evaluate error bars due to various sources of systematic uncertainty
mkdocs-auto-figure-list 0.2.2
Auto creation for figures in MkDocs.

# MkDocs auto figure list

**Note: This plugin is still in an early development phase and may contain some bugs. You are welcome to contribute to its further development.**

This plugin searches through all markdown files for the HTML tags `<figure>` and `<figcaption>`. These are then collected in ascending order, and a new markdown file named `figure-list.md` is created. This file lists all the figures and adds a link to the corresponding image.

This plugin works with the PDF-Exporter Plugin: https://github.com/Privatacc/mkdocs-to-pdf.git

Example of a `<figure>` tag:
```
<figure>
  <img src="path/to/img.jpg" alt="my image">
  <figcaption>My figcaption</figcaption>`
</figure>
```

Installation:
You can install this package with pip:
```
pip install mkdocs-auto-figure-list
```

Use:
The plugin must be added to the `mkdocs.yml` file as follows:
plugins:

Options:
```
    - auto-figure-list:
        heading: "Figure-List"
        figure_label: "Figure"
```
wavedenoiser 0.2.0
WaveDenoiser is a large deep learning model to reduce background noise from seismic signals.
Requires Python: >=3.11

# WaveDenoiser

A large deep learning model to reduce background noise from seismic signals in the time domain. The model was developed by Chengping Chai, Derek Rose, Scott Stewart, Nathan Martindale, Mark Adams, Anibely Torres Polanco, Lisa Linville, Christopher Stanley, and Philip Bingham.

## Introduction

This model is trained on STEAD (Mousavi et al., 2019) for reducing background noise from seismic signals. The model was trained using earthquake data at local distances (0-350 km). The model may not perform well for earthquake data at larger distances or for non-earthquake sources. The model may have a less-than-optimal performance for earthquake data outside of a source-receiver distance range of 10-110 km and a magnitude range of 0-4.5 due to biases in the training data.

The model uses 57s-long three-component seismograms sampled at 100 Hz as input. The output of the model are denoised three-component seismograms.

## Installation

Creating a virtual environment is highly encouraged. For example, you can run the following command if you use mamba.
```
mamba create -n wavedenoiser python=3.12
mamba activate wavedenoiser
```
To install WaveDenoiser with GPU support, you can use the following command.

```
pip3 install wavedenoiser
```
To install only for CPU (e.g., macOS), you may use the following command.
```
pip3 install torch==2.7 torchvision torchaudio
pip3 install wavedenoiser
```

## Example Usage

```
import h5py
import numpy as np  
from wavedenoiser.wavedenoiser import Denoiser
model = Denoiser()
#
fid = h5py.File("example_waveforms.h5", "r")
data_group = fid["data"]
example_data = []
for akey in data_group.keys():
    dataset = data_group[akey]
    example_data.append(dataset[...])
fid.close()
#
example_data = np.array(example_data)
preds = model.predict(example_data)
```

## Test the Package

First, download the GitHub repostory and go to the top directory of the package. Then, run the following command.
```
cd tests
python run_tests.py
```
![example image](images/example_waveform_2.png)

## Known Limitations

* The model may have a less-than-optimal performance for earthquake data outside of a source-receiver distance
range of 10–110 km and a magnitude range of 0–4.5 because of biases in the training data.
* The model may not perform well for earthquake data at larger distances or for non-earthquake sources.


## Reference

TBD

## License

GNU GENERAL PUBLIC LICENSE version 3

## Credit

The architecture of the deep learning model was adapted from SeisBench (Woollam et al., 2022).
manifold-fabric-utils 0.1.0
Utilities for Fabric/Spark environments
Requires Python: >=3.6

## manifold_fabric_utils

Utilities for Microsoft Fabric/Spark environments, with helpers for working with Lakehouse `Tables/` and `Files/` using `notebookutils.mssparkutils`.

### Install

```bash
pip install .
```

Requires Python 3.6+ and a Fabric/Spark runtime for functions that call `mssparkutils`.

### Quick start

```python
from manifold_fabric_utils import (
    path_exists,
    list_dir,
    map_dir,
    create_schema_if_not_exists,
)

# Works with local/posix paths and Fabric Lakehouse paths
path_exists("/tmp")               # True/False via os.path.exists
path_exists("Tables/my_schema")   # Uses mssparkutils.fs.ls under the hood

# Directory listing (Lakehouse path expected for list/map helpers)
files = list_dir("Files/my_folder")        # List[str]
names_iter = map_dir("Files/my_folder")    # Iterator[str]

# Create a Lakehouse schema folder if missing
created = create_schema_if_not_exists("my_schema")  # True if created, else False
```

### API

- **path_exists(path)**: Returns True if a local path exists or if a Lakehouse path (`Tables/` or `Files/`) can be listed via `mssparkutils.fs.ls`.
- **list_dir(path)**: Returns a list of entry names for a Lakehouse directory.
- **map_dir(path)**: Returns an iterator of entry names for a Lakehouse directory.
- **create_schema_if_not_exists(schema_name)**: Ensures `Tables/{schema_name}` exists; creates it if missing.

### Notes

- Functions that touch `Tables/` and `Files/` require `notebookutils.mssparkutils` (Fabric/Spark environment).
- Local filesystem behavior uses the standard library (`os.path`).

### License

MIT
anubis-ipsw 0.0.5
IPSW rule base collector
Requires Python: >=3.10
Keywords: ios, jailbreak, cli, automation, darwin, osx, macos, ipsw

# Anubis – Automated IPSW Data Harvester

Anubis is an automated collection framework for extracting data from binary files.
It supports various
collection methods, including regex searching, symbol extraction, class dumping, and IDA-based
analysis.

---

## Collectors

- **Regex-Based File Search** – Locate patterns in files using `ripgrep`.
- **Class Dump Extraction** – Extract Objective-C class information from Mach-O binaries.
- **Protocol selectors Extraction** – Extract Objective-C selectors of given protocol.
- **Plist Conversion** – Convert property list (`plist`) files to structured `YAML` format.
- **Section Extraction** – Retrieve specific sections from Mach-O binaries.
- **Symbol Extraction** – Extract function symbols from binaries using `nm`.
- **Strings Extraction** – Extract and filter strings from binaries using regex patterns.
- **Register Tracking** *(Experimental)* – Analyze register values within functions using IDA Pro.
- **Binary Export** *(Not supported on IDA 9+)* – Extract and export binary analysis results from IDA Pro.

## Installation

### 1. Install Dependencies

```sh
brew install yq ripgrep libmagic
```

### 2. Install Anubis.

```sh
python3 -m pip install anubis-ipsw
```

**To use the IDA-based collectors, `anubis` must be installed on the same Python interpreter as IDA.
You can select the correct interpreter using the `idapyswitch` utility.**

## Usage

### Running Collectors

To collect data based on a rule file:

```sh
anubis collect /path/to/input /path/to/output /path/to/rules.yaml
```

#### Filtering Collectors

Run specific collectors:

```sh
anubis collect /input /output /rules.yaml -c rg -c binexport
```

Exclude specific collectors:

```sh
anubis collect /input /output /rules.yaml -b strings -b section
```

[Rules example](example_rules.yaml)

Pull requests and issues are welcome!