semvec/pypi-packages huggingface dataset:
outcome-tb 0.0.1
A simple package for the outcome data type
Requires Python: >=3.8

# Outcome Package

This is a simple package for the outcome data type which includes the outcomes name, its value, and its probability which can be found in probability-tb. 

# Importing

You can import the outcome package by:
``` 
from outcome_tb import outcome
```

# Using Outcome

You can use the outcome type using:
```
from probability import probability

o = Outcome("outcome1", float(5), probability.Probability(.5))

print(o.outcome_name, o.outcome_value, o.outcome_probability.value)
```
which will have the values o.outcome_name => "outcome1", o.outcome_value => 5.0, outcome.outcome_probabilty.value => .5.
dolvins 0.0.6
Dolvin's Math and Stats Library
Keywords: python, distributions, probability, linear algebra, statistics, mathematics


# Dolvins



This project provides a set of functions and classes for optimization, probability, and statistical analysis, with a focus on handling multi-dimensional data, hyperplanes, and distribution analysis.

<br/>



## Table of Contents



- [Installation](#installation)

- [Usage](#usage)

- [Examples](#examples)

- [License](#license)

  <br/>



## Installation



Dolvins is built on the following packages:



- `psutil`

- `numpy`

- `pandas`

- `tqdm`

- `scipy`

- `mpmath`



To install Dolvins automatically with all its dependencies, please run:



```

pip install dolvins

```



<br/>



## Usage



Coming Soon



## License



This project is licensed under the MIT License.



This README file provides detailed documentation for each function and class, including arguments, return values, and example usage. You can adjust the details based on your specific project and needs.



> Written with [StackEdit](https://stackedit.io/).
poly-validator 0.1.0
GA tool for validating geospatial data with topology checks, coordinate system validation, and more.
Requires Python: >=3.11

# Geospatial-Data-Validation-Tool

[![Python: 3.11](https://img.shields.io/badge/Python-3.11-blue?style=for-the-badge)](https://www.python.org/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)


## Overview

The Geospatial Data Validation Tool is designed to facilitate the validation and verification of geospatial datasets. This tool helps ensure the quality and consistency of geospatial data through various checks and validations. It supports common geospatial formats such as Shapefiles and GeoJSON.

## Features

1. **Topology Checks**
   - Detect overlapping polygons, gaps, or slivers.
   - Check for self-intersecting geometries.

2. **Coordinate System Validation**
   - Verify that datasets use consistent coordinate reference systems (CRS).
   - Offer automatic re-projection options.

3. **Data Completeness**
   - Identify missing attributes or incomplete records.
   - Validate attribute data types and value ranges.

4. **Error Reporting**
   - Generate detailed reports with visualizations of detected issues.
   - Provide recommendations for fixing errors.

5. **Input/Output Formats**
   - Support for common geospatial formats including Shapefiles, GeoJSON, and others.

## Installation

To install the tool, clone this repository and install the required dependencies using pip:

```bash
git clone https://github.com/yourusername/Geospatial-Data-Validation-Tool.git
cd Geospatial-Data-Validation-Tool

conda env create -f environment.yml
conda activate geovalidator

```

## Usage

### Load and Validate Geospatial Data

To load a GeoJSON file and perform validations, use the following script:

```python
import geopandas as gpd
from geovalidator.validators.topology import detect_overlaps, detect_gaps, detect_slivers, check_self_intersection

# Load the GeoJSON file
file_path = 'path/to/your/file.geojson'
gdf = gpd.read_file(file_path)

# Apply validation functions
overlapping_polygons = detect_overlaps(gdf)
gaps = detect_gaps(gdf)
slivers = detect_slivers(gdf, area_threshold=0.01)  # Adjust area_threshold as needed
self_intersections = check_self_intersection(gdf)

# Print results
print("Overlapping Polygons:")
print(overlapping_polygons)

print("\nGaps:")
print(gaps)

print("\nSlivers:")
print(slivers)

print("\nSelf-Intersecting Geometries:")
print(self_intersections)

```

## Contact

### Software Developer

- [Billy Ashmall](https://github.com/billyz313)



## License and Distribution

Geospatial-Data-Validation-Tool is distributed by BillyZ under the terms of the {type of license you choose} License. See
[LICENSE](LICENSE) in this directory for more information.

## Privacy & Terms of Use

Geospatial-Data-Validation-Tool abides to all of BillyZ's privacy and terms of use as described
at [https://ashmall.com/Privacy-Terms-of-Use.html](https://ashmall.com/Privacy-Terms-of-Use.html).
RedcapLite 1.0.0
A Lightweight Python Client for REDCap
Requires Python: >=3.8

# RedcapLite

`RedcapLite` is a Python package for interacting with the REDCap API. This package provides methods to interact with different API endpoints in a straightforward way.

## Installation

To install the package, clone the repository and install it using `pip`:

```sh
git clone https://github.com/jubilee2/RedcapLite.git
cd RedcapLite
pip install .
```

## Usage

### Importing the Package

To use the `RedcapLite` package, import it in your Python script:

```python
import RedcapLite
```

### Creating an Instance

Create an instance of the `RedcapClient` class by providing the API URL and token:

```python
r = RedcapLite.RedcapClient('https://redcap.vumc.org/api/', 'your_token')
```

### Methods

#### `get_arms()`

Retrieve the list of arms from the REDCap API.

```python
arms = r.get_arms()
print(arms)
```

#### `delete_arms(arms)`

Delete the specified arms. Provide a list of arm IDs to delete.

```python
r.delete_arms(arms=[3])
```

### Example

Here’s a complete example of how to use the `RedcapLite` package:

```python
import RedcapLite

# Create an instance of RedcapClient
r = RedcapLite.RedcapClient('https://redcap.vumc.org/api/', 'your_token')

# Get arms
arms = r.get_arms()
print("Arms:", arms)

# Delete specific arms
r.delete_arms(arms=[3])
print("Arm 3 deleted successfully.")
```

### Contributing

If you would like to contribute to the project, please fork the repository, make your changes, and submit a pull request.

### License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
prefscript 1.1
Partial Recursive Functions for Scripting
Requires Python: >=3.10

# PReFScript: 
## Partial Recursive Functions for Scripting

Author: Jose L Balcazar, ORCID 0000-0003-4248-4528

Project started: mid Germinal 2003.

Current version: 1.1, late Thermidor 2024.

Copyleft: MIT License (https://en.wikipedia.org/wiki/MIT_License)

A Python-based environment to explore and experiment with partial 
recursive functions; naturally doubles as a (purely functional) 
programming language, but it is not intended to be used much as such.

### Scripts

In PReFScript, a script is a sequence of functions defined in terms of each
other and of a few basic functions via the partial recursion rules 
of composition and minimization. All functions are from the
natural numbers into the natural numbers and may be undefined
for some inputs. In order to handle tuples or sequences of natural
numbers, a Cantor-like encoding is used.
The always available basic functions include: 
`k_1`, the constant 1 function;
`id`, the identity function;
addition and multiplication, `add` and `mul` respectively,
that interpret the single number received as the Cantor encoding
of a pair `<x.y>` and compute the corresponding operation on `x` and 
`y`; modified difference `diff` that receives likewise a Cantor-encoded
pair  `<x.y>` and computes `max(0, x - y)` so that we always stay
within the natural numbers; and two functions related to projections
of Cantor-encoded sequences.

Scripts are maintained in objects of the class PReFScript,
that can be imported into your own Python program. 
Alternatively, a stand-alone interpreter is also provided. 
Thus, you have available two main ways of programming in PReFScript.

### Installation and ways to use PReFScript functions

See [doc.md](https://github.com/balqui/prefscript/blob/main/docs/doc.md) 
for all the details (somewhat incomplete as of today).