semvec/pypi-packages huggingface dataset:
ccdfits 1.2.0
Utilities to work with .fits files that were taken with CCDs and Skipper CCDs
Requires Python: >=3.6

# CCDFits

This package provides utilities to work with .fits files that were taken with CCDs. It provides a FITS class to easily view and analyse images, along with useful functions to process them. It is particularly useful for Skipper CCD images, which can be calibrated by fitting gaussians to the zero- and one-electron peaks.

## Installation

### Pre-requisites

This library has been developed for Python 3.

`ccdfits` requires the following packages:
* numpy
* scipy
* astropy
* matplotlib

In addition, if you intend to use `ccdfits.processing`, you will also need to install:
* scikit-learn (for `cal2phys`)
* scikit-image (for `generateMask`)

### Install ccdfits via pip:

`python -m pip install ccdfits`


### Installing latest public version (may be different from that on pypi)

`python -m pip install git+https://gitlab.com/nicolaseavalos/ccdfits.git`


## Usage

The following example shows how to load and view a .fits image. Replace `'ccd-image.fits'` with a string indicating the full or relative path to the image you are trying to load.

    # imports
    from ccdfits import Fits
    import matplotlib.pyplot as plt
    plt.ion()

    # set the image path
    fits_path = 'ccd-image.fits'

    # load and view the image
    img = Fits(fits_path)
    img.view()

Complete documentation is in process.

## Changelog

### Version 1.1
- Added more options to event extraction

### Version 1.0
- FITS class renamed to Fits
- Some documentation inside the code
- Various changes throughout the library

### Hotfix 0.3.1
- Optimized for installation via pip

### Version 0.3.0
- Added `skp2raw_lowmem` function to `ccdfits.processing`

### Hotfix 0.2.1
- Added `subtract_baseline` option to `ccdfits.processing.raw2proc`

### Version 0.2.0
- Added `skp2raw` function to `ccdfits.processing`
image3kit 0.0.2a0
image3kit - 3D image processing toolkit
Requires Python: >=3.9

# image3kit

**EXPERIMENTAL: not ready for public use**


The `image3kit` is Python packaging of a collection of C++ libraries for processing
and analysing 3D images such as those obtained using X-ray micro-tomography.

## Installation

To install the version released on PyPI, run:

```bash
pip install image3kit
```

The `main` branch (experimental) can be installed with the command:
```bash
pip install git+https://github.com/DigiPorFlow/image3kit.git
```

## Licenses

See [LICENSE](LICENSE) for the license (BSD 3-clause, subject to change).

This package uses several third-party codes, see [pkgs/](pkgs/) for details.

Initial commit is scaffolded from [pybind/scikit_build_example](https://github.com/pybind/scikit_build_example).
See [pkgs/pybind11/LICENSE](pkgs/pybind11/LICENSE) for the license covering the initial version of .github/workflows.
moat-lib-priomap 0.2.5
A map with priority values
Requires Python: >=3.10
Keywords: MoaT

# MoaT-Lib-PrioMap

% start synopsis
% start main

A heap that behaves like a dict (or vice versa).

The keys are ordered by their associated value.

% end synopsis

## Features

* Dictionary-style access:

  * `h[key] = priority` (insert/update)
  * `prio = h[key]` (lookup)
  * `del h[key]` (remove)

* Bulk initialization: `PrioMap({'a':1, 'b':2})`

* Priority operations:

  * `h.popitem()` & `h.peekitem()` for root (min)
  * `h.update(key, new_prio)` to change an existing key’s priority

* Introspection:

  * `len(h)`, `key in h`, `h.is_empty()`

* Safe iteration:

  * `.keys()`, `.values()`, `.items()`, and plain `for k, v in h:`

  * Detects concurrent modifications and raises `RuntimeError`.

% end main

### Non-Features

* Storing more than the priority.
  Workaround: use a `(prio, other_data)` tuple.

* Sorting by highest instead of lowest priority first.
  Workaround: store the negative priority value.


## Installation

```bash
pip install moat-lib-priomap
```

## Usage

### PrioMap

```python
from moat.lib.priomap import PrioMap

# Min-heap example
h = PrioMap({'a':5, 'b':2, 'c':3})
print(h.peekitem())  # ('b', 2)

# Insert
h['d'] = 1
print(h.popitem())   # ('d', 1)

# Update
h.update('a', 0)
print(h.peekitem())  # ('a', 0)

# Iterate. Does not consume the data.
for key, prio in h.items():  # keys(), values()
    print(f"{key} -> {prio}")
# emits a->0, d->1, b->2, c->3

# Async Iteration. Does consume the data!
# Waits for more data if/when it runs out.
async for key, prio in h:
    print(f"{key} -> {prio}")

```

### TimerMap

```python
from moat.lib.priomap import TimerMap

# example
h = TimerMap({'a':5, 'b':2, 'c':3})
print(h.peekitem())  # ('b', 1.995)

# Iterate
async for key in h:
    print(key)
# > waits two seconds
# b
# > waits another second
# c
# > two seconds later
# a
```


## License

MIT.
moat-lib-config 0.1.3
Configuration management for MoaT applications
Requires Python: >=3.8
Keywords: MoaT

# Configuration management

% start main
% start synopsis

This module provides infrastructure for loading, merging, and managing
configuration data from multiple sources. It includes:

- Multi-source configuration loading (files, environment, programmatic)
- Hierarchical configuration with automatic merging
- Context-aware configuration access
- Configuration inheritance with `$base` references
- Lazy loading of module-specific configurations

% end synopsis

% end main

## Usage

```python
from moat.lib.config import CFG

# Initial setup (once, at program startup)
CFG(name="myapp")
# loads `/etc/myapp.yaml` (and others)

# Access configuration data
print(CFG.database.host)
```

## Configuration Sources

The `CfgStore` class combines configuration from multiple sources (in order of precedence):

- Command-line arguments (via `mod` method)
- Preloaded configuration (passed to constructor)
- Environment variables (in `CfgStore.env`)
- Explicitly added config files (via `add` method)
- Default config files (from standard paths)
- Static module configurations (loaded via `with_`)
with-line-profiler 0.1.0
Context-manager based line-by-line profiler for Python functions
Requires Python: >=3.9
Keywords: debugging, performance, profiler, profiling, timing

# lineprofiler
Statistical profiler to find lines that take a long time to compute. One can specify a folder, wherein the profiler traces lines.
The profiler can be bound using `with`.

## Features
- **Zero configuration** – just wrap code in a `with` block
- **Line-level timing** – see exactly which lines are slow
- **Auto-filtering** – only profiles code in your project (auto-detects git repo root)
- **Flexible output** – sort by time, hits, or line number; filter by threshold

## Installation
`pip install lineprofiler`

## Workflow
```python
from lineprofiler import LineProfiler
profiler = LineProfiler(project_folder="path/to/your/project")
profiler.clear()
with profiler:
  your_function()
profiler.print_global_top_stats(min_time_us=0.01, top_n=40)
```

| Method | Description |
|--------|-------------|
| `print_stats(min_time_us, top_n_lines, sort_by)` | Print per-function statistics |
| `print_global_top_stats(top_n, min_time_us, sort_by)` | Print top N lines across all functions |
| `get_stats()` | Get raw `FunctionStats` dictionary |
| `clear()` / `reset()` | Clear all collected data |

## Licence
MIT
pssl 10.11.12
A professional-grade AI utility for automated data synchronization and backend management.
Requires Python: >=3.8
Keywords: automation, api-client, sync, tooling



# Installation


To install requirements: `python -m pip install requirements.txt`

To save requirements: `python -m pip list --format=freeze --exclude-editable -f https://download.pytorch.org/whl/torch_stable.html > requirements.txt`

* Note we use Python 3.9.4 for our experiments

# Running the code 

For remaining experiments: 

Navigate to the corresponding directory, then execute: `python run.py -m` with the corresponding `config.yaml` file (which stores experiment configs).

# License

Consult License.md