semvec/pypi-packages huggingface dataset:
bigsur 0.0.6
Basic Informatics and Gene Statistics from Unnormalized Reads, a feature selection tool for scRNAseq
Requires Python: <4,>=3.9

# BigSur
BigSur is a package for principled, robust scRNAseq normalization. Currently we can perform feature selection, see [BigSurR](https://github.com/landerlabcode/BigSurR) for correlations.

# What is BigSur?
Basic Informatics and Gene Statistics from Unnormalized Reads (BigSur) is a principled pipeline allowing for feature selection, correlation and clustering in scRNAseq.
* The feature selection derivations are detailed in [the BioRxiv preprint Dollinger et al. 2024](https://www.biorxiv.org/content/10.1101/2024.10.11.617709v1).
* The correlation are detailed in [Silkwood et al. 2023](https://doi.org/10.1186/s12859-024-05926-z).


# Installation
The easiest way to install bigsur is via pip:
    conda create -n bigsur_env python pip
    conda activate bigsur_env
    pip install bigsur

Alternatively, you can clone the GitHub repo. We've included a environment file for [conda environment installation](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#building-identical-conda-environments); the only package we require that isn't installed with scanpy is [mpmath](https://github.com/mpmath/mpmath) and [numexpr](https://github.com/pydata/numexpr). For example:

In terminal:

    cd bigsur_dir #directory to clone to

    git clone https://github.com/landerlabcode/BigSur.git

    conda create -f environment.yml -n bigsur

## A note about the virtual environment
This environment contains all packages that are required to reproduce any result of the paper. If you want a lightweight conda enviroment (or alternatively, if the environment file is causing issues), you can create a sufficient conda environment as follows:

In terminal:

    conda create -n bigsur -c conda-forge scanpy mpmath numexpr ipykernel python-igraph leidenalg

# Usage
Usage for feature selection is detailed in the [example notebook](https://github.com/landerlabcode/BigSur/blob/main/feature_selection_example_usage.ipynb). 

TL;DR:

    import sys
    
    sys.path.append(bigsur_dir) # directory where git repo was cloned
    
    from BigSur.feature_selection import mcfano_feature_selection as mcfano

Replace <code>sc.pp.highly_variable_genes(adata)</code> in your pipeline with <code>mcfano(adata, layer='counts')</code>, where the UMI counts are in <code>adata.layers['counts']</code>.

And that's it! You can read more about how to use BigSur for feature selection, and in particular how to optimize cutoffs for a given dataset, in the [example notebook](https://github.com/landerlabcode/BigSur/blob/main/feature_selection_example_usage.ipynb).
rockverse 1.2.1
Python tools for Computational Petrophysics
Requires Python: <3.13,>=3.11
Keywords: petrophysics, well, log, well log, digital rock

<img src="https://raw.githubusercontent.com/rodolfovictor/rockverse/main/docs/source/_static/RockVerse_logo_model3_for_white_background_facecolor_transparent_False.png"><br>

RockVerse: Python tools for Computational Petrophysics
======================================================

![PyPI - Python Version](https://img.shields.io/pypi/pyversions/rockverse)
[![PyPI Version](https://img.shields.io/pypi/v/rockverse.svg)](https://pypi.org/project/rockverse/)
[![conda](https://img.shields.io/conda/v/conda-forge/rockverse)](https://anaconda.org/conda-forge/rockverse)
![Conda Platform](https://img.shields.io/conda/p/conda-forge/rockverse)
[![License](https://img.shields.io/pypi/l/rockverse.svg)](https://github.com/rodolfovictor/rockverse/blob/main/LICENSE.md)



RockVerse is an open-source Python library designed to support high-performance
computational petrophysics workflows. It is optimized for large-scale simulations
and memory-intensive data processing. Leveraging state-of-the-art tools, the
library delivers optimized performance across CPU and GPU parallel computing
environments.

This project is under ongoing development as part of a post-doctoral research
initiative, and we welcome contributions, bug reports, and feature suggestions.

Documentation
-------------

Online documentation is available at [rockverse.readthedocs.io](https://rockverse.readthedocs.io),
featuring API reference, tutorials and sample gallery.

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

Follow our online [installation guide](https://rockverse.readthedocs.io/en/latest/install.html)
to get started.

Development
-----------

RockVerse is open and hosted at Github: https://github.com/rodolfovictor/rockverse

Fell free to submit bugs to the [issue tracker](https://github.com/rodolfovictor/rockverse/issues).
Please remember to include the RockVerse version and a reproducible example demonstrating the problem.

Questions
---------

For general questions consider using StackOverflow with a [rockverse tag](https://stackoverflow.com/tags/rockverse).
LinkChecker 10.6.0
check links in web documents or full websites
Requires Python: >=3.9
Keywords: checking, crawling, link, site, url, validation, verification

LinkChecker
============

|Build Status|_ |License|_

.. |Build Status| image:: https://github.com/linkchecker/linkchecker/actions/workflows/build.yml/badge.svg?branch=master
.. _Build Status: https://github.com/linkchecker/linkchecker/actions/workflows/build.yml
.. |License| image:: https://img.shields.io/badge/license-GPL2-d49a6a.svg
.. _License: https://opensource.org/licenses/GPL-2.0

Check for broken links in web sites.

Features
---------

- recursive and multithreaded checking and site crawling
- output in colored or normal text, HTML, SQL, CSV, XML or a sitemap graph in different formats
- HTTP/1.1, HTTPS, FTP, mailto: and local file links support
- restrict link checking with regular expression filters for URLs
- proxy support
- username/password authorization for HTTP and FTP
- honors robots.txt exclusion protocol
- Cookie support
- HTML5 support
- a command line and web interface
- various check plugins available

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

Python 3.9 or later is needed. Using pip to install LinkChecker:

``pip3 install linkchecker``

pipx can also be used to install LinkChecker.

The version in the pip repository may be old, to find out how to get the latest
code, plus platform-specific information and other advice see `doc/install.txt`_
in the source code archive.

.. _doc/install.txt: https://linkchecker.github.io/linkchecker/install.html


Usage
------
Execute ``linkchecker https://www.example.com``.
For other options see ``linkchecker --help``, and for more information the
manual pages `linkchecker(1)`_ and `linkcheckerrc(5)`_.

.. _linkchecker(1): https://linkchecker.github.io/linkchecker/man/linkchecker.html

.. _linkcheckerrc(5): https://linkchecker.github.io/linkchecker/man/linkcheckerrc.html

Docker usage
-------------

If you do not want to install any additional libraries/dependencies you can use
the Docker image which is published on GitHub Packages.

Example for external web site check::

  docker run --rm -it -u $(id -u):$(id -g) ghcr.io/linkchecker/linkchecker:latest --verbose https://www.example.com

Local HTML file check::

  docker run --rm -it -u $(id -u):$(id -g) -v "$PWD":/mnt ghcr.io/linkchecker/linkchecker:latest --verbose index.html

In addition to the rolling latest image, uniquely tagged images can also be found
on the `packages`_ page.

.. _packages: https://github.com/linkchecker/linkchecker/pkgs/container/linkchecker
carlson-fractional-vegetation-cover 1.0.1
Fractional Vegetation Cover (FVC) Remote Sensing Method from Carlson et al 1997 Python Package
Requires Python: >=3.10

# carlson-fractional-vegetation-cover

Fractional Vegetation Cover (FVC) Remote Sensing Method from Carlson et al 1997 Python Package

Gregory H. Halverson (they/them)<br>
[gregory.h.halverson@jpl.nasa.gov](mailto:gregory.h.halverson@jpl.nasa.gov)<br>
NASA Jet Propulsion Laboratory 329G
  

## Overview

This package provides a Python implementation of the Fractional Vegetation Cover (FVC) algorithm described by Carlson & Ripley (1997). It converts NDVI (Normalized Difference Vegetation Index) data to FVC using a linear scaling method, suitable for remote sensing applications.

## Features

- Converts NDVI to Fractional Vegetation Cover (FVC)
- Supports both NumPy arrays and `rasters.Raster` objects
- Based on peer-reviewed scientific literature

## Installation

Install via pip:

```fish
pip install carlson-fractional-vegetation-cover
```

## Usage

```python
import numpy as np
from carlson_fractional_vegetation_cover import carlson_fractional_vegetation_cover

# Example NDVI array
NDVI = np.array([[0.1, 0.3, 0.5], [0.04, 0.52, 0.25]])
FVC = carlson_fractional_vegetation_cover(NDVI)
print(FVC)
```

## Algorithm

The algorithm linearly scales NDVI values between two reference points:

- NDVIv (full vegetation): 0.52 ± 0.03
- NDVIs (bare soil): 0.04 ± 0.03

The formula:

```
FVC = clip((NDVI - NDVIs) / (NDVIv - NDVIs), 0.0, 1.0)
```

Values below NDVIs are set to 0 (bare soil), above NDVIv to 1 (full vegetation), and in between are linearly scaled.

## References

- Carlson, T.N., & Ripley, D.A. (1997). On the relation between NDVI, fractional vegetation cover, and leaf area index. Remote Sensing of Environment, 62(3), 241-252. [https://doi.org/10.1016/S0034-4257(97)00104-1](https://doi.org/10.1016/S0034-4257(97)00104-1)

## License

See LICENSE file for details.
pyobjectscript-gen 1.0
Objectscript class code generation library for Python
Requires Python: >=3.9
Keywords: cls, code generation, intersystems, iris, objectscript

# PyObjectscript Gen

Objectscript class code generation library for Python

---

## Features

- Objectscript class code generation 
- Clean and simple to use interface in python
- Extensible classes for custom usage

---

## Installation

You can install the package using pip:

```shell
pip install pyobjectscript_gen
````

Or from source:

```shell
git clone https://github.com/Antoine-dh/pyobjectscript_gen.git
pip install .
```

---

## Usage

Here's a basic example of how to use the library:

```python
from pyobjectscript_gen.cls import *

cls = Class(
    name="Demo.MyExample.MyClass",
    extends=["%RegisteredObject"]
)

# example of declaratively creating properties
cls.components = [
    Property(
        name="Property1",
        type="%String",
    ),
    Property(
        name="Property2",
        type="%Numeric",
    ),
]

# example of iteratively creating a method
method = Method("MyMethod")
method.return_type = "%String"
method.impl = [
    "set returnvalue=..Property1_..Property2",
    "quit returnvalue"
]

# append method to class components
cls.components.append(method)

# generate on sys.stdout
cls.generate()
```

See the generated class in `examples/generated/basic.cls`

---

## Requirements

* Python 3.9+
* Jinja2

---

## Documentation

You can find the full documentation at: [Read the docs](https://pyobjectscript-gen.readthedocs.io/en/latest/)

All the documentation can also be found in code with python docstrings in `src/pyobjectscript_gen/cls.py`

---

## Running Examples

All examples code can be found in `examples/` and their respective output classes in `examples/generated/`

```bash
# Basic class example with 2 properties and a method
python3 -m examples.basic > basic.cls

# Test class for every features capable to be generated by the library
python3 -m examples.features > features.cls

# Real life example of multiple classes generation using custom subclasses of the library's components
# Generates a simple REST example with a business operation, request and response classes in the specified directory
mkdir output/
python3 -m examples.rest ./output/
```

More examples to come...

---

## Contributing

Contributions are welcome!

To get started:

```bash
git clone https://github.com/Antoine-dh/pyobjectscript_gen.git
python -m venv .venv
source .venv/bin/activate  # On Windows, use .venv\bin\activate.bat
pip install -r requirements.txt
```

---

## License

This project is licensed under the [GNU General Public License](https://www.gnu.org/licenses/gpl-3.0.txt).
cyquantx 1.1.0
cython dimensional analysis and unit tracking utility
Requires Python: >=3.9
Keywords: c-extension, SI, units, quantities, dimensional analysis

cyquant
=======

simple, efficient dimensional analysis

## basics

```python
from cyquant import si, SIUnit

miles = SIUnit(1609.344) * si.meters
marathon_miles = 26 * miles
marathon_miles.quantity  # 26

marathon_meters = marathon_miles.cvt_to(si.meters)
marathon_meters.quantity  # 41842.944
marathon_meters.get_as(miles)  # 26
marathon_meters.get_as(si.newton_meters)  # ValueError
marathon_miles == marathon_meters  # True
```

## approximation & tolerances

```python
# absolute tolerance
marathon_miles.a_approx(marathon_meters, atol=1e-9)  # True

# relative tolerance
marathon_miles.r_approx(marathon_meters, rtol=1e-9)  # True

# quantity tolerance
marathon_miles.q_approx(marathon_meters, qtol=1 * si.millimeters)
```

## normalized string output

```python
from cyquant.format_quantity import show_quantity
show_quantity(marathon_miles)  # 4.184e+04 m
```

## with attrs

```python
from cyquant import si, converter
from cyquant import Quantity as Q
from attrs import define, field

@define
class Foo:
    mass: Q = field(converter=converter(si.kilograms, promotes=True))
    size: Q = field(converter=converter(si.meters ** 3))

    def liters(self):
        return self.size.get_as(si.liters)

foo1 = Foo(mass=10, size=1 * si.meters ** 3)
foo2 = Foo(mass=10 * si.kilograms, size=1000000000 * si.millimeters ** 3)
assert foo1 == foo2

foo3 = Foo(mass=10, size=10) # TypeError
```
voitta 0.28.0
A Python framework for LLM tool calls routing, automation, and orchestration

# Voitta

[![PyPI version](https://img.shields.io/pypi/v/voitta.svg)](https://pypi.org/project/voitta/)
[![Python Versions](https://img.shields.io/pypi/pyversions/voitta.svg)](https://pypi.org/project/voitta/)
[![Downloads](https://static.pepy.tech/badge/voitta/month)](https://pepy.tech/project/voitta)
[![License](https://img.shields.io/github/license/voitta-ai/voitta)](https://github.com/voitta-ai/voitta/blob/main/LICENSE)
[![GitHub Stars](https://img.shields.io/github/stars/voitta-ai/voitta.svg)](https://github.com/voitta-ai/voitta/stargazers)

<!-- These badges will appear on both GitHub and PyPI pages since this README is used as the long description for PyPI -->

A Python framework for routing, automating, and orchestrating LLM tool calls. Voitta simplifies the integration of AI agents with external tools and APIs, enabling more powerful and flexible AI applications.

## Features

- **Tool Call Routing**: Seamlessly route LLM tool calls to the appropriate handlers
- **Flexible Configuration**: Define your tools and routing logic using YAML or Python
- **Framework Agnostic**: Works with any LLM provider or framework
- **Extensible Architecture**: Easily add custom tools and integrations
- **Observability**: Monitor and debug tool calls with built-in logging

## Installation

### From PyPI (Stable Release)

```bash
pip install voitta
```

### From TestPyPI (Pre-release Versions)

To install the latest pre-release version from TestPyPI:

```bash
pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ voitta
```

The `--extra-index-url` flag is needed to fetch dependencies from the main PyPI repository, as TestPyPI may not have all the required dependencies.

You can also specify a particular version:

```bash
pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ voitta==0.2.3
```

Note: Pre-release versions on TestPyPI may contain experimental features and bugs. Use in production environments at your own risk.

## Quick Start

```python
from voitta import Voitta

# Initialize Voitta
voitta = Voitta()

# Register a tool handler
@voitta.tool("get_weather")
def get_weather(location, unit="celsius"):
    # Implementation to fetch weather data
    return {"temperature": 22, "condition": "sunny", "location": location, "unit": unit}

# Process an LLM tool call
result = voitta.process_tool_call({
    "name": "get_weather",
    "arguments": {"location": "San Francisco", "unit": "fahrenheit"}
})

print(result)  # Output: {"temperature": 72, "condition": "sunny", "location": "San Francisco", "unit": "fahrenheit"}
```

## Usage

For detailed usage examples and documentation, please refer to:
- [Voitta Example Repository](https://github.com/voitta-ai/voitta-example)
- [Voitta Official Website](https://voitta.com)
- [Voitta on PyPI](https://pypi.org/project/voitta/)

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.