semvec/pypi-packages huggingface dataset:
lazyslurm 0.1.0
A interface for SLURM job management.
Requires Python: >=3.9

 <p align="center">
   <img src="./imgs/logo.png" width="30%" alt="Project Logo">
 </p>

LazySlurm is a terminal-based Slurm management tool built with Python and curses, inspired by LazyGit for Git.

## Features
- View and manage jobs
- See partition availability

## Installation
Use pip to install the package

## Usage
To use lazyslurm you only need to run the following command:

```bash
lazyslurm
```

## Development
```bash
git clone https://github.com/your-repo/lazyslurm.git
cd lazyslurm
pip install -r requirements.txt
```

## Usage
```bash
python -m lazyslurm.main
```

## Contributing
Contributions are welcome! Please fork this repository and submit a pull request.

## License
MIT License
emccd-detect 2.5.0
EMCCD detector image simulation
Requires Python: >=3.6

# EMCCD Detect

Given an input fluxmap, emccd_detect will return a simulated EMCCD detector image.  Website:  (<https://github.com/roman-corgi/emccd_detect/tree/master/emccd_detect>)


# Version

The latest version of emccd\_detect is 2.5.0.  Main differences from previous version, 2.4.0: 
--the ability to implement smear due to exposure of some rows while others are being read out.  Credit for this smearing code: Peter Williams, Tellus1, 2024.
--the ability to implement non-uniformity in pixel response via an input master flat.  Assumed to be a FITS file.


## Getting Started
### Installing

This package requires Python version 3.6 or higher.  If the user wants the ability to apply charge transfer inefficiency (CTI) to detector frames using the optional tool (older version of arcticpy which is pure Python) provided in emccd\_detect, then the Python version should be >=3.6 and <=3.9.  If the newer version of arcticpy (wrapper around C++ code) is installed, there is no upper limit restriction for Python version. For installation instructions and documentation for the newer arcticpy, see <https://github.com/jkeger/arctic>. emccd\_detect works apart from arcticpy and does not require it.

emccd\_detect is available on PyPI.org, so the following command will install the module (without CTI capabilities):

	pip install emccd-detect

To install emccd\_detect instead from this package download, after downloading, navigate to the emccd\_detect directory where setup.py is located and use

	pip install .

This will install emccd\_detect and its dependencies, which are as follows:

* astropy
* matplotlib
* numpy
* scipy
* pynufft==2020.0.0
* pyyaml

To optionally implement CTI capabilities with the pure-Python arcticpy, navigate to the arcticpy directory (<https://github.com/roman-corgi/emccd_detect/tree/master/arcticpy_folder>), and there will be a file called setup.py in that directory.  Use

	pip install .

This will install arcticpy version 1.0.  See (<https://github.com/jkeger/arcticpy/tree/row_wise/arcticpy>) for documentation.  If
you have Python>3.9, the CTI functionality will not work if you are using the arcticpy installation that was included with this emccd_detect package, but everything else will work fine.


### Usage

For an example of how to use emccd\_detect, see example_script.py.


## Authors

* Bijan Nemati (<bijan.nemati@tellus1.com>)
* Sam Miller (<sam.miller@uah.edu>)
* Kevin Ludwick (<kevin.ludwick@uah.edu>)
crawlerugo 0.0.4
A python package that crawls a directory recursively and returns the file names and file stats as well as execute a custom function passed as a parameter.
Requires Python: >=3.8

# 🚀 CrawlerUgo

**Crawler Ugo** is a Python package for recursively crawling directories, collecting file stats, and executing custom actions on each file.  
It’s perfect for building file search tools, batch processors, or custom directory explorers.

---

## 📦 Installation

```bash
$ pip install crawlerugo
```




## Usage
crawl() takes three arguments
=> path (str), function (callable), max_depth (int|None) = None

``` python
from crawlerugo.crawler import crawl
import os

# Set your target directory
base_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')

def main():
    # Crawl the directory and run a custom action on each file
    result = crawl(base_dir, lambda f: f, 1000)  # max_depth is optional but if present indicates the debth count to crawl
    print("Crawled Data:", result)

if __name__ == "__main__":
    main()
```
cooklang-py 0.3.2
Python Parser for Cooklang
Requires Python: >=3.10

# cooklang-py

[![Tests](https://github.com/brass75/cooklang-py/actions/workflows/test.yml/badge.svg)](https://github.com/brass75/cooklang-py/actions/workflows/test.yml)
[![Format and Lint](https://github.com/brass75/cooklang-py/actions/workflows/lint.yml/badge.svg)](https://github.com/brass75/cooklang-py/actions/workflows/lint.yml)
[![CodeQL](https://github.com/brass75/cooklang-py/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/brass75/cooklang-py/actions/workflows/github-code-scanning/codeql)

A parser for the [Cooklang recipe markup language](https://cooklang.org)

## Installation

To install just run:

```shell
pip install cooklang-py
```

## Documentation

Full documentation is available at [https://cooklang-py.readthedocs.io/](https://cooklang-py.readthedocs.io/)

## `Recipe`

The `Recipe` is the primary unit. There are 2 ways to create a `Recipe` object:

```python
from cooklang_py import Recipe

# Create from a string in memory
recipe_string = '<your recipe here>'
recipe = Recipe(recipe_string)

# Create from a file
recipe_file = '/path/to/recipe/file'
recipe = Recipe.from_file(recipe_file)
```

Just like a recipe in a book a `Recipe` contains:

- Ingredients
- Cookware / equipment
- Timings
- Metadata (servings, cook time, etc.)

To see how to define these in your input please refer to the
[Cooklang language specification](https://cooklang.org/docs/spec/#comments)

When the recipe is parsed there will be a list of `Step` objects. Each step object can contain:

- Ingredients
- Cookware
- Timings
- Instructions (text)

At both the `Recipe` and `Step` level you can access the list of `Ingredients` and `Cookware`
for the recipe or step.

### Cookware, Timings, and Ingredients

Cookware, timings, and ingredients are the backbone of the recipe. In this package all three
inherit from the `BaseObj`. They all have the following 3 attributes:

- `name` - the name of the item (i.e. pot, carrot, etc.)
- `quantity` - how much is needed
- `notes` - any notes for the item (i.e. "greased", "peeled and diced", etc.)
  - `Timings` do not have notes per the Cooklang specification.

### Overriding implementations

The implementations of Cookware, Timings, and Ingredients can be overridden by creating a new
implementation (inheriting from either that class or from `BaseObj`) and calling `Recipe` or
`Step` with an updated `prefixes` dictionary that points the desired prefix to the new class.

## Compatibility

`cooklang-py` passes all canonical tests defined at
[https://github.com/cooklang/cooklang-rs/blob/main/tests/canonical.yaml](https://github.com/cooklang/cooklang-rs/blob/main/tests/canonical.yaml)
for the following platforms:

- Linux
- MacOS
- Windows
xl-engine 0.4.0
A Python package that provides convenience functions using XLWings to parametrize,
Requires Python: >=3.11

# xl-engine
 Use your existing Excel workbooks like they were Python programs: A utility built on XLWings to automate the input, execution, and data retrieval of your existing Excel Workbooks. 


## Installation

`pip install xl-engine`

## Basic Usage

### `execute_workbook`

Use `execute_workbook` when you want to execute a workbook once with known, provided parameters.

```python
import xl_engine as xl

results = xl.execute_workbook(
    TEST_DATA_DIR / "example_wb.xlsx",
    cells_to_change = {"B1": 33, "B2": 66},
    cells_to_retrieve=['B4', 'B5'], # This can either be a list or a dict; see next example
    sheet_idx=1,
    new_filepath=TEST_DATA_DIR / "stored_results.xlsx"
)

# results
# {'B4': 22.0, 'B5': 11.0}
```

You can also use a dictionary in `cells_to_retrieve` to meaningfully label the results:

```python
results2 = xl.execute_workbook(
    TEST_DATA_DIR / "example_wb.xlsx",
    cells_to_change = {"B1": 33, "B2": 66},
    cells_to_retrieve={'B4': "label1", 'B5': "label2"}, # Now a dict
    sheet_idx=1,
    new_filepath=TEST_DATA_DIR / "stored_results.xlsx"
)

# results2
# {'label1': 44.0, 'label2': 39.599999999999994}
```

### `excel_runner`

Use `excel_runner` when you want to execute a workbook multiple times (static inputs) with multiple options (dynamic inputs).

```python
import xl_engine as xl

# Creates a callable with the following function signature: callable(x: float | int) -> bool:
# When a value is a passed to dcr2, i.e. dcr2(some_value), it will return True if
# the value is greater-than-or-equal-to 2
dcr2 = xl.create_condition_check(2, "ge")

# static_inputs will be used to populate each workbook.
# Within each set of static inputs, a second sub-iteration will occur
# where the dynamic inputs will be input allowing you to test the
# results for different "options" of dynamic inputs.
# If the save conditions pass (return True for all keys), then a copy of the
# workbook will be saved to disk with the successful inputs recorded.
# A dictionary of all calculated results will be returned.
results = xl.excel_runner(
        TEST_DATA_DIR / "example_wb.xlsx",
        static_inputs={"B1": [10, 20], "Labels": ["C01", "C02"]},
        dynamic_inputs={
            "OptA": {"B2": 22},
            "OptB": {"B2": 33},
            "OptC": {"B2": 55},
        },
        success_conditions={"B6": dcr2},
        static_identifier_keys=["Labels"],
        result_labels={"B6": "meaningful_value"},
        save_dir=TEST_DATA_DIR / "design"
)
```

Return value (for the "example_wb.xlsx" file included in the tests directory):

```python
{
    'C01': {
        'successful_key': None, # None of the options were successful for this case
        'OptA': {'meaningful_value': 1.2121212121212122}, 
        'OptB': {'meaningful_value': 0.8080808080808081}, 
        'OptC': {'meaningful_value': 0.48484848484848486}
    }, 
    'C02': {
        'successful_key': 'OptA', 
        'meaningful_value': 2.4242424242424243
    }
}
```
wxdat 1.5.3
Weather data explorer.
Requires Python: <4,>=3.10

# wxdat #

[![PyPI](https://img.shields.io/pypi/v/wxdat.svg)](https://pypi.org/project/wxdat)
[![LICENSE](https://img.shields.io/github/license/jheddings/wxdat)](LICENSE)
[![Style](https://img.shields.io/badge/style-black-black)](https://github.com/ambv/black)

A general purpose weather data recorder & explorer.

![dashboard](docs/images/dashboard.png)

While the primary purpose of this library is to record weather data, it can also be
used as a framework for collecting weather information in other apps.

## Installation ##

Install the published package using pip:

```shell
pip3 install wxdat
```

This project uses `uv` to manage dependencies and a local virtual environment.  To
get started, clone the repository and install the dependencies with the following:

```shell
uv sync
```

## Usage ##

Run the module and tell it which config file to use.

```shell
python3 -m wxdat --config wxdat.yaml
```

If you are using `uv` to manage the virtual environment, use the following:

```shell
uv run python -m wxdat --config wxdat.yaml
```

## Configuration ##

The configuration file is a YAML document with a list of stations to export.  See the
included default file for more details.

All stations have the following configuration values:
* name - must be unique
* type - the support station type

## Supported Stations ##

Eventually, I'd like to add local stations, not just online sources.  Please see
the example configuration file for details on each provider.

* AccuWeather
* Ambient Weather Network
* OpenWeatherMap
* National Weather Service (NOAA)
* Weather Underground

## Unit Conversion ##

`wxdat` also includes a limited set of conversion helpers for working with units.  In
general, the pattern for using them is:

```python
from wxdat import units

# convert 100.0 from celsius to fahrenheit
temp = units.degC(100).degf
```

## Contributing ##

To submit a new issue, please visit the [Issues](https://github.com/jheddings/wxdat/issues)
page.

If you are unsure where to start, create a post in the
[Discussions](https://github.com/jheddings/wxdat/discussions) area.

Additionally, [Pull Requests](https://github.com/jheddings/wxdat/pulls) are welcome.
magicprof 0.0.1
Automatically instrumented python profiling
Requires Python: >=3.8

Automatically instrumented python profiling.

### Usage

```shell
env MAGICPROF=cpu.prof python <app.py> # if MAGICPROF not set, profiling is not instrumented.

# other options:
# MAGICPROF_DISABLE_SUBCALLS # set to anything to disable subcalls. see cProfile.Profile.
# MAGICPROF_DISABLE_BUILTINS # set to anything to disable subcalls. see cProfile.Profile.
```

Use a tool like [`snakeviz`](https://jiffyclub.github.io/snakeviz/) to visualize the profile.

```shell
# e.g.
snakeviz cpu.prof
```

### Install

```shell
# create python virtual environment
uv venv
uv pip install 'git+https://github.com/aaraney/magicprof@v0.0.1'
```
gentrig 0.1.2
Trigonometric functions generalized for parabolas and polygons
Requires Python: >=3.8

|               Generalized Trigonometry               |
| :--------------------------------------------------: |
| By Katherine Rose, Alexander Joseph and Joshua Piety |

<!--Add whitepaper link here when that is finished-->

# Generalized Trigonometry

Generalized Trigonometry is a python extension that provides trigonometric functions for systems other than a circle. For example, the following function draws a square:

<img src="https://latex.codecogs.com/gif.image?\inline&space;\large&space;\dpi{150}\bg{white}\text{square}(t)=\begin{cases}x=\text{cospoly}_4(t)\\y=\text{sinpoly}_4(t)\end{cases}" alt="A parametric equation square of t where x is equal to polygonal cosine 4 of t and y is equal to polygonal sine 4 of t"/>

## Functions

```py
import gentrig as gt
```

### Parabolic

```py
gt.sinp(x)
gt.cosp(x)
gt.tanp(x)
gt.cscp(x)
gt.secp(x)
gt.cotp(x)
```

Self-explanatory: Parabolic trig is similar to hyperbolic trig, but applied to a parabola instead of a hyperbola.

### Linear

```py
gt.sinl(x)
gt.cosl(x)
gt.tanl(x)
gt.cscl(x)
gt.secl(x)
gt.cotl(x)
```

Trigonometry applied to a line. This is actually equivalent to polygonal trig with 2 sides. For example:

<img src="https://latex.codecogs.com/gif.image?\inline&space;\large&space;\dpi{150}\bg{white}\text{sinl}(x)=\text{sinpoly}_2(x)" alt="linear sine of x is equal to polygonal sine 2 of x" />

However, due to implementation details the `sinl(x)` function in this library is much faster than `sinpoly(x,2)`.

### Polygonal

```py
# Where n is the number of sides
gt.sinpoly(x,n)
gt.cospoly(x,n)
gt.tanpoly(x,n)
gt.cscpoly(x,n)
gt.secpoly(x,n)
gt.cotpoly(x,n)
```

Polygonal trig is fun! You can draw regular polygons of "radius" 1 (unit polygons, perhaps) with arbitrary numbers of sides using just `sinpoly` and `cospoly`! The library won't stop you from using `sinpoly(x,n)` with when `n` is less than one or not an integer, but behavior in those cases is undefined. It's also worth noting that as n approaches infinity `sinpoly(x,n)` approaches `sin(x)`, which is pretty intuitive if you think of a circle as an infinite-sided polygon. You can plot this to get a unit polygon with n sides:

<img src="https://latex.codecogs.com/gif.image?\inline&space;\large&space;\dpi{150}\bg{white}\begin{cases}x=\text{cospoly}_n(t)\\y=\text{sinpoly}_n(t)\end{cases}" alt="A parametric equation where x is equal to polygonal cosine n of t and y is equal to polygonal sine n of t"/>

## Installing `gentrig`...

### From PyPI

`gentrig` has been released on PyPI! You can install it with `pip install gentrig` and use it like any other python library!

### From source

1. Clone this repo: `git clone https://github.com/KiARC/gentrig.git`
2. Move into the repository's directory: `cd gentrig`
3. Build and install with `pip`: `pip install .`

`gentrig` can now be imported within whichever environment's `pip` was used to install it.