semvec/pypi-packages huggingface dataset:
cmip-ref-celery 0.2.0
Celery app for mananging tasks and workers
Requires Python: >=3.10

# ref-celery

This package provides celery task generation from Provider and Metric definitions.

## CLI tool

The `cmip_ref_celery` package provides a CLI tool to start a worker instance from a REF metrics provider.
This worker instance will listen for tasks related to a provider and execute them.
The compute engine worker will then collect the results of these tasks and store them in the database.
This allows for the REF to be run in a distributed manner,
with multiple workers running on different machines with a centrally managed database.

### Usage

For example, to start a worker instance for the `cmip_ref_metrics_example` package:

```bash
ref-celery start-worker --package cmip_ref_metrics_example
```

This requires the `cmip_ref_metrics_example` package to be installed in the current virtual environment.

If the `cmip_ref` package is also installed,
the celery CLI command is available via the `ref` CLI tool.
The equivalent command to the above is:

```bash
ref celery start-worker --package cmip_ref_metrics_example
```

### Configuration

Each worker instance may not share the same configuration as the orchestrator.
This is because the worker may be running on a different machine with different resources available or
directories.

Each worker instance requires access to a shared input data directory and the output directory.
If the worker is deployed as a docker container these directories can be mounted as volumes.


#### Environment Variables

TODO
si-seqfs-da 1.1
Statistical Inference for Sequential Feature Selection after Domain Adaptation

# Statistical Inference for Sequential Feature Selection after Domain Adaptation 

This package provides a statistical inference framework for sequential feature selection (SeqFS) after domain adaptation (DA). It leverages the SI framework and employs a divide-and-conquer strategy to efficiently compute the p-value of selected features. Our method ensures reliable feature selection by controlling the false positive rate (FPR) while simultaneously maximizing the true positive rate (TPR), effectively reducing the false negative rate (FNR).

*For more details, refer to the paper at https://arxiv.org/abs/2501.09933*

Note: This package utilizes the scipy package to solve linear programming problems using the simplex method. However, the default scipy package does not provide the set of basic variables in its output. To address this limitation, we slightly modified the package so that it can return the set of basic variables by replacing the two files '_linprog.py' and '_linprog_simplex.py' in scipy.optimize module with our modified files in the folder 'files_to_replace'.

Please visit [these detailed instructions](https://github.com/locluclak/SI-SeqFS-DA?tab=readme-ov-file#how-to-automatically-replace-the-files) on replacing the files.

## Installization

You can install this package from PyPI using:

`pip install si-seqfs-da`

## Example 

```python 
from si_seqfs_da import gendata, SI_SeqFS_DA
import numpy as np

ns = 50 #number of source's samples
nt = 10 #number of target's samples
p = 4 #number of features

true_beta_s = np.full((p,1), 2) #source's beta
true_beta_t = np.full((p,1), 0) #target's beta

Xs, Xt, Ys, Yt, Sigma_s, Sigma_t = gendata.generate(ns, nt, p, true_beta_s, true_beta_t)



K = 2 # number of features to be selected


# apply DA-SeqFS to select relevant features
print('Selected features: ', DA_SeqFS.DA_SeqFS(Xs, Ys,
                                                Xt, Yt,
                                                Sigma_s, Sigma_t,
                                                K, method='forward'))

# compute p-value with SI-SeqFS-DA 
print('p-value =',SI_SeqFS_DA.SI_SeqFS_DA(Xs, Ys, 
                                Xt, Yt, 
                                K, Sigma_s, Sigma_t, 
                                method='forward', jth=None)) 
                                #jth = None means randomly choose jth

K = 'AIC' # stopping criterion
# apply DA-SeqFS to select relevant features
print('Selected features: ', DA_SeqFS.DA_SeqFS(Xs, Ys, 
                                                Xt, Yt, 
                                                Sigma_s, Sigma_t,
                                                K, method='backward'))
# compute p-value with SI-SeqFS-DA 
print('p-value =',SI_SeqFS_DA.SI_SeqFS_DA(Xs, Ys, Xt, Yt, K, Sigma_s, Sigma_t, method='backward', jth=1))
```
neidspecmatch 0.1.4
Matching NEID Spectra
Keywords: NEID Spectra Astronomy

# NEIDspecmatch (Beta)
NEIDSpecMatch: Spectral matching of NEID data. Based on: [HPFSpecMatch](https://gummiks.github.io/hpfspecmatch/). 

# Dependencies 

- pyde, either (`pip install pyde`) or install from [here](https://github.com/hpparvi/PyDE). This package needs numba (try `conda install numba` if problems).
- emcee (`pip install emcee`)
- astroquery (`pip install astroquery`)
- crosscorr (`git clone https://github.com/TeHanHunter/crosscorr.git`) `pip3 install .` NEED fortran installation. For Mac: brew install gcc (GNU fortran). For Ubuntu: sudo apt install gfortran
- NEIDspec (`git clone https://github.com/TeHanHunter/neidspec.git`) `pip3 install .`
- lmfit (`pip install lmfit`)
- barycorrpy (`pip install barycorrpy`)

  Known Issue: The latest version of barycorrpy deprecated some syntax used in the NEIDSpecMatch. Please use earlier versions (0.4.4 tested to work) while we update the syntax. 

# Installation
create a new conda env with
`conda create -n neidspecmatch python==3.10`
`conda activate neidspecmatch`
```
conda install numba
git clone https://github.com/hpparvi/PyDE.git
cd PyDE
pip3 install .
cd ..
pip3 install emcee
pip3 install astroquery
git clone https://github.com/TeHanHunter/crosscorr.git
cd crosscorr
brew install gcc
pip3 install .
cd ..
git clone https://github.com/TeHanHunter/neidspec.git
cd neidspec
pip3 install .
cd ..
pip3 install lmfit
pip3 install barycorrpy
pip3 install celerite
git clone https://github.com/TeHanHunter/neidspecmatch.git
cd neidspecmatch
pip3 install .
```
# Library download
The current library include 78 library stars. You may download them [here](https://drive.google.com/drive/folders/1YPzRRKow2PD0Lhkr8fCIos6fSNbFCTS1?usp=share_link). The full directory (yyyymmdd_specmatch_nir/) need to be saved under the library/ folder. Make sure the path in config.py agrees with the name of the library. 

# Cross-validation and result uncertainty 
The cross-validation is a necessary step to estimate the uncertainty of the recovered stellar parameters. To run the cross-validation on the current library, one can run `run_crossval.py` for the desired order(s). The output include a file in the format of `crossvalidation_results_o102.csv`. One can take the standard deviation of the column d_teff, d_feh, and	d_logg on all/certain rows (depending on the star type you want to estimate the uncertainty). 

The alternative is to use the cross-validation result saved in the same link as the library, although we recommend running the cross-validation locally to check the completeness of the installation. 

# Fit a spectrum
Once the library is in place, one can run NEIDSpecMatch using `run_neidspecmatch.py`. You need to specify the file path, target name (as in the fits header), orders, and more.

# Reference
TODO
runpod-ariadne 0.1.0
A third-party RunPod GraphQL client in Python generated using Ariadne.
Requires Python: >=3.10

# Usage
A third-party RunPod GraphQL client in Python generated using Ariadne.
The author is not affiliated with RunPod. This package will be updated to match the API on a best effort basis.

# Development
To regenerate the package:
1) Install dev dependencies: `pip install -r pyproject.toml --extra dev` 
1) Fetch https://graphql-spec.runpod.io/ and convert it to markdown to reduce the size
2) Ask your favorite AI to convert it into a valid GraphQL schema `runpod.schema`
4) Run `ariadne-codegen`

# Deployment
This package uses GitHub Actions to automatically deploy to PyPI when a new release is created, using PyPI's trusted publishing feature.

To deploy a new version:
1. Update the version in `pyproject.toml`
2. Create a new release on GitHub with a tag matching the version (e.g., `v0.1.0`)
3. The GitHub Action will automatically build and publish the package to PyPI