semvec/pypi-packages huggingface dataset:
UALF-dataframe-parser 0.0.1
Python class that allows for a python requests response received in the universal ascii lightning format to be parsed to a pandas dataframe object.
Requires Python: >=3.6

# Data Parser for Universal ascii lightning format âš¡
<br>
Python class that allows for a python requests response received in the universal ascii lightning format to be parsed to a pandas dataframe object.
<br><br>

Publicly available lightning data though MET Norway and Swedish SMHI are returned in the universal ascii lightning format. <br>The purpose of this Python project is to easily parse that data into a pandas dataframe (and numpy array).
<br>

A visualisation of the format can be found on MET Norway's Frost API resource pages:

![ualf](https://frost.met.no/images/concepts/UALF_format.png)
aracnid_api 1.5.0
A simple customization of the Python Logging System.
Requires Python: ~=3.8
Keywords: api

# Aracnid API

This package contains custom wrappers around a variety of Web App APIs.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

### Prerequisites

This package supports the following version of Python:

- Python 3.8 or later

### Installing

Install the latest package using pip. (We prefer pipenv.)

```
$ pip install aracnid-api
```

End with an example of getting some data out of the system or using it for a little demo

## Running the tests

Explain how to run the automated tests for this system

```
$ python -m pytest
```

## Usage

TODO

## Authors

- **Jason Romano** - [Aracnid](https://github.com/aracnid)

See also the list of [contributors](https://github.com/lakeannebrewhouse/aracnid-logger/contributors) who participated in this project.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
introspector 0.2.1a0
Introduce strict typing in your functions.
Requires Python: >=3.10

# Introspector

[WIP] A Python library to write strongly typed code.

## Table of contents
- [Introspector](#introspector)
  - [Table of contents](#table-of-contents)
  - [Introduction](#introduction)
  - [Requirements](#requirements)
  - [Basic usage](#basic-usage)
  - [Python 3.10 supported typing syntax](#python-310-supported-typing-syntax)
  - [Instrospector.strict available options](#instrospectorstrict-available-options)
    - [:arrow_right: ignore](#arrow_right-ignore)

## Introduction

Introduce strict typing in your functions.  
This project is under development. 

## Requirements

- Python >= 3.10

## Basic usage

```py
import introspector

@introspector.strict
def foo(a: int, b: list[dict[str, Any]]) -> list[int]:
    # Some funny code...

    return [1, 2, 3, 4]

foo(
    42, 
    [
        {
            'x': ['hello', 'world'],
            'y': 3.14,
        },
    ],
)
```

When the code is executed, the `instrospector.strict` decorator will inspect the signature of the `foo` function and compare it with the values passed in its parameters.  
If the typing of the values does not match the signature of the function, introspector will throw a `TypeError` exception.

## Python 3.10 supported typing syntax

This paclage support the following typing syntaxes:

| Name          | Description                    | Example        |
| ------------- | ------------------------------ | -------------- |
| `\|` operator | The Union type shortcut syntax | `int \| float` |

## Instrospector.strict available options

### :arrow_right: ignore

A list of parameter names that will be excluded from the typing control.  
Notice that the `ignore` option will always contains `self` and `cls`.

**Example:**

```py
@instrospector.strict(ignore=['b'])
def foo(a: int, b: float) -> None:
    ...
```

The argument `b` will be ignored by the typing control.
UAFL-dataframe-parser 0.0.1
Python class that allows for a python requests response received in the universal ascii lightning format to be parsed to a pandas dataframe object.
Requires Python: >=3.6

# Data Parser for Universal ascii lightning format âš¡
<br>
Python class that allows for a python requests response received in the universal ascii lightning format to be parsed to a pandas dataframe object.
<br><br>

Publicly available lightning data though MET Norway and Swedish SMHI are returned in the universal ascii lightning format. <br>The purpose of this Python project is to easily parse that data into a pandas dataframe (and numpy array).
<br>

A visualisation of the format can be found on MET Norway's Frost API resource pages:

![ualf](https://frost.met.no/images/concepts/UALF_format.png)
censuscoding 0.1.0
Censuscoding: determine the Census blockgroup for a street address
Requires Python: >=3.7,<3.10

# censuscoding

<!-- badges: start -->
![](https://github.com/ripl-org/censuscoding/actions/workflows/censuscoding.yml/badge.svg)
<!-- badges: end -->

`censuscoding` is a self-contained tool for determining the Census 
blockgroup for a street address. It is developed by
[Research Improving People's Lives (RIPL)](https://ripl.org).

## Installation

Due to outstanding bugs in dependencies introduced in Python 3.10.0,
`censuscoding` requires Python >=3.7 and <3.10.

To install from PyPI using **pip**:  
`pip install censuscoding`

To install a **development version** from the current directory:  
`pip install -e .`

## Running
There is a single command line script included, `censuscoding`.

`censuscoding` supports the following arguments:
* `--input` or `-i` - path to an input CSV file containing columns `record_id`, `zip_code`, and `address`
* `--output` or `-o` - path to output CSV file containing `record_id`, `zip_code`, `blkgrp`
* `--record_id` - field name corresponding to the record ID (default: 'record_id')
* `--zip_code` - field name corresponding to the zip code (default: 'zip_code')
* `--address` - field name corresponding to the street address with street name and number (default: 'address')

## Contributors
* [Mark Howison](https://mark.howison.org/)
* [Daniel Molitor](https://dmolitor.github.io)

## License

`censuscoding` is freely available for non-commercial use under the license provided in [LICENSE](https://github.com/ripl-org/censuscoding/blob/main/LICENSE).
To inquiry about commercial use, please contact [connect@ripl.org](mailto:connect@ripl.org).

## Data

Data included in the `censuscoding` package were derived from the following sources:

### Rhode Island Geographic Information System E911 Site/Structure Address Points

Version [e911Sites21r1](https://www.arcgis.com/sharing/rest/content/items/2d9f7e30ef904317b29f735723127c94/info/metadata/metadata.xml?format=default&output=html).

> These data are designed and maintained for RI E 9-1-1 mapping software. They are not intended for any other purpose. This dataset is provided 'as is.â€™ The producer(s) of this dataset, contributors to this dataset, the Rhode Island Geographic Information System (RIGIS) consortium, the State of Rhode Island, and the University of Rhode Island do not make any warranties of any kind for this dataset, and are not liable for any loss or damage however and whenever caused by any use of this dataset. Please acknowledge both RIGIS and the primary producer(s) of this dataset in any derived products. Versions of the RIGIS logo suitable for both printed and web-based products are available at https://www.rigis.org.

### US Census Bureau TIGER/Line Shapefiles

Version [2020](https://www.census.gov/geographies/mapping-files/time-series/geo/tiger-line-file.2020.html).
kimiko 0.0.7
Standard way for interacting with Kimiko
Requires Python: >=3.9

# Kimiko

A standard way for interacting with Kimiko

## Instructions

1. Install

```
pip install kimiko
```

2. Import Client

```
from kimiko import Objects
ob = Objects(<account_id>, <api_key>)
```

3. Use Kimko

```
objects = ob.objects()
records = ob.records(<object_type>)
```
mv-laplace 0.1.1
Multivariate Laplace Distribution Sampler
Requires Python: >=3.10, <4

# Multivariate Laplace Distribution
A sampler package from a Multivariate Laplace distrbrution.

## Background
I've been exploring Quantitative Finance for awhile now, and one frustrating point is the lack of a good sampler for a Multivariate Laplace distribution. As such I re-purposed a multivariate normal, normal, and Laplace distribution to fill the role of a multivariate Laplace. This isn't a fully implemented scipy-like class, similar to my [PertDist package](https://pypi.org/project/pertdist/), but just enough for me to spin up a custom MCMC routine and do some proper financial modeling.

## Installation
This package is on PyPi, and can be installed using `pip install mv-laplace`

## Usage
Unlike the scipy implementations this is based on, this distribution class provides sampling abilities only and no distributional parameters. The package is pretty straightforward to use:

```
from mv_laplace import MvLaplaceSampler

sampler = MvLaplaceSampler(loc, cov)
samples = sampler.sample(sample_size)
```

The input should be a pair of arrays, the first of which containing the location values (the means) in a vector of length M, and the second containing the covariance matrix in a MxM matrix. The return will be a NxM matrix, with N being the `sample_size` input on the sampler. I used [Wikipedia](https://en.wikipedia.org/wiki/Multivariate_Laplace_distribution) for basic reference on terminology.

## Disclaimer
I provide no guarentees that this package fits proper statistical robustness of how a multivariate Laplace is supposed to work, just that it seems to work for the use case I have identified. Use at your own risk.

## Roadmap
* Figure out how to calculate summary information, and refactor API to a scipi-like interface
* Add a Multivariate Asymmetric Laplace distribution class

## [Version History](./VersionHistory.md)

## License
This project uses the GNU General Public License.

Short version: Have fun and use it for whatever, just make sure to attribute me for it (-: