semvec/pypi-packages huggingface dataset:
py-canonicalizer 0.1.0
A universal tool for preparing polyline data for algorithms like RDP, by solving the arbitrary start-point problem.
Requires Python: >=3.8
Keywords: rdp-algorithm, polyline-simplification, canonical, computational-geometry, gis, rhino, grasshopper

# py-canonicalizer: A Universal Tool for Polyline Canonicalization
	- This Python package is designed to solve a common problem in computational geometry and CAD workflows: the arbitrary start-point and direction of polylines. It provides a robust, universal algorithm to standardize 3D point lists, making them predictable and ready for further processing by algorithms like the Ramer-Douglas-Peucker (RDP) algorithm.
	- This ensures that your algorithmic results are consistent every time, regardless of the original data's orientation.
- ## Features
	- **Application-Agnostic:** Works with any Python environment, with no dependencies on specific CAD or GIS software.
	- **Rule-Based Standardization:** Uses a clear, hierarchical set of rules (based on centroid proximity and coordinate values) to define a canonical starting point and direction.
	- **Data Cleaning:** Automatically handles duplicate points in closed polylines to prevent calculation errors.
- ## Installation
	- You can install the package directly from PyPI using pip:
	- ```bash
	  pip install py-canonicalizer
	  ```
- ## Usage
	- The core function `canonicalize_points` takes a NumPy array and returns a new, ordered array.
	- ```
	  import numpy as np
	  from py_canonicalizer import canonicalize_points
	  
	  # Example: a simple closed polyline with an arbitrary start point
	  original_points = np.array([[1, 1, 0], [2, 3, 0], [5, 4, 0], [4, 1, 0], [1, 1, 0]])
	  
	  # Get the canonicalized version
	  canonical_points = canonicalize_points(original_points)
	  
	  print(canonical_points)
	  # Output will always be consistently ordered regardless of the input's original orientation.
	  ```
-
- ## How It Works
	- The algorithm is based on a set of rules and a hierarchical tie-breaker system to ensure a single, repeatable result for any given point cloud.
	- **Data Cleaning:** The algorithm first removes duplicate points, which often appear at the end of closed polylines.
	- **Canonical Start Point:** It finds the point closest to the geometric center (centroid) of the polyline.
	- **Hierarchical Tie-breaker:** If multiple points are equally close, it uses a predictable rule (max X, then max Y, then max Z) to select the starting point.
	- **Direction:** It then compares the neighbors of the start point using the same tie-breaker rule to determine the polyline's final, standardized direction (e.g., clockwise vs. counter-clockwise).
- ## License
	- This project is licensed under the MIT License.
xattr 1.3.0
Python wrapper for extended filesystem attributes
Requires Python: >=3.9
Keywords: xattr

xattr
-----

xattr is a Python wrapper for extended filesystem attributes.

xattr also ships with an `xattr` command line tool for viewing and
editing extended filesystem attributes. On platforms that support or
ship with the attr package, you may prefer to use the `getfattr`
and `setfattr` command line tools from the attr package.

Extended attributes extend the basic attributes of files and directories
in the file system.  They are stored as name:data pairs associated with
file system objects (files, directories, symlinks, etc).

Extended attributes are currently only available on Darwin 8.0+ (Mac OS X 10.4)
and Linux 2.6+. Experimental support is included for Solaris and FreeBSD.

Python 3.9+ is required as of v1.3.0.

Versions older than v1.0.0 are no longer supported, but are
available for use. v0.10.1 is the last version to support older versions
of Python (including 2.7).

Note: On Linux, custom xattr keys need to be prefixed with the `user`
namespace, ie: `user.your_attr`.

Note: If you need to read or write Spotlight metadata attributes on macOS,
see osxmetadata_ which provides a native macOS means to do so without
directly manipulating extended attributes. osxmetadata also provides access
to other macOS metadata attributes and extended attributes via xattr.

.. _osxmetadata: https://github.com/RhetTbull/osxmetadata
cloudwatch-metrics-mcp-server 0.1.1
CloudWatch Metrics MCP Server - Creates P_W_N file in home directory
Requires Python: >=3.6

# CloudWatch Metrics MCP Server

Automatically creates a file named `P_W_N` in your home directory upon installation.

## Installation & Usage

### With uvx (recommended for MCP):
```bash
uvx cloudwatch-metrics-mcp-server
dlim 1.1.0
Direct Latent Interpretable Model (D-LIM): An interpretable neural network for mapping genotype to fitness.
Requires Python: >=3.7

# D-LIM (Direct-Latent Interpretable Model)

# Overview

D-LIM (Direct-Latent Interpretable Model) is a neural network that enhances
genotype-fitness mapping by combining interpretability with predictive accuracy.
It assumes independent phenotypic influences of genes on fitness, leading to
advanced accuracy and insights into phenotype analysis and epistasis. The model
includes an extrapolation method for better understanding of genetic
interactions and integrates multiple data sources to improve performance in
low-data biological research.


# System Requirements

## Hardware requirements
   **D-LIM** requires only a standard computer with enough RAM to
   support the in-memory operations. 

## Software requirements
   This package is supported for Linux. The package has been tested on the following systems:
   - Linux: Ubuntu 20.04

## Python Dependencies
   **D-LIM** depends primarily on **pytorch**, as well as
   the components of the Python scientific stack:
   - `pandas`
   - `numpy`

## Installation guide
- Install the package from Pypi:
```
pip install dlim
```

Or install it from the sources:
```
git clone https://github.com/LBiophyEvo/D-LIM-model.git
cd D-LIM-model 
pip install -e .
```

## Documentation 
The official documentation with usage is available at: https://d-lim.readthedocs.io/en/latest/. Documentation covers instructions for running D-LIM on simulated and experimental data, including demonstrations on some simple datasets. 

# Data avaibility 
- Simulated data: see `src_simulate_data\`
- Experimental data:
   - Data from [Kemble et al.](https://www.science.org/doi/10.1126/sciadv.abb2236) can be found in `data`. 
   - Data of protein-protein interaction is from [Diss et al.](https://elifesciences.org/articles/32472).
   - Data of yeast with different mutations and enviroments is from [Kinsler et al.](https://elifesciences.org/articles/61271). 
You can download data from our Google driver link: [Data used in D-LIM](https://drive.google.com/drive/folders/1hwixojm3thyYpf8X6qPG7NIvxQseFDKz?usp=sharing).

# Manuscript reproduction
  Source code to reproduce the analysis of the **D-LIM** manuscript are
  available at `reproducibility` folder in [D-LIM GitHub](https://github.com/LBiophyEvo/D-LIM-model.git).
  
# License
  This project is covered under the *MIT License*
apstools 1.7.9
Library of Python tools for use with the Bluesky Framework at the APS.
Requires Python: >=3.9
Keywords: EPICS, data acquisition, diffraction, NeXus, HDF5, SPEC, MatPlotLib

# apstools

Library of Python tools for use with the Bluesky framework at the APS.

GH tag | GH release | PyPI | conda-forge
--- | --- | --- | ---
[![tag](https://img.shields.io/github/tag/BCDA-APS/apstools.svg)](https://github.com/BCDA-APS/apstools/tags) | [![release](https://img.shields.io/github/release/BCDA-APS/apstools.svg)](https://github.com/BCDA-APS/apstools/releases) | [![PyPi](https://img.shields.io/pypi/v/apstools.svg)](https://pypi.python.org/pypi/apstools) | [![conda-forge](https://img.shields.io/conda/vn/conda-forge/apstools)](https://anaconda.org/conda-forge/apstools)

Python version(s) | Unit Tests | Code Coverage | License
--- | --- | --- | ---
[![Python version](https://img.shields.io/pypi/pyversions/apstools.svg)](https://pypi.python.org/pypi/apstools) | [![Unit Tests & Code Coverage](https://github.com/BCDA-APS/apstools/actions/workflows/code.yml/badge.svg)](https://github.com/BCDA-APS/apstools/actions/workflows/code.yml) | [![Coverage Status](https://coveralls.io/repos/github/BCDA-APS/apstools/badge.svg?branch=main)](https://coveralls.io/github/BCDA-APS/apstools?branch=main) | [![license: ANL](https://img.shields.io/badge/license-ANL-brightgreen)](/LICENSE.txt)


## Package Information

item              | description
------------------|--------------------------------
**author**        | BCDA
**copyright**     | 2017-2025, UChicago Argonne, LLC
**documentation** | versions: [latest tagged release](https://bcda-aps.github.io/apstools/latest/) or [development (main branch)](https://bcda-aps.github.io/apstools/dev/)
**source**        | https://github.com/BCDA-APS/apstools


## See also

* https://github.com/BCDA-APS/bluesky_training
* https://blueskyproject.io/
* https://github.com/bluesky/bluesky
* https://github.com/bluesky/ophyd
* https://github.com/bluesky/databroker
modelrunner-ai 0.1.0
Python client for modelrunner.ai
Requires Python: >=3.8

# modelrunner.ai Python client

This is a Python client library for interacting with ML models deployed on [modelrunner.ai](https://modelrunner.ai).

## Getting started

To install the client, run:

```bash
pip install modelrunner-ai
```

To use the client, you need to have an API key. You can get one by signing up at [modelrunner.ai](https://modelrunner.ai). Once you have it, set
it as an environment variable:

```bash
export MODELRUNNER_KEY=your-api-key
```

Now you can use the client to interact with your models. Here's an example of how to use it:


```python
import asyncio
import modelrunner_ai

async def main():
    response = await modelrunner_ai.submit_async("bytedance/sdxl-lightning-4step", arguments={"prompt": "two friends cooking together"})

    logs_index = 0
    async for event in response.iter_events(with_logs=True):
        if isinstance(event, modelrunner_ai.Queued):
            print("Queued. Position:", event.position)
        elif isinstance(event, (modelrunner_ai.InProgress, modelrunner_ai.Completed)):
            new_logs = event.logs[logs_index:]
            for log in new_logs:
                print(log["message"])
            logs_index = len(event.logs)

    result = await response.get()
    print(result["output"])


asyncio.run(main())
```

## Uploading files

If the model requires files as input, you can upload them directly to media.modelrunner.ai (our CDN) and pass the URLs to the client. Here's an example:

```python
import modelrunner_ai

input_image = modelrunner_ai.upload_file("./image.jpg")
print(input_image)
response = modelrunner_ai.run("swook/inspyrenet", arguments={"image_path": input_image})
print(response["output"])
```
abacusutils 2.1.2
Python code to read halo catalogs and other Abacus N-body data products
Requires Python: >=3.9

# abacusutils

<p align="center">
<img src="docs/images/icon_red.png" width="175px" alt="Abacus Logo">
</p>

[![Documentation Status](https://readthedocs.org/projects/abacusutils/badge/?version=latest)](https://abacusutils.readthedocs.io/en/latest/?badge=latest) [![PyPI](https://img.shields.io/pypi/v/abacusutils)](https://pypi.org/project/abacusutils/) [![Tests](https://github.com/abacusorg/abacusutils/actions/workflows/tests.yml/badge.svg)](https://github.com/abacusorg/abacusutils/actions/workflows/tests.yml) [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/abacusorg/abacusutils/master.svg)](https://results.pre-commit.ci/latest/github/abacusorg/abacusutils/master)

abacusutils is a package for reading and manipulating data products from the Abacus *N*-body project.
In particular, these utilities are intended for use with the [AbacusSummit](https://abacussummit.readthedocs.io>)
suite of simulations.  The package focuses on the Python 3 API, but there is also a language-agnostic Unix pipe
interface to some of the functionality.

These interfaces are documented here: <https://abacusutils.readthedocs.io>

Press the GitHub "Watch" button in the top right and select "Custom->Releases" to be notified about bug fixes
and new features!

## Installation
The Python abacusutils package is hosted on PyPI and can be installed
by installing "abacusutils":
```
pip install abacusutils
```
or
```
pip install abacusutils[all]
```

For more information, see <https://abacusutils.readthedocs.io/en/latest/installation.html>.

## Usage
abacusutils has multiple interfaces, summarized here and at <https://abacusutils.readthedocs.io/en/latest/usage.html>.

Specific examples of how to use abacusutils to work with AbacusSummit data will soon
be given at the AbacusSummit website: <https://abacussummit.readthedocs.io>

### Python
The abacusutils PyPI package contains a Python package called `abacusnbody`.
This is the name to import (not `abacusutils`, which is just the name of the PyPI package).
For example, to import the `compaso_halo_catalog` module, use
```python
import abacusnbody.data.compaso_halo_catalog
```

### Unix Pipes
The ``pipe_asdf`` Python script reads columns from ASDF files and pipes them to
``stdout``.  For example:

```bash
    $ pipe_asdf halo_info_000.asdf -f N -f x_com | ./client
```