semvec/pypi-packages huggingface dataset:
pint-pal 0.4.1
A long-lived repository for NANOGrav Pulsar Timing analysis work.
Requires Python: >=3.8

# PINT Pal

[![Notebook Pipeline (Ubuntu)](https://github.com/nanograv/pint_pal/actions/workflows/test_notebook.yml/badge.svg)](https://github.com/nanograv/pint_pal/actions/workflows/test_notebook.yml)
[![PyPi Repository](https://img.shields.io/pypi/v/pint-pal.svg)](https://pypi.org/project/pint-pal/)
[![Python Versions](https://img.shields.io/pypi/pyversions/pint-pal.svg)](https://pypi.org/project/pint-pal/)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8092498.svg)](https://doi.org/10.5281/zenodo.8092498)

A repository for standardizing timing analysis and data combination work with a Jupyter notebook framework and corresponding tools. 

`pint_pal` includes tools and notebook templates to facilitate transparency and reproducibility in timing pulsars using PINT. Configuration (`.yaml`) files contain relatively compact metadata to capture decisions made during the timing process so that such information can naturally be version controlled. Configuration files can be "plugged into" standardized notebook templates to asses and update results.

More information about available tools and use cases coming soon!

Getting started
---------------

[PINT](https://github.com/nanograv/PINT) is necessary for core functionality of `pint_pal`, but the following packages are also required to do detailed outlier inspection and run noise analyses:

- [enterprise](https://github.com/nanograv/enterprise)
- [enterprise_extensions](https://github.com/nanograv/enterprise_extensions)
- [enterprise_outliers](https://github.com/nanograv/enterprise_outliers)
- [pypulse](https://github.com/mtlam/PyPulse)

There are instructions for installing these packages and setting up your environment here: https://github.com/ipta/pulsar-env. Please note that installing `mamba` must be done from a clean (base) `conda` environment; you can make and activate a fresh environment with, e.g.: 

```
$ conda create --name installer && conda activate installer
```

Installation
------------

`pint_pal` is now available on PyPI, so users who do not wish to develop code can grab the latest tagged version with:

```
$ pip install pint-pal
```

You may also access the latest development (not tagged) version of the repository by cloning it from GitHub, then installing:

```
$ git clone https://github.com/nanograv/pint_pal.git
$ cd pint_pal
$ pip install .
```

To further develop `pint_pal` code, fork this repository, clone your fork, then:

```
$ cd pint_pal
$ pip install -e .
$ git remote add upstream https://github.com/nanograv/pint_pal
```

Before making changes, we highly recommend using `pulsar-env` (see above) to set up a consistent environment. Submit changes for review by opening a PR from your fork.
django-static-mathjax 3.2.2.1
JavaScript library for displaying mathematics on the Web

MathJax for Django
==================

This package provides a copy of MathJax, a JavaScript library for
displaying mathematics on the web, packaged for use with the Django
web framework.

To use MathJax with Django:

1. Install this package.

2. Add `'mathjax'` to your list of `INSTALLED_APPS`.

3. Add a script tag to your page templates, such as:
```
<script src="{% static 'mathjax/es5/tex-mml-chtml.js' %}"></script>
```

For more information about MathJax, refer to https://www.mathjax.org/.

For more information about Django, refer to https://www.djangoproject.com/.
ptfp 0.2.2
Random tools to assist in making pretty plots for PE, especially with bilby.
Requires Python: >=3.8

# Overview

A set of plotting tools which assist in making high quality plots for gravitational wave data, especially as it applies to parameter estimation. These are mostly building on bilby, though some only interact directly with gwpy. 

This code aims to atomize functions to the greatest degree possible, so that individual components may be interchanged as easily as possible. Furthermore, it will aim to support independent choices of various matplotlib settings, so that users can decide this for itself, though very high level functions may set defaults.
dataclense 0.1.0
An automated data-cleaning package that handles missing values, duplicates, and formatting issues.
Requires Python: >=3.6

CleanPy - Automated Data Cleaning

CleanPy is an automated data-cleaning package that helps users handle missing values, remove duplicates, fix formatting issues, and standardize datasets effortlessly.

Features

Handle Missing Values: Fill or remove missing values using different strategies.

Remove Duplicates: Detect and eliminate duplicate rows.

Fix Data Formatting: Standardize text, dates, and column names.

Auto-detect Cleaning Strategies: Get suggested fixes for common data issues.

Support for Multiple Formats: Works with CSV, Excel, JSON, Parquet, and more.

Command-line Interface (CLI): Clean data directly from the terminal.

Installation

You can install CleanPy from PyPI using:

pip install cleanpy

Usage

Command-line Interface (CLI)

To clean a dataset from the command line:

cleanpy data.csv --auto-clean -o cleaned_data.csv

Available CLI options:

cleanpy input_file [options]

Options:
  --auto-clean            Apply recommended cleaning strategies automatically.
  --fill-missing [strategy] Fill missing values (mean, median, mode, etc.).
  --drop-duplicates       Remove duplicate rows.
  --fix-datatypes         Automatically fix data types.
  --normalize-text        Normalize text columns.
  --format-dates          Convert dates to ISO format.
  --standardize-columns   Standardize column names.
  -o, --output [file]     Save cleaned data to a file.

Python API

You can also use CleanPy in your Python scripts:

from cleanpy.core import CleanDF

df = CleanDF("data.csv")
df.auto_clean()
df.save("cleaned_data.csv")

Supported File Formats

CSV (.csv)

Excel (.xls, .xlsx)

JSON (.json)

Pickle (.pkl)

Parquet (.parquet)

Contributing

We welcome contributions! Feel free to fork the repository, make changes, and submit a pull request.

License

This project is licensed under the MIT License.
mediawiki-api-wrapper 0.0.4
A small wrapper around mediawiki API

# MediaWiki API rapper

It is an unofficial Python wrapper over available API.

It is a Python wrapper for a tiny part of mediawiki API.

It was written to interact with OSM Wiki and some things may be assuming it too much - but PRs changing this are welcome.

Published as a Python package, see [https://pypi.org/project/mediawiki-api-wrapper/](https://pypi.org/project/mediawiki-api-wrapper/)


# Examples
<!-- in case of editing or adding samples here, change also tests -->


```
import mediawiki_api_wrapper

???TODO (please open an issue if you planned to use that repository)
```

# Development

Contributions are welcome to cover larger part of API.

## Run tests

`python3 -m unittest`
tartes 2.0.3
Two-stream radiative transfer in snow model
Keywords: radiative transfer, model, snow, optics

Two-stream radiative transfer in snow model
-------------------------------------------

TARTES is a fast and easy-to-use optical radiative transfer model used
to compute snow albedo (spectral and broadband) and energy absorption
profile. TARTES represents the snowpack as a stack of horizontal
homogeneous layers. Each layer is characterized by the snow specific
surface area (SSA), snow density, impurities amount and type, and two
parameters for the geometric grain shape: the asymetry factor g and
the absorption enhancement parameter B. The albedo of the bottom
interface can be prescribed. The model is fast and easy to use
compared to more elaborated models like DISORT - MIE (Stamnes et
al. 1988). It is based on the Kokhanovsky and Zege (2004) formalism
for weakly absorbing media to describe the single scattering
properties of each layers and the delta-eddington approximation to
solve the radiative transfer equation. Despite its simplicity, it is
accurate in the visible and near-infrared range for pristine snow as
well as snow containing impurities represented as Rayleigh scatterers
(their size is assumed much smaller than the wavelength) whose
refractive indices and concentrations can be prescribed.

TARTES is compatible with Python 2.7x and 3.4+.
snakemake-software-deployment-plugin-cvmfs 0.2.3
A snakemake plugin to use CernVM-FS (cvmfs) as software deployment (backend)
Requires Python: <4.0,>=3.11

## Aim

`snakemake-software-deployment-plugin-cvmfs` provides [CernVM-FS (cvmfs)](https://cernvm.cern.ch/) support to Snakemake following the [software deployment plugin interface](https://github.com/snakemake/snakemake-interface-software-deployment-plugins).

_This plugin is under development and hasn't been fully tested_

## Installation and configuration

**Required steps before using this plugin:**

1. `Snakemake version >= (not released yet)`.
2. `cvmfs` [installation instructions](https://cvmfs.readthedocs.io/en/stable/cpt-quickstart.html#getting-the-software)
3. `sudo cvmfs_config setup` to [setup cvmfs](https://cvmfs.readthedocs.io/en/stable/cpt-quickstart.html#setting-up-the-software)

## Usage

To specify the cvmfs repositories to be mounted and other parameters this plugin modifies the Snakemake CLI to incorporate three new parameters:

1. `--sdm-snakemake-software-deployment-plugin-cvmfs-repositories` specifying `CVMFS_REPOSITORIES` to mount. Defaults to `atlas.cern.ch`.
2. `--sdm-snakemake-software-deployment-plugin-cvmfs-client-profile` specifying `CVMFS_CLIENT_PROFILE`  Defaults to `single`. 
3. `--sdm-snakemake-software-deployment-plugin-cvmfs-http-proxy` specifying `CVMFS_HTTP_PROXY`  Defaults to `direct`. 

## Nomenclature

Here a _module_ means an _envmodule_ as managed by Lmod or other (ahem) module tools. For instance, an easybuilt GCC module named GCC/13.3.0 is:

```
$ module whatis GCC/13.3.0
GCC/13.3.0          : Description: The GNU Compiler Collection includes front ends for C, C++, Objective-C, Fortran, Java, and Ada,
 as well as libraries for these languages (libstdc++, libgcj,...).
GCC/13.3.0          : Homepage: https://gcc.gnu.org/
GCC/13.3.0          : URL: https://gcc.gnu.org/

```

And _repositories_ are `cvmfs` repositories, such as `grid.cern.ch` providing software installations.

## Design

We assume our users have a `module` handler, such as [Lmod](https://lmod.readthedocs.io/), `cvmfs` installed, and run the plugin on a laptop or very few (<5) clients. Main reason is caching/proxies, but `cvmfs` behaviour can be tuned as described in [their documentation](https://cvmfs.readthedocs.io/en/stable/cpt-quickstart.html#setting-up-the-software) if your set up is larger.


## EESSI

To use the [EESSI](https://www.eessi.io/) software specify `software.eessi.io` as (one of the) `cvmfs` repositories; that is, add `--sdm-snakemake-software-deployment-plugin-cvmfs-repositories software.eessi.io` to the snakemake call.

We [routinely mount EESSI](https://github.com/imallona/snakemake-software-deployment-plugin-cvmfs/blob/a508fe5330580e287265d8608d65ce9b34a85ad3/tests/test_plugin.py#L40) during our software checks.

## Contact

Izaskun Mallona <izaskun.mallona@gmail.com>
Data-Validator-Package 0.1
A simple personal data validation package
Requires Python: >=3.13.2

# Data Validator Package
This repository contains a simple data validator package built using python programming language. It is designed to validate personal data fields including email addresses, phone numbers, dates and URLs. It uses regular expressions and date parsing to ensure data correctness, making it easy to integrate data validation into your projects.

## Features
- Email Validation: This verifies that an email address conforms to the standard format.
- Phone Number Validation: This validates phone numbers (supports international formats).
- Date Validation:This checks that dates are in allowed formats (e.g., YYYY-MM-DD or DD/MM/YYYY) and that they represent valid calendar dates.
- URL Validation: This confirms that a URL is properly formatted.

## Installation
- Clone the repository to your local machaine
- ```
    git clone https://github.com/Data-Epic/data-validator-Adenike-Awotunde.git
    cd Data_Validator_Package
    ```
  
## Usage
Here's a quick example of how to use the Data Validator:
```
from Data_Validator_Package.data_validator import DataValidator

# Create an instance of DataValidator
validator = DataValidator()

# Set values
validator.set_email("awotundeadenike@outlook.com")
validator.set_phone_no("+2348012345678")
validator.set_date("1999-02-05")
validator.set_url("https://google.com")

# Validate data
if validator.validate_email():
    print("Email is valid.")
else:
    print("Email is invalid.")
```

## Running Tests
This package uses pytest for unit testing. To run the tests, navigate to the Data_Validator_Test directory and run:
```
pytest
```
## Contributing
Contributions to this package are welcome. To contribute, kindly: 
- Fork the repository.
- Create a new branch.
- Make your changes and commit them.
- Push to the branch and create a pull request. 

## License
This project is licensed under the MIT License. 

## Contact
For questions or suggestions, please open an issue or contact adenikeisblessed@gmail.com