semvec/pypi-packages huggingface dataset:
hockey-scraper-by-max 0.0.1.dev89
A comprehensive Python package for scraping hockey data
Requires Python: >=3.10
Keywords: nhl, hockey, sports, data, api, espn, scraping, analytics

<!-- README.md -->
# Hockey Scraper 🏒

A comprehensive Python package for scraping NHL hockey data with built-in analytics capabilities.

## Features

- **Complete Game Data**: Scrape play-by-play, shifts, rosters, and team statistics
- **Advanced Analytics**: Built-in functions for Corsi, Fenwick, TOI analysis, and more
- **Multiple Data Sources**: Support for NHL API and HTML sources
- **Flexible Output**: Export to pandas, polars, JSON, or CSV formats
- **Async Support**: Fast concurrent data collection
- **Easy to Use**: Simple API with powerful customization options

## Installation

```bash
pip install hockey-scraper
```

## Quick Start

```python
import hockey_scraper as hs

# Scrape team data
teams = hs.scrape_teams()

# Get game data with shifts
df, shifts = await hs.scrape_game_(2024020920, include_shifts=True)

# Build analytics matrix
matrix_df = hs.seconds_matrix(df, shifts)
strengths_df = hs.strengths_by_second(matrix_df)

# Get TOI analysis
toi_stats = hs.toi_by_strength_all(matrix_df, strengths_df)
```


## License

MIT License - see LICENSE file for details.

# LICENSE
MIT License

Copyright (c) 2024 Max Tixador

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

---

**Made with ❤️ for hockey analytics**
civic-transparency-spec 0.2.1
Civic Transparency specification schemas
Requires Python: >=3.11
Keywords: civic, transparency, jsonschema, specification

# Civic Transparency Schemas (README.md)

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)

> JSON Schema definitions for privacy-preserving social media transparency APIs.

## Schemas

| Schema | Purpose | Status |
|--------|---------|--------|
| [`provenance_tag.schema.json`](./src/ci/transparency/spec/schemas/provenance_tag.schema.json) | Per-post behavioral metadata | Draft |
| [`series.schema.json`](./src/ci/transparency/spec/schemas/series.schema.json) | Aggregated time series API responses | Draft |
| [`transparency_api.openapi.yaml`](./src/ci/transparency/spec/schemas/transparency_api.openapi.yaml) | REST API specification | Draft |

## Implementation

1. Generate provenance tags when posts are created
2. Aggregate tags into time buckets with k-anonymity (k≥100)
3. Expose aggregated data via REST API

See [API documentation](./src/ci/transparency/spec/schemas/transparency_api.openapi.yaml) for complete specification.

## Privacy

- All responses maintain k-anonymity (k≥100)
- Individual posts and users are never exposed
- Rare categories (<5%) are grouped as "other"
- Geographic data limited to country-level

## Versioning

This specification follows semantic versioning.
See CHANGELOG.md for version history.

## License

MIT
asyncio-thread-runner 1.0
Run async code from sync code.
Requires Python: >=3.11
Keywords: async, sync, asyncio, runner, thread

*you can have a little async (as a treat)*


[![build status](https://github.com/lemon24/asyncio-thread-runner/actions/workflows/tests.yaml/badge.svg)](https://github.com/lemon24/asyncio-thread-runner/actions/workflows/tests.yaml)
[![PyPI status](https://img.shields.io/pypi/v/asyncio-thread-runner.svg)](https://pypi.python.org/pypi/asyncio-thread-runner)


**asyncio-thread-runner** allows you to run async code from sync code.

This is useful when you're doing some sync stuff, but:

* you also need to do some async stuff, **without** making **everything async**
* maybe the sync stuff is an existing application
* maybe you still want to use your favorite sync library
* or maybe you need just a little async, without having to pay the full price

Features:

* unlike [asyncio.run()], it provides a **long-lived event loop**
* unlike [asyncio.Runner], it runs in a dedicated thread, and you can use it from **multiple threads**
* it allows you to use **async context managers** and **iterables** from sync code
* check out [this article](https://death.andgravity.com/asyncio-bridge) for why these are useful


Usage:

```shell
$ pip install asyncio-thread-runner
```

```python
>>> async def double(i):
...     return i * 2
...
>>> from asyncio_thread_runner import ThreadRunner
>>> runner = ThreadRunner()
>>> runner.run(double(2))
4
```


Annotated example:

```python
import aiohttp
from asyncio_thread_runner import ThreadRunner

# you can use ThreadRunner as a context manager,
# or call runner.close() when you're done with it
with ThreadRunner() as runner:

    # aiohttp.ClientSession() should be used as an async context manager,
    # enter_context() will exit the context on runner shutdown;
    # because instantiating ClientSession requires a running event loop,
    # we pass it as a factory instead of calling it in the main thread
    session = runner.enter_context(aiohttp.ClientSession)

    # session.get() returns an async context manager...
    request = session.get('https://death.andgravity.com/asyncio-bridge')
    # which we turn into a normal one with wrap_context()
    with runner.wrap_context(request) as response:

        # response.content is an async iterator;
        # we turn it into a normal iterator with wrap_iter()
        lines = list(runner.wrap_iter(response.content))

    # "got 935 lines"
    print('got', len(lines), 'lines')

```


[asyncio.run()]: https://docs.python.org/3/library/asyncio-runner.html#asyncio.run
[asyncio.Runner]: https://docs.python.org/3/library/asyncio-runner.html#asyncio.Runner
autochange 0.1.1
Lightweight semantic version + changelog manager
Requires Python: >=3.8
Keywords: changelog, semantic versioning, release, automation

# autochange

Lightweight semantic version + changelog manager.

## Features

- Maintain a markdown `CHANGELOG.md` with sections: Added, Changed, Deprecated, Removed, Fixed, Security.
- Add unreleased changes quickly.
- Release and automatically stamp date + version.
- Compute next semantic version via bump parts (major/minor/patch) or explicit version.
- Import Conventional Commits directly into the unreleased section.

## Install

```zsh
pip install autochange
```

#### Development dependencies

```zsh
pip install -e .[dev]
```

## Usage

```zsh
autochange init               # create CHANGELOG.md
autochange add -t added "New feature" --scope api
autochange add -t fixed "Bug in parser"
autochange release minor      # bumps minor based on last release
autochange release auto --tag --commit --push  # infer bump from changes, commit, tag and push
autochange import-commits --since v0.1.0  # parse commits after tag v0.1.0
autochange tag                # create git tag for latest released version
autochange tag 1.2.3 --push   # create & push tag v1.2.3
```

## Changelog Format

Subset of [Keep a Changelog](https://keepachangelog.com). Example:

```
# Changelog

## Unreleased - UNRELEASED
### Added
- (api) New feature

## 0.1.0 - 2025-08-13
### Fixed
- Parser bug
```

## Roadmap

- [x] Conventional commit parser integration.
- [x] Auto-detect bump type from unreleased changes.
- [x] Git tag creation helper.
- [ ] Export JSON.
- [ ] Supporting different environments (e.g. package.json, Cargo.toml).
mozarbot 0.1.9
SDK para automações do Mozarbot
Requires Python: >=3.10

# RPA Client

## Instalação

```bash
pip install mozarbot
```

## Como usar?

```python
from mozarbot.sdk import rpa

rpa.info(task_id, message)
```

## Documentação

### Para gerar alertas

```python
rpa.info(task_id, message)
rpa.error(task_id, message)
rpa.warning(task_id, message)
```

### Para retornar informações da execução atual

```python
rpa.get_execution_data()
```
O retorno é um JSON com as informações da execução atual, com os seguintes campos:

```json
{
  task: {
    id: string # ID da execução
    robotId: string # ID do robô
    runnerId: string # ID do runner
    automationId: string # ID da automação
  } | null
}
```

### Para retornar informações dos parametros da execução atual

```python
rpa.get_params(automation_id)
```
O retorno é um JSON com os parametros da execução atual, com os seguintes campos:

```json
{
  parameters: [
    {
      id: string # ID do parametro
      type: string # Tipo do parametro
      label: string # Label do parametro
      required: boolean # Se o parametro é obrigatório
      defaultValue: string # Valor default do parametro
    }
  ]
}
```

### Para retornar os secrets do automação

```python
# label é opcional
rpa.get_secrets(label)
```
O retorno é um JSON com os secrets da automação, com os seguintes campos:

```json
{
  secrets: [
    {
      id: string
      label: string
      value: string
    }
  ]
}
```

### Para reportar o tempo de execução da task

```python
rpa.report_saving(task_id, automation_id, time_spent)
```