semvec/pypi-packages huggingface dataset:
sbrscrape 0.0.10
Scrape odds data from sbrodds
Requires Python: >=3.5

# sbrscrape

Python script to scrape sports betting odds data from sbrodds.

```python
from sbrscrape import Scoreboard
games = Scoreboard(sport="NFL").games
games[0]
{
    "date": "2023-01-08T18:00:00+00:00",
    "status": "13:00 ET",
    "home_team": "Atlanta Falcons",
    "home_team_loc": "Atlanta",
    "home_team_abbr": "ATL",
    "home_team_rank": -1,
    "away_team": "Tampa Bay Buccaneers",
    "away_team_loc": "Tampa Bay",
    "away_team_abbr": "TB",
    "away_team_rank": -1,
    "home_score": 0,
    "away_score": 0,
    "home_spread": {
        "betmgm": -4,
        "draftkings": -4,
        "fanduel": -4.5,
        "caesars": -4,
        "pointsbet": -4,
        "wynn": -4,
        "bet_rivers_ny": -4
    },
    "home_spread_odds": {
        "betmgm": -110,
        "draftkings": -110,
        "fanduel": -104,
        "caesars": -110,
        "pointsbet": -110,
        "wynn": -110,
        "bet_rivers_ny": -113
    },
    "away_spread": {
        "betmgm": 4,
        "draftkings": 4,
        "fanduel": 4.5,
        "caesars": 4,
        "pointsbet": 4,
        "wynn": 4,
        "bet_rivers_ny": 4
    },
    "away_spread_odds": {
        "betmgm": -110,
        "draftkings": -110,
        "fanduel": -118,
        "caesars": -110,
        "pointsbet": -110,
        "wynn": -110,
        "bet_rivers_ny": -110
    },
    "under_odds": {
        "betmgm": -110,
        "draftkings": -110,
        "fanduel": -110,
        "caesars": -110,
        "pointsbet": -110,
        "wynn": -110,
        "bet_rivers_ny": -112
    },
    "over_odds": {
        "betmgm": -110,
        "draftkings": -110,
        "fanduel": -110,
        "caesars": -110,
        "pointsbet": -110,
        "wynn": -110,
        "bet_rivers_ny": -112
    },
    "total": {
        "betmgm": 40.5,
        "draftkings": 40.5,
        "fanduel": 40.5,
        "caesars": 40,
        "pointsbet": 40.5,
        "wynn": 40.5,
        "bet_rivers_ny": 40.5
    },
    "home_ml": {
        "betmgm": -200,
        "draftkings": -195,
        "fanduel": -194,
        "caesars": -196,
        "pointsbet": -210,
        "wynn": -204,
        "bet_rivers_ny": -200
    },
    "away_ml": {
        "betmgm": 165,
        "draftkings": 165,
        "fanduel": 164,
        "caesars": 162,
        "pointsbet": 175,
        "wynn": 170,
        "bet_rivers_ny": 175
    }
}
```
streamlit-mnist-canvas 0.1.1
A Streamlit component tailored for handwriting digit recognition using the MNIST dataset. This component allows users to draw digits on a canvas, facilitating integration with various machine learning models for digit recognition. It's ideal for educational, development, and testing purposes within Streamlit applications.
Requires Python: >=3.9

# Streamlit MNIST Canvas

## Overview

This repository provides a Streamlit component, `st_mnist_canvas`, designed for creating and recognizing handwritten digits. It's a perfect tool for educational purposes, machine learning model testing, and demonstrations.

## Installation

To install Streamlit Oekaki, run the following command:

```bash
pip install streamlit-mnist-canvas
```

## Usage

`st_mnist_canvas` enables users to draw digits in a Streamlit app. The digit can then be displayed and processed, making it highly effective for use with MNIST-trained digit recognition models.

### Example
Here's how to get started with st_mnist_canvas:
```python
import streamlit as st
from streamlit_mnist_canvas import st_mnist_canvas
import numpy as np

st.subheader("Input")
result = st_mnist_canvas()

if result.is_submitted:
    st.write("Output")
    st.image(result.resized_grayscale_array, caption="Grayscale 28x28 Image")

    # Prepare the image for ML model prediction
    # image_for_prediction = np.expand_dims(result.resized_grayscale_array, axis=0)

    # Predict digit using a machine learning model
    # Example: prediction = model.predict(image_for_prediction)
    # st.write("Predicted Digit:", prediction)
```

Integrating with Machine Learning Models  
`st_mnist_canvas` can be directly integrated with ML models, especially those trained on the MNIST dataset. Once a digit is drawn and submitted, the image data, formatted as a 28x28 grayscale array, is ready for input into a pre-trained model. This allows for real-time digit recognition and analysis within your Streamlit app.

![Demo](demo.gif)

## License
This project is licensed under the MIT License - see the LICENSE file for details.
nestargs 1.1.0
Nested arguments parser
Requires Python: >=3.8
Keywords: argparse,arguments,cli,command,interface,line,parser

# nestargs

*nestargs* is a Python library that treats command line arguments as a hierarchical structure. The functionality for interpreting command line arguments is the same as argparse.

[![PyPI](https://img.shields.io/pypi/v/nestargs)](https://pypi.org/project/nestargs/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/nestargs)](https://pypi.org/project/nestargs/)
[![Python Tests](https://github.com/speg03/nestargs/actions/workflows/python-tests.yml/badge.svg)](https://github.com/speg03/nestargs/actions/workflows/python-tests.yml)
[![codecov](https://codecov.io/gh/speg03/nestargs/graph/badge.svg?token=mOzO3kbpDl)](https://codecov.io/gh/speg03/nestargs)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/speg03/nestargs/main.svg)](https://results.pre-commit.ci/latest/github/speg03/nestargs/main)

## Installation

```
pip install nestargs
```

## Basic usage

When defining command line arguments, use "." as the delimiter. to represent a variable hierarchy. The following code example defines an `n` and `price` variable in the `apple` hierarchy and another separate `n` and `price` variable in the `banana` hierarchy.

```python
import nestargs

parser = nestargs.NestedArgumentParser()

parser.add_argument("--apple.n", type=int)
parser.add_argument("--apple.price", type=float)

parser.add_argument("--banana.n", type=int)
parser.add_argument("--banana.price", type=float)

args = parser.parse_args(
    ["--apple.n=2", "--apple.price=1.5", "--banana.n=3", "--banana.price=3.5"]
)
# => _NestedNamespace(apple=_NestedNamespace(n=2, price=1.5), banana=_NestedNamespace(n=3, price=3.5))
```

Variables obtained by parsing command line arguments can be referenced by hierarchy.

```python
args.apple
# => _NestedNamespace(n=2, price=1.5)
```

Of course, you can also refer directly to variables lower down in the hierarchy.

```python
args.apple.price
# => 1.5
```

When referring to each level of hierarchy, you can use `vars` to create a dictionary format.

```python
vars(args.apple)
# => {'n': 2, 'price': 1.5}
```

## Use a different delimiter for namespace

The default namespace delimiter is "." but can be any other character. In that case, specify the delimiter in the `NestedArgumentParser` constructor argument.

```python
import nestargs

parser = nestargs.NestedArgumentParser(delimiter="/")
parser.add_argument("--apple/n", type=int)

args = parser.parse_args(["--apple/n=1"])
# => _NestedNamespace(apple=_NestedNamespace(n=1))
```

However, references to variables must be separated by "." delimiter when referring to variables.

```python
args.apple.n
# => 1
```
ms-ovba-compression 1.0.0
Compress and decompress Microsoft Office VBA data streams.
Requires Python: >=3.7

[![Coverage Status](https://coveralls.io/repos/github/Beakerboy/MS-OVBA-Compression/badge.png?branch=main)](https://coveralls.io/github/Beakerboy/MS-OVBA-Compression?branch=main) ![Build Status](https://github.com/Beakerboy/MS-OVBA-Compression/actions/workflows/python-package.yml/badge.svg)
# MS-OVBA-Compression

Compress or decompress data streams using the MS-OVBA compression algorithm

Microsoft Office files are zip archives that contain a variety of files that work together. One of these files is vbaProject.bin, a binary OLE container which includes
any VBA source code in the project. The VBA sources are compressed using the MS-OVBA compression algorithm.

It's worth noting that the compressed output may differ between this and a Microsoft Office applcation. The way the compression algorithm works, multiple valid
compressed byte seqences are able to be decompressed into the same uncompressed stream. This project follows the algorithm documented in the 
[MS-OVBA specification](https://interoperability.blob.core.windows.net/files/MS-OVBA/%5bMS-OVBA%5d.pdf), while one of the test cases has a compressed container
that is slightly different than is produced using it's own documented procedure.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install MS_OVBA_Compression.

```bash
pip install ms_ovba_compression
```

## Usage
All inputs and outputs are bytes objects. This library does not operate on files, but on compressed or uncompressed byte streams. Any raw VBA files require a certain
amount of normalization before compression. If you are interested in writing or modifying the whole OLE container, refer to
[Beakerboy/vbaProject-Compiler](https://github.com/Beakerboy/vbaProject-Compiler).

```python
from ms_ovba_compression.ms_ovba import MsOvba

# returns b'\x01\x19°\x00abcdefgh\x00ijklmnop\x00qrstuv.'
input = b'abcdefghijklmnopqrstuv.'
ms_ovba = MsOvba()
ms_ovba.compress(input)

# returns b'#aaabcdefaaaaghijaaaaaklaaamnopqaaaaaaaaaaaarstuvwxyzaaa'
ms_ovba = MsOvba()
compressed = b'\x01/°\x00#aaabcde²f\x00paghij\x018\x08akl\x000mnop\x06q\x02p\x04\x10rstuv\x10wxyz\x00<'
ms_ovba.decompress(compressed)

```
The objects can be initialized to indicate the endianness if the default little-endian is not desired.
```python
# returns b'\x01°\x19\x00abcdefgh\x00ijklmnop\x00qrstuv.'
input = b'abcdefghijklmnopqrstuv.'
ms_ovba = MsOvba("big")
ms_ovba.compress(input)

```

## Contributing

Pull requests are welcome. For major changes, please open an issue first
to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License

[MIT](https://choosealicense.com/licenses/mit/)